@usine/engine 0.0.1 → 0.2.0

package/dist/store/codec.d.ts

@@ -0,0 +1,495 @@
+import { Agent } from "@usine/core/agent";
+import { BrainSpec } from "@usine/core/agent/brain";
+import { Attempt } from "@usine/core/attempt";
+import * as AttemptChannel from "@usine/core/attempt/channel";
+import { Event } from "@usine/core/event";
+import { Run } from "@usine/core/run";
+import { Step } from "@usine/core/step";
+import * as RunState from "@usine/core/run/state";
+import { StepResult } from "@usine/core/step/result";
+import { Effect, Schema } from "effect";
+import { RunStoreError } from "../engine/error.ts";
+import { Submission } from "../engine/submission.ts";
+import { RunSummary } from "../run-reader/model.ts";
+import { TranscriptEntry } from "../transcript.ts";
+export declare const EventRouteRow: Schema.Struct<{
+    readonly eventId: Schema.brand<Schema.NonEmptyString, "EventId">;
+    readonly dedupKey: Schema.brand<Schema.NonEmptyString, "DedupKey">;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly receivedAt: Schema.DateTimeUtcFromString;
+    readonly itemKey: Schema.brand<Schema.NonEmptyString, "ItemKey">;
+    readonly loop: Schema.brand<Schema.NonEmptyString, "LoopName">;
+    readonly step: Schema.brand<Schema.NonEmptyString, "StepName">;
+    readonly approval: Schema.Literals<readonly ["none", "required"]>;
+    readonly cycleLimit: Schema.NullOr<Schema.brand<Schema.Int, "CycleLimit">>;
+    readonly cycleGeneration: Schema.brand<Schema.Int, "CycleGeneration">;
+    readonly repository: Schema.brand<Schema.String, "RepositoryName">;
+    readonly revision: Schema.brand<Schema.String, "RepositoryRevision">;
+    readonly task: Schema.brand<Schema.String, "AttemptTask">;
+    readonly agent: typeof Agent;
+    readonly parentModel: Schema.NullOr<Schema.brand<Schema.String, "ModelId">>;
+}>;
+export type EventRouteRow = typeof EventRouteRow.Type;
+export declare const RunRow: Schema.Struct<{
+    readonly itemKey: Schema.brand<Schema.NonEmptyString, "ItemKey">;
+    readonly repository: Schema.brand<Schema.String, "RepositoryName">;
+    readonly revision: Schema.brand<Schema.String, "RepositoryRevision">;
+    readonly task: Schema.brand<Schema.String, "AttemptTask">;
+    readonly agent: typeof Agent;
+    readonly parentModel: Schema.NullOr<Schema.brand<Schema.String, "ModelId">>;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "RunId">;
+    readonly eventId: Schema.brand<Schema.NonEmptyString, "EventId">;
+    readonly loop: Schema.brand<Schema.NonEmptyString, "LoopName">;
+    readonly state: Schema.Union<readonly [typeof RunState.Pending, typeof RunState.Waiting, typeof RunState.Queued, typeof RunState.Running, typeof RunState.Succeeded, typeof RunState.Failed, typeof RunState.Canceled]>;
+    readonly openedAt: Schema.DateTimeUtcFromString;
+    readonly stepName: Schema.brand<Schema.NonEmptyString, "StepName">;
+    readonly result: Schema.NullOr<typeof StepResult>;
+}>;
+export type RunRow = typeof RunRow.Type;
+export declare const AttemptRow: Schema.Struct<{
+    readonly attemptId: Schema.brand<Schema.NonEmptyString, "AttemptId">;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "RunId">;
+    readonly stepName: Schema.brand<Schema.NonEmptyString, "StepName">;
+    readonly worker: Schema.brand<Schema.String, "WorkerName">;
+    readonly number: Schema.brand<Schema.Int, "AttemptNumber">;
+    readonly brain: typeof BrainSpec;
+    readonly parentModel: Schema.NullOr<Schema.brand<Schema.String, "ModelId">>;
+    readonly startedAt: Schema.DateTimeUtcFromString;
+    readonly outcome: Schema.NullOr<Schema.Union<readonly [typeof import("@usine/core/attempt/outcome").AttemptSucceeded, typeof import("@usine/core/attempt/outcome").AttemptFailed, typeof import("@usine/core/attempt/outcome").AttemptCanceled]>>;
+}>;
+export type AttemptRow = typeof AttemptRow.Type;
+export declare const TranscriptRow: Schema.Struct<{
+    readonly sequence: Schema.brand<Schema.Int, "TranscriptSequence">;
+    readonly attemptId: Schema.brand<Schema.NonEmptyString, "AttemptId">;
+    readonly direction: Schema.Literals<readonly ["inbound", "outbound"]>;
+    readonly envelope: Schema.Union<readonly [Schema.Union<readonly [typeof AttemptChannel.OutboundEnvelope, typeof AttemptChannel.InboundEnvelope]>, Schema.Union<readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"OutboundEnvelope">;
+        readonly attemptId: Schema.brand<Schema.NonEmptyString, "AttemptId">;
+        readonly sequence: Schema.brand<Schema.Int, "AttemptChannelSequence">;
+        readonly sentAt: Schema.DateTimeUtcFromString;
+        readonly payload: Schema.Union<readonly [typeof AttemptChannel.Started, typeof AttemptChannel.SessionEvent, typeof AttemptChannel.Final, typeof AttemptChannel.Failed, typeof AttemptChannel.Interrupted]>;
+        readonly version: Schema.Literal<3>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"InboundEnvelope">;
+        readonly attemptId: Schema.brand<Schema.NonEmptyString, "AttemptId">;
+        readonly sequence: Schema.brand<Schema.Int, "AttemptChannelSequence">;
+        readonly sentAt: Schema.DateTimeUtcFromString;
+        readonly payload: Schema.Union<readonly [typeof AttemptChannel.Steer, typeof AttemptChannel.Interrupt]>;
+        readonly version: Schema.Literal<3>;
+    }>]>]>;
+    readonly receivedAt: Schema.DateTimeUtcFromString;
+}>;
+export type TranscriptRow = typeof TranscriptRow.Type;
+export declare const WorkflowCommandRow: Schema.Struct<{
+    readonly runId: Schema.brand<Schema.NonEmptyString, "RunId">;
+    readonly command: Schema.Literals<readonly ["Approve", "Continue", "Interrupt", "Resume"]>;
+}>;
+export type WorkflowCommandRow = typeof WorkflowCommandRow.Type;
+export declare const decodeEventRoutes: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<readonly {
+    readonly eventId: string & import("effect/Brand").Brand<"EventId">;
+    readonly dedupKey: string & import("effect/Brand").Brand<"DedupKey">;
+    readonly payload: Schema.Json;
+    readonly receivedAt: import("effect/DateTime").Utc;
+    readonly itemKey: string & import("effect/Brand").Brand<"ItemKey">;
+    readonly loop: string & import("effect/Brand").Brand<"LoopName">;
+    readonly step: string & import("effect/Brand").Brand<"StepName">;
+    readonly approval: "none" | "required";
+    readonly cycleLimit: (number & import("effect/Brand").Brand<"CycleLimit">) | null;
+    readonly cycleGeneration: number & import("effect/Brand").Brand<"CycleGeneration">;
+    readonly repository: string & import("effect/Brand").Brand<"RepositoryName">;
+    readonly revision: string & import("effect/Brand").Brand<"RepositoryRevision">;
+    readonly task: string & import("effect/Brand").Brand<"AttemptTask">;
+    readonly agent: Agent;
+    readonly parentModel: (string & import("effect/Brand").Brand<"ModelId">) | null;
+}[], Schema.SchemaError, never>;
+export declare const decodeRunRows: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<readonly {
+    readonly itemKey: string & import("effect/Brand").Brand<"ItemKey">;
+    readonly repository: string & import("effect/Brand").Brand<"RepositoryName">;
+    readonly revision: string & import("effect/Brand").Brand<"RepositoryRevision">;
+    readonly task: string & import("effect/Brand").Brand<"AttemptTask">;
+    readonly agent: Agent;
+    readonly parentModel: (string & import("effect/Brand").Brand<"ModelId">) | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly eventId: string & import("effect/Brand").Brand<"EventId">;
+    readonly loop: string & import("effect/Brand").Brand<"LoopName">;
+    readonly state: RunState.Canceled | RunState.Failed | RunState.Pending | RunState.Queued | RunState.Running | RunState.Succeeded | RunState.Waiting;
+    readonly openedAt: import("effect/DateTime").Utc;
+    readonly stepName: string & import("effect/Brand").Brand<"StepName">;
+    readonly result: StepResult | null;
+}[], Schema.SchemaError, never>;
+export declare const decodeAttemptRows: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<readonly {
+    readonly attemptId: string & import("effect/Brand").Brand<"AttemptId">;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly stepName: string & import("effect/Brand").Brand<"StepName">;
+    readonly worker: string & import("effect/Brand").Brand<"WorkerName">;
+    readonly number: number & import("effect/Brand").Brand<"AttemptNumber">;
+    readonly brain: BrainSpec;
+    readonly parentModel: (string & import("effect/Brand").Brand<"ModelId">) | null;
+    readonly startedAt: import("effect/DateTime").Utc;
+    readonly outcome: import("@usine/core/attempt/outcome").AttemptCanceled | import("@usine/core/attempt/outcome").AttemptFailed | import("@usine/core/attempt/outcome").AttemptSucceeded | null;
+}[], Schema.SchemaError, never>;
+export declare const decodeRecoverableRuns: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<readonly {
+    readonly eventId: string & import("effect/Brand").Brand<"EventId">;
+    readonly dedupKey: string & import("effect/Brand").Brand<"DedupKey">;
+    readonly payload: Schema.Json;
+    readonly receivedAt: import("effect/DateTime").Utc;
+    readonly itemKey: string & import("effect/Brand").Brand<"ItemKey">;
+    readonly loop: string & import("effect/Brand").Brand<"LoopName">;
+    readonly step: string & import("effect/Brand").Brand<"StepName">;
+    readonly approval: "none" | "required";
+    readonly cycleLimit: (number & import("effect/Brand").Brand<"CycleLimit">) | null;
+    readonly cycleGeneration: number & import("effect/Brand").Brand<"CycleGeneration">;
+    readonly repository: string & import("effect/Brand").Brand<"RepositoryName">;
+    readonly revision: string & import("effect/Brand").Brand<"RepositoryRevision">;
+    readonly task: string & import("effect/Brand").Brand<"AttemptTask">;
+    readonly agent: Agent;
+    readonly parentModel: (string & import("effect/Brand").Brand<"ModelId">) | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly state: RunState.Canceled | RunState.Failed | RunState.Pending | RunState.Queued | RunState.Running | RunState.Succeeded | RunState.Waiting;
+}[], Schema.SchemaError, never>;
+export declare const decodeRunIds: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<readonly {
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+}[], Schema.SchemaError, never>;
+export declare const decodeDiscards: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<readonly {
+    readonly reason: "revoked" | "superseded";
+}[], Schema.SchemaError, never>;
+export declare const decodeWorkflowCommands: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<readonly {
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly command: "Approve" | "Continue" | "Interrupt" | "Resume";
+}[], Schema.SchemaError, never>;
+export declare const decodeProjectionRevision: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<readonly {
+    readonly revision: number & import("effect/Brand").Brand<"ProjectionRevision">;
+}[], Schema.SchemaError, never>;
+export declare const decodeTranscriptRows: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<readonly {
+    readonly sequence: number & import("effect/Brand").Brand<"TranscriptSequence">;
+    readonly attemptId: string & import("effect/Brand").Brand<"AttemptId">;
+    readonly direction: "inbound" | "outbound";
+    readonly envelope: AttemptChannel.InboundEnvelope | AttemptChannel.OutboundEnvelope | {
+        readonly _tag: "OutboundEnvelope";
+        readonly attemptId: string & import("effect/Brand").Brand<"AttemptId">;
+        readonly sequence: number & import("effect/Brand").Brand<"AttemptChannelSequence">;
+        readonly sentAt: import("effect/DateTime").Utc;
+        readonly payload: AttemptChannel.Failed | AttemptChannel.Final | AttemptChannel.Interrupted | AttemptChannel.SessionEvent | AttemptChannel.Started;
+        readonly version: 3;
+    } | {
+        readonly _tag: "InboundEnvelope";
+        readonly attemptId: string & import("effect/Brand").Brand<"AttemptId">;
+        readonly sequence: number & import("effect/Brand").Brand<"AttemptChannelSequence">;
+        readonly sentAt: import("effect/DateTime").Utc;
+        readonly payload: AttemptChannel.Interrupt | AttemptChannel.Steer;
+        readonly version: 3;
+    };
+    readonly receivedAt: import("effect/DateTime").Utc;
+}[], Schema.SchemaError, never>;
+export declare const encodePayload: (input: Schema.Json, options?: import("effect/SchemaAST").ParseOptions) => Schema.Json;
+export declare const encodeDateTime: (input: import("effect/DateTime").Utc, options?: import("effect/SchemaAST").ParseOptions) => string;
+export declare const encodeRunState: (input: RunState.Canceled | RunState.Failed | RunState.Pending | RunState.Queued | RunState.Running | RunState.Succeeded | RunState.Waiting, options?: import("effect/SchemaAST").ParseOptions) => {
+    readonly _tag: "Succeeded";
+} | {
+    readonly _tag: "Pending";
+} | {
+    readonly _tag: "Waiting";
+} | {
+    readonly _tag: "Queued";
+} | {
+    readonly _tag: "Running";
+} | {
+    readonly _tag: "Failed";
+} | {
+    readonly _tag: "Canceled";
+    readonly reason: {
+        readonly _tag: "OperatorCanceled";
+    } | {
+        readonly _tag: "Superseded";
+        readonly by: string;
+    } | {
+        readonly _tag: "Revoked";
+    };
+};
+export declare const encodeOutcome: (input: import("@usine/core/attempt/outcome").AttemptCanceled | import("@usine/core/attempt/outcome").AttemptFailed | import("@usine/core/attempt/outcome").AttemptSucceeded, options?: import("effect/SchemaAST").ParseOptions) => {
+    readonly _tag: "Succeeded";
+} | {
+    readonly _tag: "Failed";
+    readonly failure: {
+        readonly _tag: "InfraFailure";
+        readonly message: string;
+        readonly cause: Schema.Json;
+    } | {
+        readonly _tag: "DefectFailure";
+        readonly message: string;
+        readonly cause: Schema.Json;
+    } | {
+        readonly _tag: "AgentFailure";
+        readonly message: string;
+    } | {
+        readonly _tag: "RunawayFailure";
+        readonly ceiling: "tokens" | "wall-clock";
+    } | {
+        readonly _tag: "ChildSessionBudgetFailure";
+        readonly maxChildren: number;
+        readonly attemptedChildren: number;
+    };
+} | {
+    readonly _tag: "Canceled";
+};
+export declare const encodeStepResult: (input: StepResult, options?: import("effect/SchemaAST").ParseOptions) => {
+    readonly message: string;
+    readonly facts: readonly ({
+        readonly _tag: "Commit";
+        readonly sha: string;
+        readonly summary: string;
+    } | {
+        readonly _tag: "PullRequest";
+        readonly number: number;
+        readonly url: string;
+    } | {
+        readonly _tag: "Comment";
+        readonly url: string;
+    })[];
+};
+export declare const encodeEnvelope: (input: AttemptChannel.InboundEnvelope | AttemptChannel.OutboundEnvelope, options?: import("effect/SchemaAST").ParseOptions) => {
+    readonly _tag: "OutboundEnvelope";
+    readonly version: 4;
+    readonly attemptId: string;
+    readonly sequence: number;
+    readonly sentAt: string;
+    readonly payload: {
+        readonly _tag: "Started";
+        readonly parentModel: string;
+    } | {
+        readonly _tag: "SessionEvent";
+        readonly event: {
+            readonly _tag: "SessionStarted";
+            readonly session: {
+                readonly _tag: "ParentSession";
+                readonly id: string;
+                readonly agent: string;
+                readonly brain: {
+                    readonly harness: "claude" | "codex" | "pi";
+                    readonly model: string;
+                    readonly effort: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+                };
+            } | {
+                readonly _tag: "ChildSession";
+                readonly id: string;
+                readonly parentId: string;
+                readonly agent: string;
+                readonly brain: {
+                    readonly harness: "claude" | "codex" | "pi";
+                    readonly model: string;
+                    readonly effort: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+                };
+            };
+        } | {
+            readonly _tag: "TextOutput";
+            readonly session: {
+                readonly _tag: "ParentSession";
+                readonly id: string;
+                readonly agent: string;
+                readonly brain: {
+                    readonly harness: "claude" | "codex" | "pi";
+                    readonly model: string;
+                    readonly effort: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+                };
+            } | {
+                readonly _tag: "ChildSession";
+                readonly id: string;
+                readonly parentId: string;
+                readonly agent: string;
+                readonly brain: {
+                    readonly harness: "claude" | "codex" | "pi";
+                    readonly model: string;
+                    readonly effort: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+                };
+            };
+            readonly text: string;
+        } | {
+            readonly _tag: "ToolStarted";
+            readonly session: {
+                readonly _tag: "ParentSession";
+                readonly id: string;
+                readonly agent: string;
+                readonly brain: {
+                    readonly harness: "claude" | "codex" | "pi";
+                    readonly model: string;
+                    readonly effort: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+                };
+            } | {
+                readonly _tag: "ChildSession";
+                readonly id: string;
+                readonly parentId: string;
+                readonly agent: string;
+                readonly brain: {
+                    readonly harness: "claude" | "codex" | "pi";
+                    readonly model: string;
+                    readonly effort: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+                };
+            };
+            readonly callId: string;
+            readonly tool: string;
+            readonly input: Schema.Json;
+        } | {
+            readonly _tag: "ToolFinished";
+            readonly session: {
+                readonly _tag: "ParentSession";
+                readonly id: string;
+                readonly agent: string;
+                readonly brain: {
+                    readonly harness: "claude" | "codex" | "pi";
+                    readonly model: string;
+                    readonly effort: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+                };
+            } | {
+                readonly _tag: "ChildSession";
+                readonly id: string;
+                readonly parentId: string;
+                readonly agent: string;
+                readonly brain: {
+                    readonly harness: "claude" | "codex" | "pi";
+                    readonly model: string;
+                    readonly effort: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+                };
+            };
+            readonly callId: string;
+            readonly tool: string;
+            readonly output: Schema.Json;
+            readonly isError: boolean;
+        } | {
+            readonly _tag: "PoolRateLimitsUpdated";
+            readonly session: {
+                readonly _tag: "ParentSession";
+                readonly id: string;
+                readonly agent: string;
+                readonly brain: {
+                    readonly harness: "claude" | "codex" | "pi";
+                    readonly model: string;
+                    readonly effort: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+                };
+            } | {
+                readonly _tag: "ChildSession";
+                readonly id: string;
+                readonly parentId: string;
+                readonly agent: string;
+                readonly brain: {
+                    readonly harness: "claude" | "codex" | "pi";
+                    readonly model: string;
+                    readonly effort: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+                };
+            };
+            readonly pool: "apiKeys" | "chatgptPlan" | "claudePlan";
+            readonly rateLimits: {
+                readonly limitId: string | null;
+                readonly limitName: string | null;
+                readonly primary: {
+                    readonly usedPercent: number;
+                    readonly windowDurationMinutes: number | null;
+                    readonly resetsAt: string | null;
+                } | null;
+                readonly secondary: {
+                    readonly usedPercent: number;
+                    readonly windowDurationMinutes: number | null;
+                    readonly resetsAt: string | null;
+                } | null;
+            };
+        } | {
+            readonly _tag: "SessionFinished";
+            readonly session: {
+                readonly _tag: "ParentSession";
+                readonly id: string;
+                readonly agent: string;
+                readonly brain: {
+                    readonly harness: "claude" | "codex" | "pi";
+                    readonly model: string;
+                    readonly effort: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+                };
+            } | {
+                readonly _tag: "ChildSession";
+                readonly id: string;
+                readonly parentId: string;
+                readonly agent: string;
+                readonly brain: {
+                    readonly harness: "claude" | "codex" | "pi";
+                    readonly model: string;
+                    readonly effort: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+                };
+            };
+        };
+    } | {
+        readonly _tag: "Final";
+        readonly result: {
+            readonly message: string;
+            readonly facts: readonly ({
+                readonly _tag: "Commit";
+                readonly sha: string;
+                readonly summary: string;
+            } | {
+                readonly _tag: "PullRequest";
+                readonly number: number;
+                readonly url: string;
+            } | {
+                readonly _tag: "Comment";
+                readonly url: string;
+            })[];
+        };
+    } | {
+        readonly _tag: "Failed";
+        readonly failure: {
+            readonly _tag: "InfraFailure";
+            readonly message: string;
+            readonly cause: Schema.Json;
+        } | {
+            readonly _tag: "DefectFailure";
+            readonly message: string;
+            readonly cause: Schema.Json;
+        } | {
+            readonly _tag: "AgentFailure";
+            readonly message: string;
+        } | {
+            readonly _tag: "RunawayFailure";
+            readonly ceiling: "tokens" | "wall-clock";
+        } | {
+            readonly _tag: "ChildSessionBudgetFailure";
+            readonly maxChildren: number;
+            readonly attemptedChildren: number;
+        };
+    } | {
+        readonly _tag: "Interrupted";
+    };
+} | {
+    readonly _tag: "InboundEnvelope";
+    readonly version: 4;
+    readonly attemptId: string;
+    readonly sequence: number;
+    readonly sentAt: string;
+    readonly payload: {
+        readonly _tag: "Steer";
+        readonly message: string;
+    } | {
+        readonly _tag: "Interrupt";
+    };
+};
+export declare const encodeAgent: (input: Agent, options?: import("effect/SchemaAST").ParseOptions) => {
+    readonly name: string;
+    readonly brain: {
+        readonly harness: "claude" | "codex" | "pi";
+        readonly model: string;
+        readonly effort: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+    };
+    readonly parentModel: string | null;
+    readonly parentEffort?: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+    readonly persona: string;
+};
+export declare const encodeBrainSpec: (input: BrainSpec, options?: import("effect/SchemaAST").ParseOptions) => {
+    readonly harness: "claude" | "codex" | "pi";
+    readonly model: string;
+    readonly effort: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
+};
+export declare const persistence: (operation: string) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, RunStoreError, R>;
+export declare const eventFromRow: (row: EventRouteRow) => Event;
+export declare const submissionFromRow: (row: EventRouteRow) => Submission;
+export declare const runFromRow: (row: RunRow) => Run;
+export declare const stepFromRow: (row: RunRow) => Step;
+export declare const attemptFromRow: (row: AttemptRow) => Attempt;
+export declare const runSummaryFromRow: (row: RunRow, storedAttempts: ReadonlyArray<AttemptRow>) => RunSummary;
+export declare const transcriptEntryFromRow: (row: TranscriptRow) => TranscriptEntry;
+//# sourceMappingURL=codec.d.ts.map

package/dist/store/codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/store/codec.ts"],"names":[],"mappings":"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"}

package/dist/store/codec.js

@@ -0,0 +1,162 @@
+import { Agent } from "@usine/core/agent";
+import { CycleGeneration, CycleLimit } from "@usine/core/cycle-budget";
+import { BrainSpec, ModelId } from "@usine/core/agent/brain";
+import { Attempt, AttemptNumber, AttemptTask, AttemptId } from "@usine/core/attempt";
+import * as AttemptChannel from "@usine/core/attempt/channel";
+import { AttemptOutcome } from "@usine/core/attempt/outcome";
+import { Event, DedupKey, EventId } from "@usine/core/event";
+import { ApprovalRequirement, LoopName } from "@usine/core/loop";
+import { ItemKey } from "@usine/core/item";
+import { RepositoryName, RepositoryRevision } from "@usine/core/repository";
+import { RunId, Run } from "@usine/core/run";
+import { StepName, Step } from "@usine/core/step";
+import { WorkerName } from "@usine/core/worker";
+import * as RunState from "@usine/core/run/state";
+import { StepResult } from "@usine/core/step/result";
+import { Effect, Option, Schema } from "effect";
+import { EnginePersistenceError, RunStoreError } from "../engine/error.js";
+import { IgnoreReason, Submission } from "../engine/submission.js";
+import { ProjectionRevision, RunSummary } from "../run-reader/model.js";
+import { TranscriptEntry, TranscriptSequence } from "../transcript.js";
+import { WorkflowCommand } from "../workflow/command.js";
+export const EventRouteRow = Schema.Struct({
+    eventId: EventId,
+    dedupKey: DedupKey,
+    payload: Schema.Json,
+    receivedAt: Schema.DateTimeUtcFromString,
+    itemKey: ItemKey,
+    loop: LoopName,
+    step: StepName,
+    approval: ApprovalRequirement,
+    cycleLimit: Schema.NullOr(CycleLimit),
+    cycleGeneration: CycleGeneration,
+    repository: RepositoryName,
+    revision: RepositoryRevision,
+    task: AttemptTask,
+    agent: Agent,
+    parentModel: Schema.NullOr(ModelId),
+});
+export const RunRow = Schema.Struct({
+    itemKey: ItemKey,
+    repository: RepositoryName,
+    revision: RepositoryRevision,
+    task: AttemptTask,
+    agent: Agent,
+    parentModel: Schema.NullOr(ModelId),
+    runId: RunId,
+    eventId: EventId,
+    loop: LoopName,
+    state: RunState.RunState,
+    openedAt: Schema.DateTimeUtcFromString,
+    stepName: StepName,
+    result: Schema.NullOr(StepResult),
+});
+export const AttemptRow = Schema.Struct({
+    attemptId: AttemptId,
+    runId: RunId,
+    stepName: StepName,
+    worker: WorkerName,
+    number: AttemptNumber,
+    brain: BrainSpec,
+    parentModel: Schema.NullOr(ModelId),
+    startedAt: Schema.DateTimeUtcFromString,
+    outcome: Schema.NullOr(AttemptOutcome),
+});
+export const TranscriptRow = Schema.Struct({
+    sequence: TranscriptSequence,
+    attemptId: AttemptId,
+    direction: AttemptChannel.Direction,
+    envelope: TranscriptEntry.fields.envelope,
+    receivedAt: Schema.DateTimeUtcFromString,
+});
+const RecoverableRunRow = Schema.Struct({
+    ...EventRouteRow.fields,
+    runId: RunId,
+    state: RunState.RunState,
+});
+const RunIdRow = Schema.Struct({ runId: RunId });
+const DiscardRow = Schema.Struct({ reason: IgnoreReason });
+export const WorkflowCommandRow = Schema.Struct({
+    runId: RunId,
+    command: WorkflowCommand,
+});
+const ProjectionRevisionRow = Schema.Struct({ revision: ProjectionRevision });
+export const decodeEventRoutes = Schema.decodeUnknownEffect(Schema.Array(EventRouteRow));
+export const decodeRunRows = Schema.decodeUnknownEffect(Schema.Array(RunRow));
+export const decodeAttemptRows = Schema.decodeUnknownEffect(Schema.Array(AttemptRow));
+export const decodeRecoverableRuns = Schema.decodeUnknownEffect(Schema.Array(RecoverableRunRow));
+export const decodeRunIds = Schema.decodeUnknownEffect(Schema.Array(RunIdRow));
+export const decodeDiscards = Schema.decodeUnknownEffect(Schema.Array(DiscardRow));
+export const decodeWorkflowCommands = Schema.decodeUnknownEffect(Schema.Array(WorkflowCommandRow));
+export const decodeProjectionRevision = Schema.decodeUnknownEffect(Schema.Array(ProjectionRevisionRow));
+export const decodeTranscriptRows = Schema.decodeUnknownEffect(Schema.Array(TranscriptRow));
+export const encodePayload = Schema.encodeSync(Schema.Json);
+export const encodeDateTime = Schema.encodeSync(Schema.DateTimeUtcFromString);
+export const encodeRunState = Schema.encodeSync(RunState.RunState);
+export const encodeOutcome = Schema.encodeSync(AttemptOutcome);
+export const encodeStepResult = Schema.encodeSync(StepResult);
+export const encodeEnvelope = Schema.encodeSync(AttemptChannel.Envelope);
+export const encodeAgent = Schema.encodeSync(Agent);
+export const encodeBrainSpec = Schema.encodeSync(BrainSpec);
+const isRunStoreError = Schema.is(RunStoreError);
+export const persistence = (operation) => (effect) => Effect.mapError(effect, (error) => isRunStoreError(error) ? error : new EnginePersistenceError({ operation, cause: error }));
+export const eventFromRow = (row) => new Event({
+    id: row.eventId,
+    dedupKey: row.dedupKey,
+    payload: row.payload,
+    receivedAt: row.receivedAt,
+});
+export const submissionFromRow = (row) => new Submission({
+    event: eventFromRow(row),
+    itemKey: row.itemKey,
+    loop: row.loop,
+    step: row.step,
+    approval: row.approval,
+    cycleLimit: Option.fromNullishOr(row.cycleLimit),
+    cycleGeneration: row.cycleGeneration,
+    repository: row.repository,
+    revision: row.revision,
+    task: row.task,
+    agent: row.agent,
+    parentModel: Option.fromNullishOr(row.parentModel),
+});
+export const runFromRow = (row) => new Run({
+    id: row.runId,
+    eventId: row.eventId,
+    loop: row.loop,
+    state: row.state,
+    openedAt: row.openedAt,
+});
+export const stepFromRow = (row) => new Step({
+    runId: row.runId,
+    name: row.stepName,
+    result: Option.fromNullishOr(row.result),
+});
+export const attemptFromRow = (row) => new Attempt({
+    id: row.attemptId,
+    runId: row.runId,
+    stepName: row.stepName,
+    worker: row.worker,
+    number: row.number,
+    brain: row.brain,
+    parentModel: Option.fromNullishOr(row.parentModel),
+    startedAt: row.startedAt,
+    outcome: Option.fromNullishOr(row.outcome),
+});
+export const runSummaryFromRow = (row, storedAttempts) => new RunSummary({
+    itemKey: row.itemKey,
+    run: runFromRow(row),
+    step: stepFromRow(row),
+    attempts: storedAttempts.map(attemptFromRow),
+    repository: row.repository,
+    task: row.task,
+    agent: row.agent,
+});
+export const transcriptEntryFromRow = (row) => new TranscriptEntry({
+    sequence: row.sequence,
+    attemptId: row.attemptId,
+    direction: row.direction,
+    envelope: row.envelope,
+    receivedAt: row.receivedAt,
+});
+//# sourceMappingURL=codec.js.map