@vercel/factory 0.0.12 → 0.0.14

package/dist/engine-DFHU2Pe-.d.mts

@@ -0,0 +1,781 @@
+import { i as StoreDriver } from "./driver-BC0Mt5KG.mjs";
+import { z } from "zod";
+//#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/id.d.ts
+declare const factoryIdSchema: z.ZodString;
+declare const repositoryIdSchema: z.ZodString;
+declare const signalIdSchema: z.ZodString;
+declare const taskIdSchema: z.ZodString;
+declare const changeIdSchema: z.ZodString;
+declare const receiptIdSchema: z.ZodString;
+declare const outboxIdSchema: z.ZodString;
+declare const answerIdSchema: z.ZodString;
+declare const repositoryIdsSchema: z.ZodArray<z.ZodString>;
+type FactoryId = z.infer<typeof factoryIdSchema>;
+type RepositoryId = z.infer<typeof repositoryIdSchema>;
+type SignalId = z.infer<typeof signalIdSchema>;
+type TaskId = z.infer<typeof taskIdSchema>;
+type ChangeId = z.infer<typeof changeIdSchema>;
+type ReceiptId = z.infer<typeof receiptIdSchema>;
+type OutboxId = z.infer<typeof outboxIdSchema>;
+type AnswerId = z.infer<typeof answerIdSchema>;
+//#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<{
+  succeeded: "succeeded";
+  failed: "failed";
+  needs_human: "needs_human";
+  queued: "queued";
+  running: "running";
+  stalled: "stalled";
+  verifying: "verifying";
+  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<{
+    succeeded: "succeeded";
+    failed: "failed";
+    needs_human: "needs_human";
+    queued: "queued";
+    running: "running";
+    stalled: "stalled";
+    verifying: "verifying";
+    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>>;
+  questionTaskId: z.ZodOptional<z.ZodString>;
+  answerEventIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  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/answer.d.ts
+declare const answerEventSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  id: z.ZodString;
+  questionTaskId: z.ZodString;
+  parentTaskId: z.ZodOptional<z.ZodString>;
+  repositoryIds: z.ZodArray<z.ZodString>;
+  replyTo: z.ZodObject<{
+    channel: z.ZodString;
+    address: z.ZodString;
+  }, z.core.$strict>;
+  question: z.ZodString;
+  answer: z.ZodString;
+  answeredBy: z.ZodString;
+  recordedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type AnswerEvent = z.infer<typeof answerEventSchema>;
+//#endregion
+//#region src/schema/session.d.ts
+declare const agentSessionIdSchema: z.ZodString;
+declare const agentSessionSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  id: z.ZodString;
+  owner: z.ZodString;
+  agent: z.ZodString;
+  repositoryId: z.ZodOptional<z.ZodString>;
+  routeId: z.ZodOptional<z.ZodString>;
+  message: z.ZodString;
+  changeId: z.ZodOptional<z.ZodString>;
+  taskId: z.ZodOptional<z.ZodString>;
+  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>>;
+  notifications: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    eventId: z.ZodString;
+    repositoryIds: z.ZodArray<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodString>;
+    changeId: z.ZodOptional<z.ZodString>;
+    replyTo: z.ZodObject<{
+      channel: z.ZodString;
+      address: z.ZodString;
+    }, z.core.$strict>;
+    outcome: z.ZodEnum<{
+      message: "message";
+      accepted: "accepted";
+      started: "started";
+      succeeded: "succeeded";
+      failed: "failed";
+      needs_human: "needs_human";
+      question: "question";
+      digest: "digest";
+      rolled_back: "rolled_back";
+      budget_warning: "budget_warning";
+      budget_exhausted: "budget_exhausted";
+    }>;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  }, z.core.$strict>>>;
+  createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type AgentSession = z.infer<typeof agentSessionSchema>;
+//#endregion
+//#region src/schema/common.d.ts
+declare const SCHEMA_VERSION = 1;
+declare const schemaVersionSchema: z.ZodLiteral<1>;
+declare const isoDateTimeSchema: z.ZodISODateTime;
+declare const usdSchema: z.ZodNumber;
+/**
+ * Open vocabulary value. Standard values ship as exported constants; custom
+ * values matching the pattern are equally valid.
+ */
+declare const vocabularySchema: z.ZodString;
+declare const replyToSchema: z.ZodObject<{
+  channel: z.ZodString;
+  address: z.ZodString;
+}, z.core.$strict>;
+type ReplyTo = z.infer<typeof replyToSchema>;
+//#endregion
+//#region src/schema/communication.d.ts
+declare const communicationOutcomes: readonly ["accepted", "started", "succeeded", "failed", "needs_human", "question", "digest", "rolled_back", "budget_warning", "budget_exhausted", "message"];
+declare const communicationOutcomeSchema: z.ZodEnum<{
+  message: "message";
+  accepted: "accepted";
+  started: "started";
+  succeeded: "succeeded";
+  failed: "failed";
+  needs_human: "needs_human";
+  question: "question";
+  digest: "digest";
+  rolled_back: "rolled_back";
+  budget_warning: "budget_warning";
+  budget_exhausted: "budget_exhausted";
+}>;
+declare const communicationEventSchema: z.ZodObject<{
+  eventId: z.ZodString;
+  repositoryIds: z.ZodArray<z.ZodString>;
+  taskId: z.ZodOptional<z.ZodString>;
+  changeId: z.ZodOptional<z.ZodString>;
+  replyTo: z.ZodObject<{
+    channel: z.ZodString;
+    address: z.ZodString;
+  }, z.core.$strict>;
+  outcome: z.ZodEnum<{
+    message: "message";
+    accepted: "accepted";
+    started: "started";
+    succeeded: "succeeded";
+    failed: "failed";
+    needs_human: "needs_human";
+    question: "question";
+    digest: "digest";
+    rolled_back: "rolled_back";
+    budget_warning: "budget_warning";
+    budget_exhausted: "budget_exhausted";
+  }>;
+  data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+type CommunicationOutcome = z.infer<typeof communicationOutcomeSchema>;
+type CommunicationEvent = z.infer<typeof communicationEventSchema>;
+//#endregion
+//#region src/schema/change.d.ts
+declare const levelSchema: z.ZodEnum<{
+  low: "low";
+  medium: "medium";
+  high: "high";
+}>;
+declare const changeStateSchema: z.ZodEnum<{
+  rolled_back: "rolled_back";
+  verifying: "verifying";
+  ready: "ready";
+  merged: "merged";
+  deployed: "deployed";
+  rolled_out: "rolled_out";
+  closed: "closed";
+}>;
+declare const changeEvidenceSchema: z.ZodObject<{
+  reproVerified: z.ZodBoolean;
+  testsAdded: z.ZodNumber;
+  checksGreen: z.ZodBoolean;
+  attackPassed: z.ZodBoolean;
+  scopeMatches: z.ZodBoolean;
+  previewUrl: z.ZodOptional<z.ZodURL>;
+}, z.core.$strict>;
+declare const changeSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  id: z.ZodString;
+  repositoryId: z.ZodString;
+  taskId: z.ZodOptional<z.ZodString>;
+  groupId: z.ZodOptional<z.ZodString>;
+  prNumber: z.ZodNumber;
+  prUrl: z.ZodURL;
+  author: z.ZodString;
+  risk: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+  }>;
+  confidence: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+  }>;
+  evidence: z.ZodObject<{
+    reproVerified: z.ZodBoolean;
+    testsAdded: z.ZodNumber;
+    checksGreen: z.ZodBoolean;
+    attackPassed: z.ZodBoolean;
+    scopeMatches: z.ZodBoolean;
+    previewUrl: z.ZodOptional<z.ZodURL>;
+  }, z.core.$strict>;
+  state: z.ZodEnum<{
+    rolled_back: "rolled_back";
+    verifying: "verifying";
+    ready: "ready";
+    merged: "merged";
+    deployed: "deployed";
+    rolled_out: "rolled_out";
+    closed: "closed";
+  }>;
+  mergeSha: z.ZodOptional<z.ZodString>;
+  decidedBy: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodISODateTime;
+  updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type Level = z.infer<typeof levelSchema>;
+type ChangeState = z.infer<typeof changeStateSchema>;
+type ChangeEvidence = z.infer<typeof changeEvidenceSchema>;
+type Change = z.infer<typeof changeSchema>;
+//#endregion
+//#region src/schema/outbox.d.ts
+declare const outboxStateSchema: z.ZodEnum<{
+  pending: "pending";
+  delivering: "delivering";
+  delivered: "delivered";
+}>;
+declare const outboxMessageSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  id: z.ZodString;
+  event: z.ZodObject<{
+    eventId: z.ZodString;
+    repositoryIds: z.ZodArray<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodString>;
+    changeId: z.ZodOptional<z.ZodString>;
+    replyTo: z.ZodObject<{
+      channel: z.ZodString;
+      address: z.ZodString;
+    }, z.core.$strict>;
+    outcome: z.ZodEnum<{
+      message: "message";
+      accepted: "accepted";
+      started: "started";
+      succeeded: "succeeded";
+      failed: "failed";
+      needs_human: "needs_human";
+      question: "question";
+      digest: "digest";
+      rolled_back: "rolled_back";
+      budget_warning: "budget_warning";
+      budget_exhausted: "budget_exhausted";
+    }>;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  }, z.core.$strict>;
+  state: z.ZodEnum<{
+    pending: "pending";
+    delivering: "delivering";
+    delivered: "delivered";
+  }>;
+  attempt: z.ZodNumber;
+  availableAt: z.ZodISODateTime;
+  leaseUntil: z.ZodOptional<z.ZodISODateTime>;
+  deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+  lastError: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodISODateTime;
+  updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type OutboxMessage = z.infer<typeof outboxMessageSchema>;
+declare const outboxQueueSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  id: z.ZodString;
+  messages: z.ZodArray<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    event: z.ZodObject<{
+      eventId: z.ZodString;
+      repositoryIds: z.ZodArray<z.ZodString>;
+      taskId: z.ZodOptional<z.ZodString>;
+      changeId: z.ZodOptional<z.ZodString>;
+      replyTo: z.ZodObject<{
+        channel: z.ZodString;
+        address: z.ZodString;
+      }, z.core.$strict>;
+      outcome: z.ZodEnum<{
+        message: "message";
+        accepted: "accepted";
+        started: "started";
+        succeeded: "succeeded";
+        failed: "failed";
+        needs_human: "needs_human";
+        question: "question";
+        digest: "digest";
+        rolled_back: "rolled_back";
+        budget_warning: "budget_warning";
+        budget_exhausted: "budget_exhausted";
+      }>;
+      data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>;
+    state: z.ZodEnum<{
+      pending: "pending";
+      delivering: "delivering";
+      delivered: "delivered";
+    }>;
+    attempt: z.ZodNumber;
+    availableAt: z.ZodISODateTime;
+    leaseUntil: z.ZodOptional<z.ZodISODateTime>;
+    deliveredAt: z.ZodOptional<z.ZodISODateTime>;
+    lastError: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+  }, z.core.$strict>>;
+  updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type OutboxQueue = z.infer<typeof outboxQueueSchema>;
+//#endregion
+//#region src/schema/receipt.d.ts
+/** States the engine writes on transitions. Any vocabulary value is valid. */
+declare const standardReceiptStates: readonly ["approved", "rejected", "queued", "dispatched", "stalled", "succeeded", "failed", "needs_human", "cancelled", "settled", "verifying", "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". */
+declare const standardReceiptKinds: readonly ["coordination", "code_change", "verification", "investigation", "question", "change"];
+declare const receiptStateSchema: z.ZodString;
+declare const receiptPhaseSchema: z.ZodString;
+declare const receiptKindSchema: z.ZodString;
+declare const costSchema: z.ZodObject<{
+  totalUsd: z.ZodNumber;
+}, z.core.$strict>;
+declare const receiptSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  receiptId: z.ZodString;
+  repositoryIds: z.ZodArray<z.ZodString>;
+  taskId: z.ZodOptional<z.ZodString>;
+  changeId: z.ZodOptional<z.ZodString>;
+  kind: z.ZodString;
+  state: z.ZodString;
+  phase: z.ZodOptional<z.ZodString>;
+  reason: z.ZodOptional<z.ZodString>;
+  attempt: z.ZodNumber;
+  cost: z.ZodOptional<z.ZodObject<{
+    totalUsd: z.ZodNumber;
+  }, z.core.$strict>>;
+  decidedBy: z.ZodOptional<z.ZodString>;
+  recordedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type ReceiptState = z.infer<typeof receiptStateSchema>;
+type ReceiptPhase = z.infer<typeof receiptPhaseSchema>;
+type ReceiptKind = z.infer<typeof receiptKindSchema>;
+type Cost = z.infer<typeof costSchema>;
+type Receipt = z.infer<typeof receiptSchema>;
+//#endregion
+//#region src/schema/repository.d.ts
+declare const repositorySlugSchema: z.ZodString;
+declare const repositorySchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  id: z.ZodString;
+  slug: z.ZodString;
+  defaultBranch: z.ZodString;
+  enabled: z.ZodBoolean;
+  dependsOn: z.ZodArray<z.ZodString>;
+  devbox: z.ZodOptional<z.ZodObject<{
+    projectId: z.ZodString;
+    teamId: z.ZodString;
+    snapshot: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  connectedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type RepositorySlug = z.infer<typeof repositorySlugSchema>;
+type Repository = z.infer<typeof repositorySchema>;
+//#endregion
+//#region src/schema/signal.d.ts
+/** Sources used by the standard connectors. Any vocabulary value is valid. */
+declare const standardSignalSources: readonly ["github_issue", "github_pr", "github_pr_comment", "slack", "human", "github_ci_failure", "vercel_deploy_failure", "security_scan", "investigation", "api"];
+declare const signalSourceSchema: z.ZodString;
+declare const signalOutcomeSchema: z.ZodEnum<{
+  accepted: "accepted";
+  duplicate: "duplicate";
+  unactionable: "unactionable";
+  low_confidence: "low_confidence";
+  ignored: "ignored";
+  pending: "pending";
+}>;
+declare const signalSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  id: z.ZodString;
+  repositoryId: z.ZodString;
+  source: z.ZodString;
+  deliveryId: z.ZodString;
+  replyTo: z.ZodObject<{
+    channel: z.ZodString;
+    address: z.ZodString;
+  }, z.core.$strict>;
+  payload: z.ZodUnknown;
+  receivedAt: z.ZodISODateTime;
+  outcome: z.ZodEnum<{
+    accepted: "accepted";
+    duplicate: "duplicate";
+    unactionable: "unactionable";
+    low_confidence: "low_confidence";
+    ignored: "ignored";
+    pending: "pending";
+  }>;
+  detail: z.ZodOptional<z.ZodString>;
+  reason: z.ZodOptional<z.ZodString>;
+  decidedAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>;
+type SignalSource = z.infer<typeof signalSourceSchema>;
+type SignalOutcome = z.infer<typeof signalOutcomeSchema>;
+type Signal = z.infer<typeof signalSchema>;
+//#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 {
+  readonly taskId: TaskId;
+  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;
+  readonly reason: string;
+  constructor(taskId: TaskId, repositoryId: RepositoryId, reason: string);
+}
+declare class OutboxEventConflictError extends Error {
+  constructor(eventId: string);
+}
+declare class AnswerEventConflictError extends Error {
+  constructor(questionTaskId: TaskId);
+}
+interface CreateSignalInput {
+  repositoryId: RepositoryId;
+  source: SignalSource;
+  deliveryId: string;
+  replyTo: ReplyTo;
+  payload: unknown;
+}
+interface DecideSignalOptions {
+  detail?: string;
+  reason?: string;
+}
+interface CreateTaskInput {
+  repositoryIds: RepositoryId[];
+  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. */
+  approval?: "required";
+}
+interface ApprovalDecision {
+  /** Authenticated operator making the decision. */
+  by: string;
+  reason?: string;
+}
+interface AnswerQuestionInput {
+  questionTaskId: TaskId;
+  answer: string;
+  answeredBy: string;
+}
+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;
+  /** Required when a non-question task waits, so validation is a direct read. */
+  questionTaskId?: TaskId;
+  /**
+   * 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;
+  taskId?: TaskId;
+  groupId?: TaskId;
+  prNumber: number;
+  prUrl: string;
+  author: string;
+  risk: Level;
+  confidence: Level;
+  evidence: Change["evidence"];
+}
+type ChangePatch = Partial<Pick<Change, "confidence" | "evidence" | "decidedBy" | "mergeSha">>;
+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;
+  changeId?: ChangeId;
+  kind: string;
+  state: string;
+  phase?: string;
+  reason?: string;
+  attempt?: number;
+  cost?: Cost;
+  decidedBy?: string;
+  /** Same key twice appends one receipt and returns the existing one. */
+  dedupeKey?: string;
+}
+declare class SessionConflictError extends Error {}
+interface FactoryStores {
+  driverName: string;
+  sessions: {
+    create(input: Omit<AgentSession, "schemaVersion" | "id" | "createdAt" | "execution" | "taskId" | "notifications"> & {
+      operationId: string;
+    }): Promise<AgentSession>;
+    get(id: string): Promise<AgentSession | null>;
+    list(): Promise<AgentSession[]>;
+    bind(id: string, reference: {
+      taskId: TaskId;
+    } | {
+      execution: ExecutionReference;
+    }): Promise<AgentSession>;
+    notify(event: CommunicationEvent): Promise<void>;
+  };
+  repositories: {
+    put(repository: Repository): Promise<Repository>;
+    get(id: RepositoryId): Promise<Repository | null>;
+    list(): Promise<Repository[]>;
+  };
+  signals: {
+    create(input: CreateSignalInput): Promise<Signal>;
+    get(id: SignalId): Promise<Signal | null>;
+    decide(id: SignalId, outcome: SignalOutcome, options?: DecideSignalOptions): Promise<Signal>;
+    list(): Promise<Signal[]>;
+  };
+  tasks: {
+    create(input: CreateTaskInput): Promise<Task>;
+    get(id: TaskId): Promise<Task | null>;
+    transition(id: TaskId, to: TaskState, options?: TaskTransitionOptions): Promise<Task>;
+    answerQuestion(input: AnswerQuestionInput): Promise<{
+      answerEvent: AnswerEvent;
+      questionTask: Task;
+      parentTask: Task | null;
+    }>;
+    /** Grant a required approval. The task stays queued; dispatch may now take it. */
+    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: {
+    create(input: CreateChangeInput): Promise<Change>;
+    get(id: ChangeId): Promise<Change | null>;
+    transition(id: ChangeId, to: ChangeState, options?: ChangeTransitionOptions): Promise<Change>;
+    list(): Promise<Change[]>;
+  };
+  receipts: {
+    append(input: AppendReceiptInput): Promise<Receipt>;
+    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;
+    }>;
+  };
+  answers: {
+    get(id: AnswerId): Promise<AnswerEvent | null>;
+  };
+  outbox: {
+    enqueue(event: CommunicationEvent): Promise<OutboxMessage>;
+    get(id: OutboxId): Promise<OutboxMessage | null>;
+    claim(id: OutboxId, leaseMs?: number): Promise<OutboxMessage | null>;
+    retry(id: OutboxId, attempt: number, reason: string, delayMs: number): Promise<OutboxMessage | null>;
+    complete(id: OutboxId, attempt: number): Promise<OutboxMessage | null>;
+    pending(limit?: number): Promise<OutboxMessage[]>;
+  };
+}
+interface CreateStoresOptions {
+  driver: StoreDriver;
+  now?: () => string;
+}
+declare function createStores(options: CreateStoresOptions): FactoryStores;
+//#endregion
+export { Change as $, outboxIdSchema as $t, standardSignalSources as A, coordinationRepositoryIdsSchema as At, costSchema as B, taskStateSchema as Bt, createStores as C, answerEventSchema as Ct, signalOutcomeSchema as D, TaskKind as Dt, SignalSource as E, TaskApproval as Et, Cost as F, taskExecutionRepositoryIdsSchema as Ft, standardReceiptKinds as G, OutboxId as Gt, receiptPhaseSchema as H, AnswerId as Ht, Receipt as I, taskKindSchema as It, OutboxMessage as J, SignalId as Jt, standardReceiptPhases as K, ReceiptId as Kt, ReceiptKind as L, taskOriginSchema as Lt, RepositorySlug as M, harnessSchema as Mt, repositorySchema as N, standardTaskKinds as Nt, signalSchema as O, TaskState as Ot, repositorySlugSchema as P, taskApprovalSchema as Pt, outboxStateSchema as Q, factoryIdSchema as Qt, ReceiptPhase as R, taskQuestionSchema as Rt, TaskTransitionOptions as S, AnswerEvent as St, SignalOutcome as T, Task as Tt, receiptSchema as U, ChangeId as Ut, receiptKindSchema as V, taskUsageSchema as Vt, receiptStateSchema as W, FactoryId as Wt, outboxMessageSchema as X, answerIdSchema as Xt, OutboxQueue as Y, TaskId as Yt, outboxQueueSchema as Z, changeIdSchema as Zt, SessionConflictError as _, usdSchema as _t, ApprovalError as a, Budget as an, changeStateSchema as at, StepUsage as b, agentSessionIdSchema as bt, ChangeTransitionOptions as c, budgetMonthSchema as cn, CommunicationOutcome as ct, CreateStoresOptions as d, communicationOutcomes as dt, receiptIdSchema as en, ChangeEvidence as et, CreateTaskInput as f, ReplyTo as ft, OutboxEventConflictError as g, schemaVersionSchema as gt, FactoryStores as h, replyToSchema as ht, ApprovalDecision as i, taskIdSchema as in, changeSchema as it, Repository as j, executionReferenceSchema as jt, signalSourceSchema as k, TaskUsage as kt, CreateChangeInput as l, budgetSchema as ln, communicationEventSchema as lt, EnsureBudgetInput as m, isoDateTimeSchema as mt, AnswerQuestionInput as n, repositoryIdsSchema as nn, Level as nt, ChangeAssociationError as o, BudgetLimits as on, levelSchema as ot, DecideSignalOptions as p, SCHEMA_VERSION as pt, standardReceiptStates as q, RepositoryId as qt, AppendReceiptInput as r, signalIdSchema as rn, changeEvidenceSchema as rt, ChangePatch as s, budgetLimitsSchema as sn, CommunicationEvent as st, AnswerEventConflictError as t, repositoryIdSchema as tn, ChangeState as tt, CreateSignalInput as u, communicationOutcomeSchema as ut, SettleTaskOptions as v, vocabularySchema as vt, Signal as w, ExecutionReference as wt, TaskPatch as x, agentSessionSchema as xt, SettlementError as y, AgentSession as yt, ReceiptState as z, taskSchema as zt };
+//# sourceMappingURL=engine-DFHU2Pe-.d.mts.map