@vercel/factory 0.0.13 → 0.0.14

package/dist/{dispatch-B77cuPxh.d.mts → engine-DFHU2Pe-.d.mts}

@@ -1,6 +1,52 @@
-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 { 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
@@ -9,13 +55,13 @@ import { z } from "zod";
 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";
-  succeeded: "succeeded";
-  failed: "failed";
-  needs_human: "needs_human";
   cancelled: "cancelled";
 }>;
 declare const taskApprovalSchema: z.ZodEnum<{
@@ -64,13 +110,13 @@ declare const taskSchema: z.ZodObject<{
   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";
-    succeeded: "succeeded";
-    failed: "failed";
-    needs_human: "needs_human";
     cancelled: "cancelled";
   }>;
   approval: z.ZodOptional<z.ZodEnum<{
@@ -116,6 +162,8 @@ declare const taskSchema: z.ZodObject<{
     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;
@@ -128,48 +176,128 @@ 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;
-declare const signalIdSchema: z.ZodString;
-declare const taskIdSchema: z.ZodString;
-declare const changeIdSchema: z.ZodString;
-declare const receiptIdSchema: 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>;
-//#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<{
+//#region src/schema/answer.d.ts
+declare const answerEventSchema: 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>>;
+  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>;
-  notices: z.ZodObject<{
-    warningAt: z.ZodOptional<z.ZodISODateTime>;
-    exhaustedAt: z.ZodOptional<z.ZodISODateTime>;
+  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 BudgetLimits = z.infer<typeof budgetLimitsSchema>;
-type Budget = z.infer<typeof budgetSchema>;
+type CommunicationOutcome = z.infer<typeof communicationOutcomeSchema>;
+type CommunicationEvent = z.infer<typeof communicationEventSchema>;
 //#endregion
 //#region src/schema/change.d.ts
 declare const levelSchema: z.ZodEnum<{
@@ -178,12 +306,12 @@ declare const levelSchema: z.ZodEnum<{
   high: "high";
 }>;
 declare const changeStateSchema: z.ZodEnum<{
+  rolled_back: "rolled_back";
   verifying: "verifying";
   ready: "ready";
   merged: "merged";
   deployed: "deployed";
   rolled_out: "rolled_out";
-  rolled_back: "rolled_back";
   closed: "closed";
 }>;
 declare const changeEvidenceSchema: z.ZodObject<{
@@ -222,12 +350,12 @@ declare const changeSchema: z.ZodObject<{
     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";
-    rolled_back: "rolled_back";
     closed: "closed";
   }>;
   mergeSha: z.ZodOptional<z.ZodString>;
@@ -240,9 +368,103 @@ 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", "dispatched", "stalled", "succeeded", "failed", "needs_human", "cancelled", "settled", "ready", "merged", "deployed", "rolled_out", "rolled_back"];
+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". */
@@ -295,6 +517,46 @@ declare const repositorySchema: z.ZodObject<{
 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 {
@@ -314,6 +576,12 @@ declare class ChangeAssociationError extends Error {
   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;
@@ -344,6 +612,11 @@ interface ApprovalDecision {
   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 {
@@ -358,6 +631,8 @@ interface StepUsage {
 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
@@ -403,8 +678,22 @@ interface AppendReceiptInput {
   /** 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>;
@@ -420,6 +709,11 @@ interface FactoryStores {
     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. */
@@ -465,6 +759,17 @@ interface FactoryStores {
       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;
@@ -472,242 +777,5 @@ interface CreateStoresOptions {
 }
 declare function createStores(options: CreateStoresOptions): FactoryStores;
 //#endregion
-//#region src/schema/finding.d.ts
-declare const findingPrioritySchema: z.ZodEnum<{
-  P0: "P0";
-  P1: "P1";
-  P2: "P2";
-  P3: "P3";
-}>;
-declare const findingCategorySchema: z.ZodEnum<{
-  security: "security";
-  correctness: "correctness";
-  reliability: "reliability";
-  performance: "performance";
-  compatibility: "compatibility";
-  accessibility: "accessibility";
-  documentation: "documentation";
-  maintainability: "maintainability";
-  testing: "testing";
-  usability: "usability";
-}>;
-declare const findingVerificationLevelSchema: z.ZodEnum<{
-  unverified: "unverified";
-  supported: "supported";
-  confirmed: "confirmed";
-}>;
-declare const findingVerificationMethodSchema: z.ZodEnum<{
-  documentation: "documentation";
-  code_inspection: "code_inspection";
-  static_analysis: "static_analysis";
-  manual_reproduction: "manual_reproduction";
-  unit_test: "unit_test";
-  integration_test: "integration_test";
-  e2e_test: "e2e_test";
-  runtime_observation: "runtime_observation";
-}>;
-/**
- * What was done to check the finding. Forces a reporter to distinguish "I
- * think this is a problem" from "I demonstrated it", which is the axis a human
- * approving fixes cares about most.
- */
-declare const findingVerificationSchema: z.ZodObject<{
-  level: z.ZodEnum<{
-    unverified: "unverified";
-    supported: "supported";
-    confirmed: "confirmed";
-  }>;
-  method: z.ZodEnum<{
-    documentation: "documentation";
-    code_inspection: "code_inspection";
-    static_analysis: "static_analysis";
-    manual_reproduction: "manual_reproduction";
-    unit_test: "unit_test";
-    integration_test: "integration_test";
-    e2e_test: "e2e_test";
-    runtime_observation: "runtime_observation";
-  }>;
-  summary: z.ZodString;
-  limitations: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-/** A single problem found in a repository, as a scanner or agent reports it. */
-declare const findingSchema: z.ZodObject<{
-  title: z.ZodString;
-  body: z.ZodString;
-  path: z.ZodOptional<z.ZodString>;
-  line: z.ZodOptional<z.ZodNumber>;
-  endLine: z.ZodOptional<z.ZodNumber>;
-  priority: z.ZodEnum<{
-    P0: "P0";
-    P1: "P1";
-    P2: "P2";
-    P3: "P3";
-  }>;
-  category: z.ZodEnum<{
-    security: "security";
-    correctness: "correctness";
-    reliability: "reliability";
-    performance: "performance";
-    compatibility: "compatibility";
-    accessibility: "accessibility";
-    documentation: "documentation";
-    maintainability: "maintainability";
-    testing: "testing";
-    usability: "usability";
-  }>;
-  verification: z.ZodObject<{
-    level: z.ZodEnum<{
-      unverified: "unverified";
-      supported: "supported";
-      confirmed: "confirmed";
-    }>;
-    method: z.ZodEnum<{
-      documentation: "documentation";
-      code_inspection: "code_inspection";
-      static_analysis: "static_analysis";
-      manual_reproduction: "manual_reproduction";
-      unit_test: "unit_test";
-      integration_test: "integration_test";
-      e2e_test: "e2e_test";
-      runtime_observation: "runtime_observation";
-    }>;
-    summary: z.ZodString;
-    limitations: z.ZodOptional<z.ZodString>;
-  }, z.core.$strict>;
-  tool: z.ZodOptional<z.ZodString>;
-  ruleId: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-type FindingPriority = z.infer<typeof findingPrioritySchema>;
-type FindingCategory = z.infer<typeof findingCategorySchema>;
-type FindingVerification = z.infer<typeof findingVerificationSchema>;
-type Finding = z.infer<typeof findingSchema>;
-/**
- * Stable identity of a finding across scans, used as the signal's delivery id
- * so re-reporting is a no-op instead of a second task. A scanner finding is
- * the same problem when the same tool reports the same rule on the same file;
- * its title is model-written prose and changes between runs, so it is left
- * out. Without a rule id the title is all there is, normalised.
- */
-declare function findingFingerprint(repositoryId: string, finding: Finding): string;
-//#endregion
-//#region src/approval.d.ts
-/**
- * One approval rule. Every listed field must match for the rule to apply;
- * absent fields match anything. Rules are evaluated first-match.
- */
-declare const approvalRuleSchema: z.ZodObject<{
-  source: z.ZodOptional<z.ZodString>;
-  kind: z.ZodOptional<z.ZodString>;
-  priority: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-    P0: "P0";
-    P1: "P1";
-    P2: "P2";
-    P3: "P3";
-  }>>>;
-  require: z.ZodBoolean;
-}, z.core.$strict>;
-declare const approvalPolicySchema: z.ZodArray<z.ZodObject<{
-  source: z.ZodOptional<z.ZodString>;
-  kind: z.ZodOptional<z.ZodString>;
-  priority: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-    P0: "P0";
-    P1: "P1";
-    P2: "P2";
-    P3: "P3";
-  }>>>;
-  require: z.ZodBoolean;
-}, z.core.$strict>>;
-type ApprovalRule = z.infer<typeof approvalRuleSchema>;
-type ApprovalPolicy = z.infer<typeof approvalPolicySchema>;
-/**
- * The default: fixes for security findings wait for a human; everything else
- * runs as it always has. Handoffs between agents (verification) never wait,
- * because a human already approved the work they continue.
- */
-declare const defaultApprovalPolicy: ApprovalPolicy;
-interface ApprovalSubject {
-  source?: string;
-  kind: string;
-  priority?: FindingPriority;
-}
-/**
- * Decide at task-creation time whether a task needs approval. Pure: the answer
- * is stamped on the task and never re-evaluated, so a later policy change
- * cannot silently release work a human was expecting to see.
- */
-declare function requiresApproval(policy: ApprovalPolicy, subject: ApprovalSubject): boolean;
-//#endregion
-//#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
+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