@intentic/sandbox-contract 1.176.3 → 1.209.0

package/dist/contracts/loops.contract.d.ts

@@ -0,0 +1,343 @@
+export declare const loopsContract: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        loops: import("zod").ZodArray<import("zod").ZodObject<{
+            conversationId: import("zod").ZodString;
+            goal: import("zod").ZodString;
+            prompt: import("zod").ZodString;
+            context: import("zod").ZodEnum<{
+                continue: "continue";
+                fresh: "fresh";
+            }>;
+            output: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"none">;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"claim">;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"json">;
+                fields: import("zod").ZodArray<import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    type: import("zod").ZodEnum<{
+                        boolean: "boolean";
+                        number: "number";
+                        string: "string";
+                        "string[]": "string[]";
+                    }>;
+                    description: import("zod").ZodString;
+                    required: import("zod").ZodBoolean;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>], "kind">;
+            checks: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"command">;
+                command: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"judge">;
+                rubric: import("zod").ZodString;
+                model: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>], "kind">>;
+            maxIterations: import("zod").ZodNumber;
+            maxSpendUsd: import("zod").ZodOptional<import("zod").ZodNumber>;
+            stallLimit: import("zod").ZodNumber;
+            isolated: import("zod").ZodBoolean;
+            agent: import("zod").ZodOptional<import("zod").ZodString>;
+            harness: import("zod").ZodOptional<import("zod").ZodEnum<{
+                "claude-code": "claude-code";
+                native: "native";
+            }>>;
+            account: import("zod").ZodOptional<import("zod").ZodString>;
+            model: import("zod").ZodOptional<import("zod").ZodString>;
+            actsAs: import("zod").ZodOptional<import("zod").ZodString>;
+            worktreeBase: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                repo: import("zod").ZodString;
+                base: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>>>;
+            autoLand: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            state: import("zod").ZodEnum<{
+                done: "done";
+                error: "error";
+                exhausted: "exhausted";
+                overspent: "overspent";
+                running: "running";
+                stalled: "stalled";
+                stopped: "stopped";
+            }>;
+            startedAt: import("zod").ZodNumber;
+            endedAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+            resumed: import("zod").ZodNumber;
+            detail: import("zod").ZodOptional<import("zod").ZodString>;
+            iterations: import("zod").ZodArray<import("zod").ZodObject<{
+                n: import("zod").ZodNumber;
+                at: import("zod").ZodNumber;
+                outcome: import("zod").ZodEnum<{
+                    continue: "continue";
+                    done: "done";
+                    error: "error";
+                }>;
+                detail: import("zod").ZodOptional<import("zod").ZodString>;
+                costUsd: import("zod").ZodOptional<import("zod").ZodNumber>;
+                changed: import("zod").ZodBoolean;
+                sessionId: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    start: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        conversationId: import("zod").ZodString;
+        goal: import("zod").ZodString;
+        prompt: import("zod").ZodString;
+        context: import("zod").ZodEnum<{
+            continue: "continue";
+            fresh: "fresh";
+        }>;
+        output: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"none">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"claim">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"json">;
+            fields: import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                type: import("zod").ZodEnum<{
+                    boolean: "boolean";
+                    number: "number";
+                    string: "string";
+                    "string[]": "string[]";
+                }>;
+                description: import("zod").ZodString;
+                required: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>], "kind">;
+        checks: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"command">;
+            command: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"judge">;
+            rubric: import("zod").ZodString;
+            model: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>], "kind">>;
+        maxIterations: import("zod").ZodNumber;
+        maxSpendUsd: import("zod").ZodOptional<import("zod").ZodNumber>;
+        stallLimit: import("zod").ZodNumber;
+        isolated: import("zod").ZodBoolean;
+        agent: import("zod").ZodOptional<import("zod").ZodString>;
+        harness: import("zod").ZodOptional<import("zod").ZodEnum<{
+            "claude-code": "claude-code";
+            native: "native";
+        }>>;
+        account: import("zod").ZodOptional<import("zod").ZodString>;
+        model: import("zod").ZodOptional<import("zod").ZodString>;
+        actsAs: import("zod").ZodOptional<import("zod").ZodString>;
+        worktreeBase: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            repo: import("zod").ZodString;
+            base: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>>;
+        autoLand: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        conversationId: import("zod").ZodString;
+        goal: import("zod").ZodString;
+        prompt: import("zod").ZodString;
+        context: import("zod").ZodEnum<{
+            continue: "continue";
+            fresh: "fresh";
+        }>;
+        output: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"none">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"claim">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"json">;
+            fields: import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                type: import("zod").ZodEnum<{
+                    boolean: "boolean";
+                    number: "number";
+                    string: "string";
+                    "string[]": "string[]";
+                }>;
+                description: import("zod").ZodString;
+                required: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>], "kind">;
+        checks: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"command">;
+            command: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"judge">;
+            rubric: import("zod").ZodString;
+            model: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>], "kind">>;
+        maxIterations: import("zod").ZodNumber;
+        maxSpendUsd: import("zod").ZodOptional<import("zod").ZodNumber>;
+        stallLimit: import("zod").ZodNumber;
+        isolated: import("zod").ZodBoolean;
+        agent: import("zod").ZodOptional<import("zod").ZodString>;
+        harness: import("zod").ZodOptional<import("zod").ZodEnum<{
+            "claude-code": "claude-code";
+            native: "native";
+        }>>;
+        account: import("zod").ZodOptional<import("zod").ZodString>;
+        model: import("zod").ZodOptional<import("zod").ZodString>;
+        actsAs: import("zod").ZodOptional<import("zod").ZodString>;
+        worktreeBase: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            repo: import("zod").ZodString;
+            base: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>>;
+        autoLand: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        state: import("zod").ZodEnum<{
+            done: "done";
+            error: "error";
+            exhausted: "exhausted";
+            overspent: "overspent";
+            running: "running";
+            stalled: "stalled";
+            stopped: "stopped";
+        }>;
+        startedAt: import("zod").ZodNumber;
+        endedAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+        resumed: import("zod").ZodNumber;
+        detail: import("zod").ZodOptional<import("zod").ZodString>;
+        iterations: import("zod").ZodArray<import("zod").ZodObject<{
+            n: import("zod").ZodNumber;
+            at: import("zod").ZodNumber;
+            outcome: import("zod").ZodEnum<{
+                continue: "continue";
+                done: "done";
+                error: "error";
+            }>;
+            detail: import("zod").ZodOptional<import("zod").ZodString>;
+            costUsd: import("zod").ZodOptional<import("zod").ZodNumber>;
+            changed: import("zod").ZodBoolean;
+            sessionId: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    stop: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        conversationId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    designs: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        designs: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            prompt: import("zod").ZodOptional<import("zod").ZodString>;
+            context: import("zod").ZodEnum<{
+                continue: "continue";
+                fresh: "fresh";
+            }>;
+            output: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"none">;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"claim">;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"json">;
+                fields: import("zod").ZodArray<import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    type: import("zod").ZodEnum<{
+                        boolean: "boolean";
+                        number: "number";
+                        string: "string";
+                        "string[]": "string[]";
+                    }>;
+                    description: import("zod").ZodString;
+                    required: import("zod").ZodBoolean;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>], "kind">;
+            checks: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"command">;
+                command: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"judge">;
+                rubric: import("zod").ZodString;
+                model: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>], "kind">>;
+            maxIterations: import("zod").ZodNumber;
+            maxSpendUsd: import("zod").ZodOptional<import("zod").ZodNumber>;
+            stallLimit: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    saveDesign: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        design: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            prompt: import("zod").ZodOptional<import("zod").ZodString>;
+            context: import("zod").ZodEnum<{
+                continue: "continue";
+                fresh: "fresh";
+            }>;
+            output: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"none">;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"claim">;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"json">;
+                fields: import("zod").ZodArray<import("zod").ZodObject<{
+                    name: import("zod").ZodString;
+                    type: import("zod").ZodEnum<{
+                        boolean: "boolean";
+                        number: "number";
+                        string: "string";
+                        "string[]": "string[]";
+                    }>;
+                    description: import("zod").ZodString;
+                    required: import("zod").ZodBoolean;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>], "kind">;
+            checks: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"command">;
+                command: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"judge">;
+                rubric: import("zod").ZodString;
+                model: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>], "kind">>;
+            maxIterations: import("zod").ZodNumber;
+            maxSpendUsd: import("zod").ZodOptional<import("zod").ZodNumber>;
+            stallLimit: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+        create: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        prompt: import("zod").ZodOptional<import("zod").ZodString>;
+        context: import("zod").ZodEnum<{
+            continue: "continue";
+            fresh: "fresh";
+        }>;
+        output: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"none">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"claim">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"json">;
+            fields: import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                type: import("zod").ZodEnum<{
+                    boolean: "boolean";
+                    number: "number";
+                    string: "string";
+                    "string[]": "string[]";
+                }>;
+                description: import("zod").ZodString;
+                required: import("zod").ZodBoolean;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>], "kind">;
+        checks: import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"command">;
+            command: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"judge">;
+            rubric: import("zod").ZodString;
+            model: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>], "kind">>;
+        maxIterations: import("zod").ZodNumber;
+        maxSpendUsd: import("zod").ZodOptional<import("zod").ZodNumber>;
+        stallLimit: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    removeDesign: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+};
+//# sourceMappingURL=loops.contract.d.ts.map

package/dist/contracts/loops.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loops.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/loops.contract.ts"],"names":[],"mappings":"AA+BA,eAAO,MAAM,aAAa;IAGtB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAOJ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAOL,IAAI;;;;;IAIJ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKP,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGV,YAAY;;;;;CACf,CAAC"}

package/dist/contracts/loops.contract.js

@@ -0,0 +1,11 @@
+import { oc } from "@orpc/contract";
+import { LoopDesignIdParamSchema, LoopDesignSaveSchema, LoopDesignSchema, LoopDesignsListSchema, LoopIdParamSchema, LoopRecordSchema, LoopSchema, LoopsListSchema, OkSchema, } from "../schemas.js";
+export const loopsContract = {
+    list: oc.route({ method: "GET", path: "/loops" }).output(LoopsListSchema),
+    start: oc.route({ method: "POST", path: "/loops" }).input(LoopSchema).output(LoopRecordSchema),
+    stop: oc.route({ method: "POST", path: "/loops/{conversationId}/stop" }).input(LoopIdParamSchema).output(OkSchema),
+    designs: oc.route({ method: "GET", path: "/loops/designs" }).output(LoopDesignsListSchema),
+    saveDesign: oc.route({ method: "POST", path: "/loops/designs" }).input(LoopDesignSaveSchema).output(LoopDesignSchema),
+    removeDesign: oc.route({ method: "DELETE", path: "/loops/designs/{id}" }).input(LoopDesignIdParamSchema).output(OkSchema),
+};
+//# sourceMappingURL=loops.contract.js.map

package/dist/contracts/loops.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loops.contract.js","sourceRoot":"","sources":["../../src/contracts/loops.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EACH,uBAAuB,EACvB,oBAAoB,EACpB,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EACjB,gBAAgB,EAChB,UAAU,EACV,eAAe,EACf,QAAQ,GACX,MAAM,eAAe,CAAC;AAoBvB,MAAM,CAAC,MAAM,aAAa,GAAG;IAGzB,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC;IAOzE,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC;IAO9F,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,8BAA8B,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IAIlH,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC,MAAM,CAAC,qBAAqB,CAAC;IAK1F,UAAU,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC;IAGrH,YAAY,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,qBAAqB,EAAE,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CAC5H,CAAC"}

package/dist/contracts/panels.contract.d.ts

@@ -6,6 +6,11 @@ export declare const panelsContract: {
             running: import("zod").ZodBoolean;
             healthy: import("zod").ZodBoolean;
             port: import("zod").ZodOptional<import("zod").ZodNumber>;
+            servers: import("zod").ZodArray<import("zod").ZodObject<{
+                url: import("zod").ZodString;
+                dir: import("zod").ZodOptional<import("zod").ZodString>;
+                session: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>>;
             previewUrl: import("zod").ZodOptional<import("zod").ZodString>;
             role: import("zod").ZodOptional<import("zod").ZodEnum<{
                 app: "app";
@@ -18,6 +23,7 @@ export declare const panelsContract: {
             monorepo: import("zod").ZodBoolean;
             vitest: import("zod").ZodBoolean;
             userStories: import("zod").ZodBoolean;
+            docs: import("zod").ZodBoolean;
         }, import("zod/v4/core").$strip>>;
     }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
     start: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{

package/dist/contracts/panels.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panels.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/panels.contract.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,cAAc;IACvB,IAAI;;;;;;;;;;;;;;;;;;;;;IACJ,KAAK;;;;;IACL,IAAI;;;;;CACP,CAAC"}
+{"version":3,"file":"panels.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/panels.contract.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,cAAc;IACvB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;IACJ,KAAK;;;;;IACL,IAAI;;;;;CACP,CAAC"}

package/dist/contracts/personas.contract.d.ts

@@ -0,0 +1,112 @@
+export declare const personasContract: {
+    list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+        personas: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            label: import("zod").ZodOptional<import("zod").ZodString>;
+            capabilities: import("zod").ZodArray<import("zod").ZodString>;
+            repos: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            powers: import("zod").ZodOptional<import("zod").ZodObject<{
+                files: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    none: "none";
+                    read: "read";
+                    write: "write";
+                }>>;
+                shell: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                code: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                web: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                browser: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                delegate: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                sandbox: import("zod").ZodDefault<import("zod").ZodBoolean>;
+                connectors: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                computers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                mcp: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strip>>;
+            workspace: import("zod").ZodOptional<import("zod").ZodObject<{
+                startIn: import("zod").ZodOptional<import("zod").ZodString>;
+                folders: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strip>>;
+            systemPromptMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+                claude: "claude";
+                custom: "custom";
+                intentic: "intentic";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        connected: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    save: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        label: import("zod").ZodOptional<import("zod").ZodString>;
+        capabilities: import("zod").ZodArray<import("zod").ZodString>;
+        repos: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        powers: import("zod").ZodOptional<import("zod").ZodObject<{
+            files: import("zod").ZodDefault<import("zod").ZodEnum<{
+                none: "none";
+                read: "read";
+                write: "write";
+            }>>;
+            shell: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            code: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            web: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            browser: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            delegate: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            sandbox: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            connectors: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            computers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            mcp: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strip>>;
+        workspace: import("zod").ZodOptional<import("zod").ZodObject<{
+            startIn: import("zod").ZodOptional<import("zod").ZodString>;
+            folders: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        }, import("zod/v4/core").$strip>>;
+        systemPromptMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+            claude: "claude";
+            custom: "custom";
+            intentic: "intentic";
+        }>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    remove: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    kit: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        prompt: import("zod").ZodString;
+        skills: import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            description: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    savePrompt: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        prompt: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    readSkill: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        description: import("zod").ZodString;
+        body: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    saveSkill: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        description: import("zod").ZodString;
+        body: import("zod").ZodString;
+        id: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+    removeSkill: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        ok: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
+};
+//# sourceMappingURL=personas.contract.d.ts.map

package/dist/contracts/personas.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"personas.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/personas.contract.ts"],"names":[],"mappings":"AA8BA,eAAO,MAAM,gBAAgB;IACzB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEJ,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IASJ,MAAM;;;;;IAIN,GAAG;;;;;;;;;IAGH,UAAU;;;;;;IACV,SAAS;;;;;;;;IAGT,SAAS;;;;;;;;IACT,WAAW;;;;;;CACd,CAAC"}

package/dist/contracts/personas.contract.js

@@ -0,0 +1,13 @@
+import { oc } from "@orpc/contract";
+import { OkSchema, PersonaIdParamSchema, PersonaKitSchema, PersonaPromptSchema, PersonaSchema, PersonasListSchema, PersonaSkillBodySchema, PersonaSkillNameSchema, PersonaSkillSchema, } from "../schemas.js";
+export const personasContract = {
+    list: oc.route({ method: "GET", path: "/personas" }).output(PersonasListSchema),
+    save: oc.route({ method: "POST", path: "/personas" }).input(PersonaSchema).output(OkSchema),
+    remove: oc.route({ method: "DELETE", path: "/personas/{id}" }).input(PersonaIdParamSchema).output(OkSchema),
+    kit: oc.route({ method: "GET", path: "/personas/{id}/kit" }).input(PersonaIdParamSchema).output(PersonaKitSchema),
+    savePrompt: oc.route({ method: "POST", path: "/personas/{id}/prompt" }).input(PersonaPromptSchema).output(OkSchema),
+    readSkill: oc.route({ method: "GET", path: "/personas/{id}/skills/read" }).input(PersonaSkillNameSchema).output(PersonaSkillBodySchema),
+    saveSkill: oc.route({ method: "POST", path: "/personas/{id}/skills" }).input(PersonaSkillSchema).output(OkSchema),
+    removeSkill: oc.route({ method: "POST", path: "/personas/{id}/skills/remove" }).input(PersonaSkillNameSchema).output(OkSchema),
+};
+//# sourceMappingURL=personas.contract.js.map

package/dist/contracts/personas.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"personas.contract.js","sourceRoot":"","sources":["../../src/contracts/personas.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EACH,QAAQ,EACR,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,EACnB,aAAa,EACb,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,kBAAkB,GACrB,MAAM,eAAe,CAAC;AAmBvB,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAE/E,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IAS3F,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IAI3G,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,oBAAoB,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC;IAGjH,UAAU,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,uBAAuB,EAAE,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IACnH,SAAS,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,4BAA4B,EAAE,CAAC,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC,MAAM,CAAC,sBAAsB,CAAC;IAGvI,SAAS,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,uBAAuB,EAAE,CAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IACjH,WAAW,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,8BAA8B,EAAE,CAAC,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CACjI,CAAC"}

package/dist/contracts/ports.contract.d.ts

@@ -14,6 +14,7 @@ export declare const portsContract: {
             pid: import("zod").ZodOptional<import("zod").ZodNumber>;
             command: import("zod").ZodOptional<import("zod").ZodString>;
             cwd: import("zod").ZodOptional<import("zod").ZodString>;
+            session: import("zod").ZodOptional<import("zod").ZodString>;
             forwarded: import("zod").ZodBoolean;
             previewUrl: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>>;

package/dist/contracts/ports.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ports.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/ports.contract.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa;IACtB,IAAI;;;;;;;;;;;;;;;;;;;IACJ,OAAO;;;;;IACP,SAAS;;;;;CACZ,CAAC"}
+{"version":3,"file":"ports.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/ports.contract.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa;IACtB,IAAI;;;;;;;;;;;;;;;;;;;;IACJ,OAAO;;;;;IACP,SAAS;;;;;CACZ,CAAC"}

package/dist/contracts/prepush.contract.d.ts

@@ -13,6 +13,7 @@ export declare const prepushContract: {
         finishedAt: import("zod").ZodOptional<import("zod").ZodNumber>;
         exitCode: import("zod").ZodOptional<import("zod").ZodNumber>;
         timedOut: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        session: import("zod").ZodOptional<import("zod").ZodString>;
         output: import("zod").ZodString;
     }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
     run: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{

package/dist/contracts/prepush.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prepush.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/prepush.contract.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,eAAe;IACxB,KAAK;;;;;;;;;;;;;;;;IACL,GAAG;;;IACH,MAAM;;;CACT,CAAC"}
+{"version":3,"file":"prepush.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/prepush.contract.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,eAAe;IACxB,KAAK;;;;;;;;;;;;;;;;;IACL,GAAG;;;IACH,MAAM;;;CACT,CAAC"}

package/dist/contracts/prepush.contract.js.map

@@ -1 +1 @@
-{"version":3,"file":"prepush.contract.js","sourceRoot":"","sources":["../../src/contracts/prepush.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAU3D,MAAM,CAAC,MAAM,eAAe,GAAG;IAC3B,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC;IACnF,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IACxE,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CACjF,CAAC"}
+{"version":3,"file":"prepush.contract.js","sourceRoot":"","sources":["../../src/contracts/prepush.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAW3D,MAAM,CAAC,MAAM,eAAe,GAAG;IAC3B,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC;IACnF,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;IACxE,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC;CACjF,CAAC"}

package/dist/contracts/{codex.contract.d.ts → providers.contract.d.ts}

@@ -1,5 +1,13 @@
-export declare const codexContract: {
-    models: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+export declare const providersContract: {
+    models: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<import("zod").ZodObject<{
+        provider: import("zod").ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            gemini: "gemini";
+            grok: "grok";
+            kimi: "kimi";
+        }>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         models: import("zod").ZodArray<import("zod").ZodObject<{
             id: import("zod").ZodString;
             label: import("zod").ZodString;
@@ -13,4 +21,4 @@ export declare const codexContract: {
         default: import("zod").ZodString;
     }, import("zod/v4/core").$strip>, Record<never, never>, Record<never, never>>;
 };
-//# sourceMappingURL=codex.contract.d.ts.map
+//# sourceMappingURL=providers.contract.d.ts.map

package/dist/contracts/providers.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.contract.d.ts","sourceRoot":"","sources":["../../src/contracts/providers.contract.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,iBAAiB;IAG1B,MAAM;;;;;;;;;;;;;;;;;;;;;CACT,CAAC"}

package/dist/contracts/providers.contract.js

@@ -0,0 +1,6 @@
+import { oc } from "@orpc/contract";
+import { ModelsSchema, NativeProviderParamSchema } from "../schemas.js";
+export const providersContract = {
+    models: oc.route({ method: "GET", path: "/providers/{provider}/models" }).input(NativeProviderParamSchema).output(ModelsSchema),
+};
+//# sourceMappingURL=providers.contract.js.map

package/dist/contracts/providers.contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.contract.js","sourceRoot":"","sources":["../../src/contracts/providers.contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAiBxE,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAG7B,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,8BAA8B,EAAE,CAAC,CAAC,KAAK,CAAC,yBAAyB,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC;CAClI,CAAC"}