@vercel/factory 0.0.11 → 0.0.13

package/dist/{approval-CDiBco2V.d.mts → dispatch-B77cuPxh.d.mts}

@@ -1,6 +1,133 @@
-import { i as StoreDriver } from "./driver-CrZsy7sm.mjs";
+import { i as StoreDriver } from "./driver-BJutB0PE.mjs";
 import { c as ReplyTo, n as SignalOutcome, r as SignalSource, t as Signal } from "./signal-CHVEmzvI.mjs";
 import { z } from "zod";
+//#region src/schema/task.d.ts
+/**
+ * Kinds the standard loop understands. Any vocabulary value is valid; the
+ * kind-scoped rules below apply only to these standard kinds.
+ */
+declare const standardTaskKinds: readonly ["coordination", "code_change", "verification", "investigation", "question"];
+declare const taskKindSchema: z.ZodString;
+declare const taskStateSchema: z.ZodEnum<{
+  queued: "queued";
+  running: "running";
+  stalled: "stalled";
+  verifying: "verifying";
+  succeeded: "succeeded";
+  failed: "failed";
+  needs_human: "needs_human";
+  cancelled: "cancelled";
+}>;
+declare const taskApprovalSchema: z.ZodEnum<{
+  required: "required";
+  granted: "granted";
+  denied: "denied";
+}>;
+declare const taskExecutionRepositoryIdsSchema: z.ZodTuple<[z.ZodString], null>;
+declare const coordinationRepositoryIdsSchema: z.ZodTuple<[z.ZodString, z.ZodString], z.ZodString>;
+declare const taskOriginSchema: z.ZodObject<{
+  signalId: z.ZodOptional<z.ZodString>;
+  parentTaskId: z.ZodOptional<z.ZodString>;
+  operator: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const harnessSchema: z.ZodString;
+/**
+ * The provider's handle on the current attempt's execution. Opaque to the
+ * lifecycle: Factory records it so the execution can be inspected or
+ * cancelled, never to mirror the provider's own state machine.
+ */
+declare const executionReferenceSchema: z.ZodObject<{
+  provider: z.ZodString;
+  sessionId: z.ZodString;
+  environmentId: z.ZodOptional<z.ZodString>;
+  harness: z.ZodOptional<z.ZodString>;
+  traceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const taskUsageSchema: z.ZodObject<{
+  costUsd: z.ZodNumber;
+  inputTokens: z.ZodNumber;
+  outputTokens: z.ZodNumber;
+  cacheReadTokens: z.ZodNumber;
+  cacheWriteTokens: z.ZodNumber;
+  steps: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strict>;
+declare const taskQuestionSchema: z.ZodObject<{
+  text: z.ZodString;
+  options: z.ZodArray<z.ZodString>;
+  answer: z.ZodOptional<z.ZodString>;
+  answeredBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const taskSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  id: z.ZodString;
+  repositoryIds: z.ZodArray<z.ZodString>;
+  kind: z.ZodString;
+  area: z.ZodOptional<z.ZodString>;
+  state: z.ZodEnum<{
+    queued: "queued";
+    running: "running";
+    stalled: "stalled";
+    verifying: "verifying";
+    succeeded: "succeeded";
+    failed: "failed";
+    needs_human: "needs_human";
+    cancelled: "cancelled";
+  }>;
+  approval: z.ZodOptional<z.ZodEnum<{
+    required: "required";
+    granted: "granted";
+    denied: "denied";
+  }>>;
+  origin: z.ZodObject<{
+    signalId: z.ZodOptional<z.ZodString>;
+    parentTaskId: z.ZodOptional<z.ZodString>;
+    operator: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>;
+  dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  replyTo: z.ZodObject<{
+    channel: z.ZodString;
+    address: z.ZodString;
+  }, z.core.$strict>;
+  attempt: z.ZodNumber;
+  execution: z.ZodOptional<z.ZodObject<{
+    provider: z.ZodString;
+    sessionId: z.ZodString;
+    environmentId: z.ZodOptional<z.ZodString>;
+    harness: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  lastProgressAt: z.ZodOptional<z.ZodISODateTime>;
+  stalledAt: z.ZodOptional<z.ZodISODateTime>;
+  stalledReason: z.ZodOptional<z.ZodString>;
+  reservedUsd: z.ZodOptional<z.ZodNumber>;
+  reservedAt: z.ZodOptional<z.ZodISODateTime>;
+  usage: z.ZodOptional<z.ZodObject<{
+    costUsd: z.ZodNumber;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    cacheReadTokens: z.ZodNumber;
+    cacheWriteTokens: z.ZodNumber;
+    steps: z.ZodRecord<z.ZodString, z.ZodNumber>;
+  }, z.core.$strict>>;
+  settledUsd: z.ZodOptional<z.ZodNumber>;
+  question: z.ZodOptional<z.ZodObject<{
+    text: z.ZodString;
+    options: z.ZodArray<z.ZodString>;
+    answer: z.ZodOptional<z.ZodString>;
+    answeredBy: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  changeId: z.ZodOptional<z.ZodString>;
+  reportRef: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodISODateTime;
+  updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type TaskApproval = z.infer<typeof taskApprovalSchema>;
+type TaskKind = z.infer<typeof taskKindSchema>;
+type TaskState = z.infer<typeof taskStateSchema>;
+type TaskUsage = z.infer<typeof taskUsageSchema>;
+type ExecutionReference = z.infer<typeof executionReferenceSchema>;
+type Task = z.infer<typeof taskSchema>;
+//#endregion
 //#region src/schema/id.d.ts
 declare const factoryIdSchema: z.ZodString;
 declare const repositoryIdSchema: z.ZodString;
@@ -16,6 +143,34 @@ type TaskId = z.infer<typeof taskIdSchema>;
 type ChangeId = z.infer<typeof changeIdSchema>;
 type ReceiptId = z.infer<typeof receiptIdSchema>;
 //#endregion
+//#region src/schema/budget.d.ts
+declare const budgetMonthSchema: z.ZodString;
+declare const budgetLimitsSchema: z.ZodObject<{
+  totalUsd: z.ZodNumber;
+  investigationUsd: z.ZodNumber;
+  perTaskReservationUsd: z.ZodNumber;
+  warningPercent: z.ZodNumber;
+  perRepositoryUsd: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strict>;
+declare const budgetSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  factoryId: z.ZodString;
+  month: z.ZodString;
+  limits: z.ZodObject<{
+    totalUsd: z.ZodNumber;
+    investigationUsd: z.ZodNumber;
+    perTaskReservationUsd: z.ZodNumber;
+    warningPercent: z.ZodNumber;
+    perRepositoryUsd: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+  }, z.core.$strict>;
+  notices: z.ZodObject<{
+    warningAt: z.ZodOptional<z.ZodISODateTime>;
+    exhaustedAt: z.ZodOptional<z.ZodISODateTime>;
+  }, z.core.$strict>;
+}, z.core.$strict>;
+type BudgetLimits = z.infer<typeof budgetLimitsSchema>;
+type Budget = z.infer<typeof budgetSchema>;
+//#endregion
 //#region src/schema/change.d.ts
 declare const levelSchema: z.ZodEnum<{
   low: "low";
@@ -87,7 +242,7 @@ type Change = z.infer<typeof changeSchema>;
 //#endregion
 //#region src/schema/receipt.d.ts
 /** States the engine writes on transitions. Any vocabulary value is valid. */
-declare const standardReceiptStates: readonly ["approved", "rejected", "dispatched", "succeeded", "failed", "needs_human", "cancelled", "settled", "ready", "merged", "deployed", "rolled_out", "rolled_back"];
+declare const standardReceiptStates: readonly ["approved", "rejected", "dispatched", "stalled", "succeeded", "failed", "needs_human", "cancelled", "settled", "ready", "merged", "deployed", "rolled_out", "rolled_back"];
 /** Phases the standard loop uses. Any vocabulary value is valid. */
 declare const standardReceiptPhases: readonly ["approval", "budget", "dispatch", "implementation", "verification", "pull_request", "cleanup"];
 /** Kinds the standard loop writes: the standard task kinds plus "change". */
@@ -140,100 +295,6 @@ declare const repositorySchema: z.ZodObject<{
 type RepositorySlug = z.infer<typeof repositorySlugSchema>;
 type Repository = z.infer<typeof repositorySchema>;
 //#endregion
-//#region src/schema/task.d.ts
-/**
- * Kinds the standard loop understands. Any vocabulary value is valid; the
- * kind-scoped rules below apply only to these standard kinds.
- */
-declare const standardTaskKinds: readonly ["coordination", "code_change", "verification", "investigation", "question"];
-declare const taskKindSchema: z.ZodString;
-declare const taskStateSchema: z.ZodEnum<{
-  queued: "queued";
-  running: "running";
-  verifying: "verifying";
-  succeeded: "succeeded";
-  failed: "failed";
-  needs_human: "needs_human";
-  cancelled: "cancelled";
-}>;
-declare const taskApprovalSchema: z.ZodEnum<{
-  required: "required";
-  granted: "granted";
-  denied: "denied";
-}>;
-declare const taskExecutionRepositoryIdsSchema: z.ZodTuple<[z.ZodString], null>;
-declare const coordinationRepositoryIdsSchema: z.ZodTuple<[z.ZodString, z.ZodString], z.ZodString>;
-declare const harnessSchema: z.ZodString;
-declare const taskOriginSchema: z.ZodObject<{
-  signalId: z.ZodOptional<z.ZodString>;
-  parentTaskId: z.ZodOptional<z.ZodString>;
-  operator: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-declare const taskDevboxSchema: z.ZodObject<{
-  devboxId: z.ZodString;
-  remoteId: z.ZodString;
-  harness: z.ZodString;
-}, z.core.$strict>;
-declare const taskQuestionSchema: z.ZodObject<{
-  text: z.ZodString;
-  options: z.ZodArray<z.ZodString>;
-  answer: z.ZodOptional<z.ZodString>;
-  answeredBy: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-declare const taskSchema: z.ZodObject<{
-  schemaVersion: z.ZodLiteral<1>;
-  id: z.ZodString;
-  repositoryIds: z.ZodArray<z.ZodString>;
-  kind: z.ZodString;
-  area: z.ZodOptional<z.ZodString>;
-  state: z.ZodEnum<{
-    queued: "queued";
-    running: "running";
-    verifying: "verifying";
-    succeeded: "succeeded";
-    failed: "failed";
-    needs_human: "needs_human";
-    cancelled: "cancelled";
-  }>;
-  approval: z.ZodOptional<z.ZodEnum<{
-    required: "required";
-    granted: "granted";
-    denied: "denied";
-  }>>;
-  origin: z.ZodObject<{
-    signalId: z.ZodOptional<z.ZodString>;
-    parentTaskId: z.ZodOptional<z.ZodString>;
-    operator: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>;
-  dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  replyTo: z.ZodObject<{
-    channel: z.ZodString;
-    address: z.ZodString;
-  }, z.core.$strict>;
-  devbox: z.ZodOptional<z.ZodObject<{
-    devboxId: z.ZodString;
-    remoteId: z.ZodString;
-    harness: z.ZodString;
-  }, z.core.$strict>>;
-  attempt: z.ZodNumber;
-  reservedUsd: z.ZodOptional<z.ZodNumber>;
-  settledUsd: z.ZodOptional<z.ZodNumber>;
-  question: z.ZodOptional<z.ZodObject<{
-    text: z.ZodString;
-    options: z.ZodArray<z.ZodString>;
-    answer: z.ZodOptional<z.ZodString>;
-    answeredBy: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>>;
-  changeId: z.ZodOptional<z.ZodString>;
-  reportRef: z.ZodOptional<z.ZodString>;
-  createdAt: z.ZodISODateTime;
-  updatedAt: z.ZodISODateTime;
-}, z.core.$strict>;
-type TaskApproval = z.infer<typeof taskApprovalSchema>;
-type TaskKind = z.infer<typeof taskKindSchema>;
-type TaskState = z.infer<typeof taskStateSchema>;
-type Task = z.infer<typeof taskSchema>;
-//#endregion
 //#region src/store/engine.d.ts
 /** An approval decision that does not apply to the task's current approval or state. */
 declare class ApprovalError extends Error {
@@ -241,6 +302,12 @@ declare class ApprovalError extends Error {
   readonly reason: string;
   constructor(taskId: TaskId, reason: string);
 }
+/** A settlement that does not apply to the task's current state. */
+declare class SettlementError extends Error {
+  readonly taskId: TaskId;
+  readonly reason: string;
+  constructor(taskId: TaskId, reason: string);
+}
 declare class ChangeAssociationError extends Error {
   readonly taskId: TaskId;
   readonly repositoryId: RepositoryId;
@@ -263,7 +330,10 @@ interface CreateTaskInput {
   kind: Task["kind"];
   origin: Task["origin"];
   replyTo: ReplyTo;
+  /** Same key creates one task and returns it on workflow retries. */
+  dedupeKey?: string;
   area?: string;
+  changeId?: ChangeId;
   dependsOn?: TaskId[];
   question?: Task["question"];
   /** Stamp the task as needing a human decision before dispatch. */
@@ -274,10 +344,26 @@ interface ApprovalDecision {
   by: string;
   reason?: string;
 }
-type TaskPatch = Partial<Pick<Task, "devbox" | "changeId" | "reportRef" | "reservedUsd" | "settledUsd" | "question">>;
+type TaskPatch = Partial<Pick<Task, "changeId" | "reportRef" | "reservedUsd" | "reservedAt" | "question">>;
+/** One completed model step's usage, as eve's step.completed event carries it. */
+interface StepUsage {
+  turnId: string;
+  stepIndex: number;
+  costUsd?: number;
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheReadTokens?: number;
+  cacheWriteTokens?: number;
+}
 interface TaskTransitionOptions {
   patch?: TaskPatch;
   reason?: string;
+  /**
+   * Refuse unless the task is in this state at write time. Closes
+   * check-then-act races where the transition would also be legal from the
+   * state a concurrent writer moved the task into.
+   */
+  expectFrom?: TaskState;
 }
 interface CreateChangeInput {
   repositoryId: RepositoryId;
@@ -295,6 +381,14 @@ interface ChangeTransitionOptions {
   patch?: ChangePatch;
   reason?: string;
 }
+interface EnsureBudgetInput {
+  factoryId: FactoryId;
+  month: string;
+  limits: Budget["limits"];
+}
+interface SettleTaskOptions {
+  reason?: string;
+}
 interface AppendReceiptInput {
   repositoryIds: RepositoryId[];
   taskId?: TaskId;
@@ -330,6 +424,18 @@ interface FactoryStores {
     approve(id: TaskId, decision: ApprovalDecision): Promise<Task>;
     /** Deny a required approval. The task is cancelled with the reason. */
     reject(id: TaskId, decision: ApprovalDecision): Promise<Task>;
+    /**
+     * Record the provider's handle on the running attempt's execution, so the
+     * reconciler can inspect or cancel it. Refused unless the task is running.
+     */
+    recordExecution(id: TaskId, execution: ExecutionReference): Promise<Task>;
+    /** Add one model step's usage to the task. Idempotent per (turnId, stepIndex). Never settles. */
+    recordUsage(id: TaskId, step: StepUsage): Promise<Task>;
+    /**
+     * Record measured cost on a terminal task. Idempotent: an already settled
+     * task returns unchanged and writes no second receipt.
+     */
+    settle(id: TaskId, cost: Cost, options?: SettleTaskOptions): Promise<Task>;
     list(): Promise<Task[]>;
   };
   changes: {
@@ -343,6 +449,22 @@ interface FactoryStores {
     get(id: string): Promise<Receipt | null>;
     list(): Promise<Receipt[]>;
   };
+  budgets: {
+    /**
+     * Insert-once per month; refreshes limits when configuration changed and
+     * preserves notices. Safe under concurrent sweeps.
+     */
+    ensure(input: EnsureBudgetInput): Promise<Budget>;
+    get(month: string): Promise<Budget | null>;
+    /**
+     * Write-once notice stamp. `stamped` is false when the notice was already
+     * set or a concurrent stamp won, so callers notify at most once.
+     */
+    stampNotice(month: string, notice: "warning" | "exhausted"): Promise<{
+      budget: Budget;
+      stamped: boolean;
+    }>;
+  };
 }
 interface CreateStoresOptions {
   driver: StoreDriver;
@@ -515,5 +637,77 @@ interface ApprovalSubject {
  */
 declare function requiresApproval(policy: ApprovalPolicy, subject: ApprovalSubject): boolean;
 //#endregion
-export { Cost as $, FactoryStores as A, repositoryIdsSchema as At, standardTaskKinds as B, ChangePatch as C, RepositoryId as Ct, CreateStoresOptions as D, factoryIdSchema as Dt, CreateSignalInput as E, changeIdSchema as Et, TaskApproval as F, taskOriginSchema as G, taskDevboxSchema as H, TaskKind as I, taskStateSchema as J, taskQuestionSchema as K, TaskState as L, TaskTransitionOptions as M, taskIdSchema as Mt, createStores as N, CreateTaskInput as O, receiptIdSchema as Ot, Task as P, repositorySlugSchema as Q, coordinationRepositoryIdsSchema as R, ChangeAssociationError as S, ReceiptId as St, CreateChangeInput as T, TaskId as Tt, taskExecutionRepositoryIdsSchema as U, taskApprovalSchema as V, taskKindSchema as W, RepositorySlug as X, Repository as Y, repositorySchema as Z, findingVerificationMethodSchema as _, changeSchema as _t, approvalRuleSchema as a, receiptKindSchema as at, ApprovalDecision as b, ChangeId as bt, Finding as c, receiptStateSchema as ct, FindingVerification as d, standardReceiptStates as dt, Receipt as et, findingCategorySchema as f, Change as ft, findingVerificationLevelSchema as g, changeEvidenceSchema as gt, findingSchema as h, Level as ht, approvalPolicySchema as i, costSchema as it, TaskPatch as j, signalIdSchema as jt, DecideSignalOptions as k, repositoryIdSchema as kt, FindingCategory as l, standardReceiptKinds as lt, findingPrioritySchema as m, ChangeState as mt, ApprovalRule as n, ReceiptPhase as nt, defaultApprovalPolicy as o, receiptPhaseSchema as ot, findingFingerprint as p, ChangeEvidence as pt, taskSchema as q, ApprovalSubject as r, ReceiptState as rt, requiresApproval as s, receiptSchema as st, ApprovalPolicy as t, ReceiptKind as tt, FindingPriority as u, standardReceiptPhases as ut, findingVerificationSchema as v, changeStateSchema as vt, ChangeTransitionOptions as w, SignalId as wt, ApprovalError as x, FactoryId as xt, AppendReceiptInput as y, levelSchema as yt, harnessSchema as z };
-//# sourceMappingURL=approval-CDiBco2V.d.mts.map
+//#region src/agent-routes.d.ts
+declare const agentRouteSchema: z.ZodObject<{
+  id: z.ZodString;
+  agent: z.ZodString;
+  taskKind: z.ZodString;
+  description: z.ZodString;
+  permissions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+type AgentRoute = z.infer<typeof agentRouteSchema>;
+type AgentRouteInput = z.input<typeof agentRouteSchema>;
+interface AgentRouteRegistry {
+  readonly routes: readonly AgentRoute[];
+  get(id: string): AgentRoute | undefined;
+  forTaskKind(kind: string): AgentRoute | undefined;
+}
+/**
+ * Define the application-owned routes an agent or workflow may select. Route
+ * descriptions inform judgment; this validated registry remains the authority.
+ */
+declare function defineAgentRoutes(inputs: readonly AgentRouteInput[]): AgentRouteRegistry;
+//#endregion
+//#region src/dispatch.d.ts
+declare class DispatchRefusedError extends Error {
+  readonly taskId: TaskId;
+  readonly reason: string;
+  constructor(taskId: TaskId, reason: string);
+}
+/**
+ * An exhausted budget is definitive, not a retryable refusal: the task has
+ * already been failed and receipted when this throws, so it never re-enters
+ * the sweep. Operator retry recovers it once budget frees up.
+ */
+declare class BudgetExhaustedError extends Error {
+  readonly taskId: TaskId;
+  readonly month: string;
+  readonly spendUsd: number;
+  constructor(taskId: TaskId, month: string, spendUsd: number);
+}
+interface DispatchBudget {
+  limits: Pick<BudgetLimits, "totalUsd" | "perTaskReservationUsd">;
+  /** Defaults to the current UTC month. */
+  month?: string;
+  now?: () => Date;
+}
+interface DispatchOptions {
+  /**
+   * Starts the durable execution for the task (an Eve agent run). Runs after
+   * the task has won the queued -> running transition. Returning the
+   * provider's execution reference records it on the task so the reconciler
+   * can find the run; returning nothing leaves the task reachable only by the
+   * stall window.
+   */
+  launch: (task: Task) => Promise<ExecutionReference | void>;
+  /** How many launches to try before the task fails for good; a failure re-queues for the next sweep. */
+  maxLaunchAttempts?: number;
+  /**
+   * Reserve-before-execution. When set, dispatch refuses definitively once
+   * the month's derived spend cannot fit another reservation, and otherwise
+   * stamps the reservation in the same write that wins queued -> running.
+   */
+  budget?: DispatchBudget;
+}
+declare const DEFAULT_MAX_LAUNCH_ATTEMPTS = 45;
+/**
+ * The handshake between recorded work and execution: win the store-gated
+ * transition (at most one dispatcher can succeed), then start the run. A
+ * launch failure re-queues the task (bumping its attempt) until the attempt
+ * limit, then fails it; a crash between the transition and the launch leaves
+ * a running task with no execution, which the sweep reaps.
+ */
+declare function dispatchTask(stores: FactoryStores, taskId: TaskId, options: DispatchOptions): Promise<Task>;
+//#endregion
+export { Cost as $, taskSchema as $t, AppendReceiptInput as A, TaskId as At, DecideSignalOptions as B, TaskApproval as Bt, findingCategorySchema as C, budgetMonthSchema as Ct, findingVerificationLevelSchema as D, ReceiptId as Dt, findingSchema as E, FactoryId as Et, ChangeTransitionOptions as F, repositoryIdsSchema as Ft, StepUsage as G, executionReferenceSchema as Gt, FactoryStores as H, TaskState as Ht, CreateChangeInput as I, signalIdSchema as It, createStores as J, taskApprovalSchema as Jt, TaskPatch as K, harnessSchema as Kt, CreateSignalInput as L, taskIdSchema as Lt, ApprovalError as M, factoryIdSchema as Mt, ChangeAssociationError as N, receiptIdSchema as Nt, findingVerificationMethodSchema as O, RepositoryId as Ot, ChangePatch as P, repositoryIdSchema as Pt, repositorySlugSchema as Q, taskQuestionSchema as Qt, CreateStoresOptions as R, ExecutionReference as Rt, FindingVerification as S, budgetLimitsSchema as St, findingPrioritySchema as T, ChangeId as Tt, SettleTaskOptions as U, TaskUsage as Ut, EnsureBudgetInput as V, TaskKind as Vt, SettlementError as W, coordinationRepositoryIdsSchema as Wt, RepositorySlug as X, taskKindSchema as Xt, Repository as Y, taskExecutionRepositoryIdsSchema as Yt, repositorySchema as Z, taskOriginSchema as Zt, defaultApprovalPolicy as _, changeSchema as _t, DispatchRefusedError as a, receiptKindSchema as at, FindingCategory as b, Budget as bt, AgentRouteInput as c, receiptStateSchema as ct, defineAgentRoutes as d, standardReceiptStates as dt, taskStateSchema as en, Receipt as et, ApprovalPolicy as f, Change as ft, approvalRuleSchema as g, changeEvidenceSchema as gt, approvalPolicySchema as h, Level as ht, DispatchOptions as i, costSchema as it, ApprovalDecision as j, changeIdSchema as jt, findingVerificationSchema as k, SignalId as kt, AgentRouteRegistry as l, standardReceiptKinds as lt, ApprovalSubject as m, ChangeState as mt, DEFAULT_MAX_LAUNCH_ATTEMPTS as n, ReceiptPhase as nt, dispatchTask as o, receiptPhaseSchema as ot, ApprovalRule as p, ChangeEvidence as pt, TaskTransitionOptions as q, standardTaskKinds as qt, DispatchBudget as r, ReceiptState as rt, AgentRoute as s, receiptSchema as st, BudgetExhaustedError as t, taskUsageSchema as tn, ReceiptKind as tt, agentRouteSchema as u, standardReceiptPhases as ut, requiresApproval as v, changeStateSchema as vt, findingFingerprint as w, budgetSchema as wt, FindingPriority as x, BudgetLimits as xt, Finding as y, levelSchema as yt, CreateTaskInput as z, Task as zt };
+//# sourceMappingURL=dispatch-B77cuPxh.d.mts.map

package/dist/{driver-CrZsy7sm.d.mts → driver-BJutB0PE.d.mts}

@@ -1,5 +1,5 @@
 //#region src/store/driver.d.ts
-type CollectionName = "repositories" | "signals" | "tasks" | "changes" | "receipts";
+type CollectionName = "repositories" | "signals" | "tasks" | "changes" | "receipts" | "budgets";
 interface StoredRecord {
   readonly value: unknown;
   readonly version: number;
@@ -31,4 +31,4 @@ interface StoreDriver {
 }
 //#endregion
 export { StoredEntry as a, StoreDriver as i, RecordExistsError as n, StoredRecord as o, RecordNotFoundError as r, VersionConflictError as s, CollectionName as t };
-//# sourceMappingURL=driver-CrZsy7sm.d.mts.map
+//# sourceMappingURL=driver-BJutB0PE.d.mts.map

package/dist/driver-Bbd25rNM.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"driver-Bbd25rNM.mjs","names":[],"sources":["../src/store/driver.ts"],"sourcesContent":["export type CollectionName = \"repositories\" | \"signals\" | \"tasks\" | \"changes\" | \"receipts\";\n\nexport interface StoredRecord {\n  readonly value: unknown;\n  readonly version: number;\n}\n\nexport interface StoredEntry {\n  readonly id: string;\n  readonly record: StoredRecord;\n}\n\nexport class RecordExistsError extends Error {\n  constructor(collection: CollectionName, id: string) {\n    super(`record \"${id}\" already exists in \"${collection}\"`);\n    this.name = \"RecordExistsError\";\n  }\n}\n\nexport class RecordNotFoundError extends Error {\n  constructor(collection: CollectionName, id: string) {\n    super(`record \"${id}\" not found in \"${collection}\"`);\n    this.name = \"RecordNotFoundError\";\n  }\n}\n\nexport class VersionConflictError extends Error {\n  constructor(collection: CollectionName, id: string, expectedVersion: number) {\n    super(\n      `record \"${id}\" in \"${collection}\" changed since version ${expectedVersion} was read`,\n    );\n    this.name = \"VersionConflictError\";\n  }\n}\n\n/**\n * Raw persistence contract. Drivers store opaque values and enforce nothing\n * about their content; every invariant lives in the engine above. `update`\n * must be an atomic compare-and-swap on `expectedVersion`.\n */\nexport interface StoreDriver {\n  readonly name: string;\n  get(collection: CollectionName, id: string): Promise<StoredRecord | null>;\n  insert(collection: CollectionName, id: string, value: unknown): Promise<void>;\n  update(\n    collection: CollectionName,\n    id: string,\n    value: unknown,\n    expectedVersion: number,\n  ): Promise<void>;\n  list(collection: CollectionName): Promise<readonly StoredEntry[]>;\n}\n"],"mappings":";AAYA,IAAa,oBAAb,cAAuC,MAAM;CAC3C,YAAY,YAA4B,IAAY;EAClD,MAAM,WAAW,GAAG,uBAAuB,WAAW,EAAE;EACxD,KAAK,OAAO;CACd;AACF;AAEA,IAAa,sBAAb,cAAyC,MAAM;CAC7C,YAAY,YAA4B,IAAY;EAClD,MAAM,WAAW,GAAG,kBAAkB,WAAW,EAAE;EACnD,KAAK,OAAO;CACd;AACF;AAEA,IAAa,uBAAb,cAA0C,MAAM;CAC9C,YAAY,YAA4B,IAAY,iBAAyB;EAC3E,MACE,WAAW,GAAG,QAAQ,WAAW,0BAA0B,gBAAgB,UAC7E;EACA,KAAK,OAAO;CACd;AACF"}
+{"version":3,"file":"driver-Bbd25rNM.mjs","names":[],"sources":["../src/store/driver.ts"],"sourcesContent":["export type CollectionName =\n  | \"repositories\"\n  | \"signals\"\n  | \"tasks\"\n  | \"changes\"\n  | \"receipts\"\n  | \"budgets\";\n\nexport interface StoredRecord {\n  readonly value: unknown;\n  readonly version: number;\n}\n\nexport interface StoredEntry {\n  readonly id: string;\n  readonly record: StoredRecord;\n}\n\nexport class RecordExistsError extends Error {\n  constructor(collection: CollectionName, id: string) {\n    super(`record \"${id}\" already exists in \"${collection}\"`);\n    this.name = \"RecordExistsError\";\n  }\n}\n\nexport class RecordNotFoundError extends Error {\n  constructor(collection: CollectionName, id: string) {\n    super(`record \"${id}\" not found in \"${collection}\"`);\n    this.name = \"RecordNotFoundError\";\n  }\n}\n\nexport class VersionConflictError extends Error {\n  constructor(collection: CollectionName, id: string, expectedVersion: number) {\n    super(\n      `record \"${id}\" in \"${collection}\" changed since version ${expectedVersion} was read`,\n    );\n    this.name = \"VersionConflictError\";\n  }\n}\n\n/**\n * Raw persistence contract. Drivers store opaque values and enforce nothing\n * about their content; every invariant lives in the engine above. `update`\n * must be an atomic compare-and-swap on `expectedVersion`.\n */\nexport interface StoreDriver {\n  readonly name: string;\n  get(collection: CollectionName, id: string): Promise<StoredRecord | null>;\n  insert(collection: CollectionName, id: string, value: unknown): Promise<void>;\n  update(\n    collection: CollectionName,\n    id: string,\n    value: unknown,\n    expectedVersion: number,\n  ): Promise<void>;\n  list(collection: CollectionName): Promise<readonly StoredEntry[]>;\n}\n"],"mappings":";AAkBA,IAAa,oBAAb,cAAuC,MAAM;CAC3C,YAAY,YAA4B,IAAY;EAClD,MAAM,WAAW,GAAG,uBAAuB,WAAW,EAAE;EACxD,KAAK,OAAO;CACd;AACF;AAEA,IAAa,sBAAb,cAAyC,MAAM;CAC7C,YAAY,YAA4B,IAAY;EAClD,MAAM,WAAW,GAAG,kBAAkB,WAAW,EAAE;EACnD,KAAK,OAAO;CACd;AACF;AAEA,IAAa,uBAAb,cAA0C,MAAM;CAC9C,YAAY,YAA4B,IAAY,iBAAyB;EAC3E,MACE,WAAW,GAAG,QAAQ,WAAW,0BAA0B,gBAAgB,UAC7E;EACA,KAAK,OAAO;CACd;AACF"}