@vercel/factory 0.0.12 → 0.0.14

package/dist/index.d.mts

@@ -1,8 +1,173 @@
-import { a as StoredEntry, i as StoreDriver, n as RecordExistsError, o as StoredRecord, r as RecordNotFoundError, s as VersionConflictError, t as CollectionName } from "./driver-CrZsy7sm.mjs";
-import { a as factoryConfigSchema, i as factoryConfigRepositorySchema, n as FactoryConfigInput, r as defineFactory, t as FactoryConfig } from "./factory-config-Bu4mklm9.mjs";
-import { a as signalSchema, c as ReplyTo, d as replyToSchema, f as schemaVersionSchema, i as signalOutcomeSchema, l as SCHEMA_VERSION, m as vocabularySchema, n as SignalOutcome, o as signalSourceSchema, p as usdSchema, r as SignalSource, s as standardSignalSources, t as Signal, u as isoDateTimeSchema } from "./signal-CHVEmzvI.mjs";
-import { $ as Cost, A as FactoryStores, At as repositoryIdsSchema, B as standardTaskKinds, C as ChangePatch, Ct as RepositoryId, D as CreateStoresOptions, Dt as factoryIdSchema, E as CreateSignalInput, Et as changeIdSchema, F as TaskApproval, G as taskOriginSchema, H as taskDevboxSchema, I as TaskKind, J as taskStateSchema, K as taskQuestionSchema, L as TaskState, M as TaskTransitionOptions, Mt as taskIdSchema, N as createStores, O as CreateTaskInput, Ot as receiptIdSchema, P as Task, Q as repositorySlugSchema, R as coordinationRepositoryIdsSchema, S as ChangeAssociationError, St as ReceiptId, T as CreateChangeInput, Tt as TaskId, U as taskExecutionRepositoryIdsSchema, V as taskApprovalSchema, W as taskKindSchema, X as RepositorySlug, Y as Repository, Z as repositorySchema, _ as findingVerificationMethodSchema, _t as changeSchema, a as approvalRuleSchema, at as receiptKindSchema, b as ApprovalDecision, bt as ChangeId, c as Finding, ct as receiptStateSchema, d as FindingVerification, dt as standardReceiptStates, et as Receipt, f as findingCategorySchema, ft as Change, g as findingVerificationLevelSchema, gt as changeEvidenceSchema, h as findingSchema, ht as Level, i as approvalPolicySchema, it as costSchema, j as TaskPatch, jt as signalIdSchema, k as DecideSignalOptions, kt as repositoryIdSchema, l as FindingCategory, lt as standardReceiptKinds, m as findingPrioritySchema, mt as ChangeState, n as ApprovalRule, nt as ReceiptPhase, o as defaultApprovalPolicy, ot as receiptPhaseSchema, p as findingFingerprint, pt as ChangeEvidence, q as taskSchema, r as ApprovalSubject, rt as ReceiptState, s as requiresApproval, st as receiptSchema, t as ApprovalPolicy, tt as ReceiptKind, u as FindingPriority, ut as standardReceiptPhases, v as findingVerificationSchema, vt as changeStateSchema, w as ChangeTransitionOptions, wt as SignalId, x as ApprovalError, xt as FactoryId, y as AppendReceiptInput, yt as levelSchema, z as harnessSchema } from "./approval-CIXB8IF8.mjs";
+import { a as DispatchRefusedError, c as AgentRouteInput, d as defineAgentRoutes, i as DispatchOptions, l as AgentRouteRegistry, n as DEFAULT_MAX_LAUNCH_ATTEMPTS, o as dispatchTask, r as DispatchBudget, s as AgentRoute, t as BudgetExhaustedError, u as agentRouteSchema } from "./dispatch-BaZS3PT8.mjs";
+import { $ as Change, $t as outboxIdSchema, A as standardSignalSources, At as coordinationRepositoryIdsSchema, B as costSchema, Bt as taskStateSchema, C as createStores, Ct as answerEventSchema, D as signalOutcomeSchema, Dt as TaskKind, E as SignalSource, Et as TaskApproval, F as Cost, Ft as taskExecutionRepositoryIdsSchema, G as standardReceiptKinds, Gt as OutboxId, H as receiptPhaseSchema, Ht as AnswerId, I as Receipt, It as taskKindSchema, J as OutboxMessage, Jt as SignalId, K as standardReceiptPhases, Kt as ReceiptId, L as ReceiptKind, Lt as taskOriginSchema, M as RepositorySlug, Mt as harnessSchema, N as repositorySchema, Nt as standardTaskKinds, O as signalSchema, Ot as TaskState, P as repositorySlugSchema, Pt as taskApprovalSchema, Q as outboxStateSchema, Qt as factoryIdSchema, R as ReceiptPhase, Rt as taskQuestionSchema, S as TaskTransitionOptions, St as AnswerEvent, T as SignalOutcome, Tt as Task, U as receiptSchema, Ut as ChangeId, V as receiptKindSchema, Vt as taskUsageSchema, W as receiptStateSchema, Wt as FactoryId, X as outboxMessageSchema, Xt as answerIdSchema, Y as OutboxQueue, Yt as TaskId, Z as outboxQueueSchema, Zt as changeIdSchema, _ as SessionConflictError, _t as usdSchema, a as ApprovalError, an as Budget, at as changeStateSchema, b as StepUsage, bt as agentSessionIdSchema, c as ChangeTransitionOptions, cn as budgetMonthSchema, ct as CommunicationOutcome, d as CreateStoresOptions, dt as communicationOutcomes, en as receiptIdSchema, et as ChangeEvidence, f as CreateTaskInput, ft as ReplyTo, g as OutboxEventConflictError, gt as schemaVersionSchema, h as FactoryStores, ht as replyToSchema, i as ApprovalDecision, in as taskIdSchema, it as changeSchema, j as Repository, jt as executionReferenceSchema, k as signalSourceSchema, kt as TaskUsage, l as CreateChangeInput, ln as budgetSchema, lt as communicationEventSchema, m as EnsureBudgetInput, mt as isoDateTimeSchema, n as AnswerQuestionInput, nn as repositoryIdsSchema, nt as Level, o as ChangeAssociationError, on as BudgetLimits, ot as levelSchema, p as DecideSignalOptions, pt as SCHEMA_VERSION, q as standardReceiptStates, qt as RepositoryId, r as AppendReceiptInput, rn as signalIdSchema, rt as changeEvidenceSchema, s as ChangePatch, sn as budgetLimitsSchema, st as CommunicationEvent, t as AnswerEventConflictError, tn as repositoryIdSchema, tt as ChangeState, u as CreateSignalInput, ut as communicationOutcomeSchema, v as SettleTaskOptions, vt as vocabularySchema, w as Signal, wt as ExecutionReference, x as TaskPatch, xt as agentSessionSchema, y as SettlementError, yt as AgentSession, z as ReceiptState, zt as taskSchema } from "./engine-DFHU2Pe-.mjs";
+import { a as StoredEntry, i as StoreDriver, n as RecordExistsError, o as StoredRecord, r as RecordNotFoundError, s as VersionConflictError, t as CollectionName } from "./driver-BC0Mt5KG.mjs";
+import { a as defineFactory, c as factoryConfigSchema, i as defaultExecutionPolicy, n as FactoryConfig, o as executionPolicySchema, r as FactoryConfigInput, s as factoryConfigRepositorySchema, t as ExecutionPolicy } from "./factory-config-D2yU3G0c.mjs";
 import { z } from "zod";
+//#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/briefs.d.ts
 /** The finding behind a task, when its signal carries one. */
 declare function findingForTask(stores: FactoryStores, task: Task): Promise<Finding | null>;
@@ -16,6 +181,79 @@ declare function scanBrief(task: Task, repository: Repository): string;
 /** The verifier's starting message for a recorded pull request. */
 declare function verificationBrief(task: Task, repository: Repository, change: Change): string;
 //#endregion
+//#region src/budget.d.ts
+/**
+ * Stable factory identity for budget rows. Nothing mints factory ids yet, so
+ * the app derives one from a deployment-stable seed such as the Vercel
+ * project id.
+ */
+declare function deriveFactoryId(seed: string): FactoryId;
+/** The budget month ("YYYY-MM", UTC) a timestamp falls into. */
+declare function budgetMonthOf(isoDateTime: string): string;
+/**
+ * Monthly spend is derived from task rows, never stored: each task counts its
+ * settled cost once that exists, otherwise its held reservation. A task
+ * settles once, so a settled row never also counts its reservation.
+ * Attribution uses the reservation time so tasks that wait across a month
+ * boundary charge the month they actually ran in.
+ */
+declare function computeMonthSpendUsd(tasks: readonly Task[], month: string): number;
+type BudgetStatus = "ok" | "warning" | "exhausted";
+/**
+ * True when one more per-task slice fits under the monthly total. Dispatch
+ * refuses on this exact predicate and budgetStatus reports "exhausted" on its
+ * negation, so refusing and reporting can never disagree.
+ */
+declare function canReserve(spendUsd: number, limits: Pick<BudgetLimits, "totalUsd" | "perTaskReservationUsd">): boolean;
+declare function budgetStatus(spendUsd: number, limits: Pick<BudgetLimits, "totalUsd" | "perTaskReservationUsd" | "warningPercent">): BudgetStatus;
+interface SettleSweepOptions {
+  /** How long a terminal task waits for late usage before the sweep settles it. */
+  graceMinutes?: number;
+  now?: () => Date;
+}
+interface SettleSweepResult {
+  settled: {
+    taskId: TaskId;
+    totalUsd: number;
+  }[];
+}
+/**
+ * Settle reserved terminal tasks the session hook did not: a task that ended
+ * after its session (a change verified later) or whose session died. Settles
+ * at the recorded usage, or at zero with a warning reason when none was
+ * recorded within the grace window.
+ */
+declare function sweepSettlements(stores: FactoryStores, options?: SettleSweepOptions): Promise<SettleSweepResult>;
+interface BudgetNotice {
+  outcome: "budget_warning" | "budget_exhausted";
+  month: string;
+  spendUsd: number;
+  limits: BudgetLimits;
+}
+interface BudgetSweepOptions {
+  factoryId: FactoryId;
+  limits: BudgetLimits;
+  /** Defaults to the current UTC month. */
+  month?: string;
+  now?: () => Date;
+  /** Owner-only delivery; invoked at most once per month per outcome. */
+  notify?: (notice: BudgetNotice) => Promise<void>;
+}
+interface BudgetSweepResult {
+  month: string;
+  spendUsd: number;
+  status: BudgetStatus;
+  warned: boolean;
+  exhausted: boolean;
+}
+/**
+ * Ensure the month's budget row, derive spend, and record threshold crossings
+ * write-once. Delivery comes first and the stamp only lands after it, so a
+ * failed notification retries on the next sweep instead of being lost; the
+ * write-once stamp still keeps each threshold to one message per month.
+ */
+declare function sweepBudget(stores: FactoryStores, options: BudgetSweepOptions): Promise<BudgetSweepResult>;
+//#endregion
 //#region src/changes.d.ts
 interface AdoptPullRequestInput {
   repositoryId: RepositoryId;
@@ -26,11 +264,19 @@ interface AdoptPullRequestInput {
 declare function adoptPullRequest(stores: Pick<FactoryStores, "changes">, input: AdoptPullRequestInput): Promise<Change>;
 //#endregion
 //#region src/coordination.d.ts
-interface CreateCoordinationInput {
+interface CreateCoordinationInputBase {
   repositoryIds: readonly [RepositoryId, RepositoryId, ...RepositoryId[]];
-  signalId: SignalId;
   replyTo: ReplyTo;
+  /** Same key recreates neither the parent nor its repository-scoped children. */
+  dedupeKey?: string;
 }
+type CreateCoordinationInput = CreateCoordinationInputBase & ({
+  signalId: SignalId;
+  operator?: never;
+} | {
+  operator: string;
+  signalId?: never;
+});
 interface CoordinationPlan {
   parent: Task;
   children: readonly Task[];
@@ -57,33 +303,6 @@ declare function createCoordination(stores: FactoryStores, input: CreateCoordina
 /** Reconcile a coordination parent from its direct children without ever dispatching the parent. */
 declare function reconcileCoordination(stores: FactoryStores, parentTaskId: TaskId, options: ReconcileCoordinationOptions): Promise<CoordinationReconciliation>;
 //#endregion
-//#region src/dispatch.d.ts
-declare class DispatchRefusedError extends Error {
-  readonly taskId: TaskId;
-  readonly reason: string;
-  constructor(taskId: TaskId, reason: string);
-}
-interface DispatchOptions {
-  /**
-   * Starts the durable execution for the task (an Eve agent run). Runs after
-   * the task has won the queued -> running transition. The execution owns its
-   * own provisioning: it creates its Devbox as its first step and patches the
-   * task record with the result.
-   */
-  launch: (task: Task) => Promise<void>;
-  /** How many launches to try before the task fails for good; a failure re-queues for the next sweep. */
-  maxLaunchAttempts?: number;
-}
-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
 //#region src/metrics.d.ts
 /**
  * The derived review bucket from the default risk x confidence table. Derived
@@ -140,6 +359,8 @@ interface HealthOptions {
   now?: Date;
   /** Open-change cap from factory configuration; omitted disables that check. */
   maxOpenChanges?: number;
+  /** Minutes an eligible executable task may remain queued before health turns yellow. Default 5. */
+  maxQueuedMinutes?: number;
 }
 interface RepositoryHealth {
   color: HealthColor;
@@ -147,32 +368,13 @@ interface RepositoryHealth {
   reasons: string[];
 }
 /**
- * Green, yellow, or red from rows, never from a model. Budget and onboarding
- * signals are not evaluated yet: budgets do not settle and onboarding
- * investigations are not recorded, so those spec rules have no rows to read.
+ * Green, yellow, or red from rows, never from a model. Budget threshold and
+ * onboarding rules are not evaluated here yet: budget notices live on the
+ * budgets collection (not in these rows), and onboarding investigations are
+ * not recorded.
  */
 declare function computeRepositoryHealth(rows: LedgerRows, options?: HealthOptions): RepositoryHealth;
 //#endregion
-//#region src/schema/budget.d.ts
-declare const budgetMonthSchema: z.ZodString;
-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 Budget = z.infer<typeof budgetSchema>;
-//#endregion
 //#region src/schema/transitions.d.ts
 type TransitionActor = "system" | "reconciler" | "foreman" | "operator" | "webhook" | "human";
 interface Transition<State extends string> {
@@ -209,24 +411,52 @@ interface SignalCreator {
  */
 declare function createSignalCreator(stores: Pick<FactoryStores, "signals">): SignalCreator;
 //#endregion
+//#region src/stall.d.ts
+interface StallSweepOptions {
+  policy: ExecutionPolicy;
+  now?: () => Date;
+}
+interface StallSweepResult {
+  stalled: TaskId[];
+  requeued: TaskId[];
+  failed: TaskId[];
+}
+declare function stallWindowMinutes(policy: ExecutionPolicy, kind: Task["kind"]): number;
+/**
+ * The reconciler's stall pass. A running task whose execution has not
+ * progressed within its stall window is marked stalled; a stalled task is
+ * re-queued for a replacement attempt while attempts remain, and failed once
+ * they are exhausted. Only `running` tasks can stall: a task whose result has
+ * already been recorded (verifying, or terminal) is never retried by this
+ * pass. Coordination parents run only through their children and are skipped.
+ */
+declare function sweepStalled(stores: FactoryStores, options: StallSweepOptions): Promise<StallSweepResult>;
+//#endregion
 //#region src/store/memory.d.ts
 declare function createInMemoryDriver(): StoreDriver;
 //#endregion
 //#region src/sweep.d.ts
-/** Starts the agent for one task kind. Supplied by the app, which knows its agents' addresses. */
-type TaskLauncher = (task: Task, repository: Repository) => Promise<void>;
+/**
+ * Starts the agent for one task kind. Supplied by the app, which knows its
+ * agents' addresses. Returns the provider's execution reference when it has one.
+ */
+type TaskLauncher = (task: Task, repository: Repository) => Promise<ExecutionReference | void>;
 interface SweepOptions {
   /** Launcher per task kind, e.g. code_change -> foreman, security_scan -> security-scanner. */
   launchers: Readonly<Record<string, TaskLauncher>>;
+  /** Reserve-before-execution limits, passed through to every dispatch. */
+  budget?: DispatchBudget;
+  /** Maximum task launches attempted in one pass; omitted means no limit. */
+  maxDispatches?: number;
 }
 interface SweepResult {
   dispatched: string[];
-  /** Tasks left in the queue and why: awaiting approval, no launcher, missing repository. */
+  /** Tasks left in the queue because a declared gate may become eligible later. */
   skipped: {
     taskId: string;
     reason: string;
   }[];
-  /** Tasks whose launch threw; dispatchTask has already recorded them as failed. */
+  /** Tasks whose routing is invalid or whose launch threw. */
   failed: {
     taskId: string;
     reason: string;
@@ -250,5 +480,5 @@ interface VerificationTaskSweep {
 /** Ensure every recorded code change has exactly one durable verification task. */
 declare function ensureVerificationTasks(stores: FactoryStores): Promise<VerificationTaskSweep>;
 //#endregion
-export { AdoptPullRequestInput, AppendReceiptInput, ApprovalDecision, ApprovalError, ApprovalPolicy, ApprovalRule, ApprovalSubject, Budget, Change, ChangeAssociationError, ChangeEvidence, ChangeId, ChangePatch, ChangeState, ChangeTransitionOptions, CollectionName, CoordinationPlan, CoordinationReconciliation, Cost, CreateChangeInput, CreateCoordinationInput, CreateSignalInput, CreateStoresOptions, CreateTaskInput, DEFAULT_MAX_LAUNCH_ATTEMPTS, DecideSignalOptions, DispatchOptions, DispatchRefusedError, FactoryConfig, FactoryConfigInput, FactoryId, FactoryStores, Finding, FindingCategory, FindingPriority, FindingVerification, HealthColor, HealthOptions, InvalidTransitionError, LedgerMetrics, LedgerRows, Level, MetricsOptions, Receipt, ReceiptId, ReceiptKind, ReceiptPhase, ReceiptState, ReconcileCoordinationOptions, RecordExistsError, RecordNotFoundError, ReplyTo, Repository, RepositoryHealth, RepositoryId, RepositorySlug, ReviewBucket, SCHEMA_VERSION, Signal, SignalCreator, SignalId, SignalOutcome, SignalSource, StoreDriver, StoredEntry, StoredRecord, SweepOptions, SweepResult, Task, TaskApproval, TaskId, TaskKind, TaskLauncher, TaskPatch, TaskState, TaskTransitionOptions, Transition, TransitionActor, VerificationTaskSweep, VersionConflictError, adoptPullRequest, approvalPolicySchema, approvalRuleSchema, assertTransition, budgetMonthSchema, budgetSchema, changeEvidenceSchema, changeIdSchema, changeInitialState, changeSchema, changeStateSchema, changeTransitions, computeLedgerMetrics, computeRepositoryHealth, coordinationRepositoryIdsSchema, costSchema, createCoordination, createInMemoryDriver, createSignalCreator, createStores, defaultApprovalPolicy, defineFactory, dispatchTask, ensureVerificationTasks, factoryConfigRepositorySchema, factoryConfigSchema, factoryIdSchema, findingCategorySchema, findingFingerprint, findingForTask, findingPrioritySchema, findingSchema, findingVerificationLevelSchema, findingVerificationMethodSchema, findingVerificationSchema, fixBrief, harnessSchema, isTransitionAllowed, isoDateTimeSchema, legalNextStates, levelSchema, receiptIdSchema, receiptKindSchema, receiptPhaseSchema, receiptSchema, receiptStateSchema, reconcileCoordination, replyToSchema, repositoryIdSchema, repositoryIdsSchema, repositorySchema, repositorySlugSchema, requiresApproval, reviewBucket, scanBrief, schemaVersionSchema, signalIdSchema, signalInitialOutcome, signalOutcomeSchema, signalOutcomeTransitions, signalSchema, signalSourceSchema, standardReceiptKinds, standardReceiptPhases, standardReceiptStates, standardSignalSources, standardTaskKinds, sweepQueued, taskApprovalSchema, taskDevboxSchema, taskExecutionRepositoryIdsSchema, taskIdSchema, taskInitialState, taskKindSchema, taskOriginSchema, taskQuestionSchema, taskSchema, taskStateSchema, taskTransitions, terminalStates, usdSchema, verificationBrief, vocabularySchema };
+export { AdoptPullRequestInput, AgentRoute, AgentRouteInput, AgentRouteRegistry, AgentSession, AnswerEvent, AnswerEventConflictError, AnswerId, AnswerQuestionInput, AppendReceiptInput, ApprovalDecision, ApprovalError, ApprovalPolicy, ApprovalRule, ApprovalSubject, Budget, BudgetExhaustedError, BudgetLimits, BudgetNotice, BudgetStatus, BudgetSweepOptions, BudgetSweepResult, Change, ChangeAssociationError, ChangeEvidence, ChangeId, ChangePatch, ChangeState, ChangeTransitionOptions, CollectionName, CommunicationEvent, CommunicationOutcome, CoordinationPlan, CoordinationReconciliation, Cost, CreateChangeInput, CreateCoordinationInput, CreateSignalInput, CreateStoresOptions, CreateTaskInput, DEFAULT_MAX_LAUNCH_ATTEMPTS, DecideSignalOptions, DispatchBudget, DispatchOptions, DispatchRefusedError, EnsureBudgetInput, ExecutionPolicy, ExecutionReference, FactoryConfig, FactoryConfigInput, FactoryId, FactoryStores, Finding, FindingCategory, FindingPriority, FindingVerification, HealthColor, HealthOptions, InvalidTransitionError, LedgerMetrics, LedgerRows, Level, MetricsOptions, OutboxEventConflictError, OutboxId, OutboxMessage, OutboxQueue, Receipt, ReceiptId, ReceiptKind, ReceiptPhase, ReceiptState, ReconcileCoordinationOptions, RecordExistsError, RecordNotFoundError, ReplyTo, Repository, RepositoryHealth, RepositoryId, RepositorySlug, ReviewBucket, SCHEMA_VERSION, SessionConflictError, SettleSweepOptions, SettleSweepResult, SettleTaskOptions, SettlementError, Signal, SignalCreator, SignalId, SignalOutcome, SignalSource, StallSweepOptions, StallSweepResult, StepUsage, StoreDriver, StoredEntry, StoredRecord, SweepOptions, SweepResult, Task, TaskApproval, TaskId, TaskKind, TaskLauncher, TaskPatch, TaskState, TaskTransitionOptions, TaskUsage, Transition, TransitionActor, VerificationTaskSweep, VersionConflictError, adoptPullRequest, agentRouteSchema, agentSessionIdSchema, agentSessionSchema, answerEventSchema, answerIdSchema, approvalPolicySchema, approvalRuleSchema, assertTransition, budgetLimitsSchema, budgetMonthOf, budgetMonthSchema, budgetSchema, budgetStatus, canReserve, changeEvidenceSchema, changeIdSchema, changeInitialState, changeSchema, changeStateSchema, changeTransitions, communicationEventSchema, communicationOutcomeSchema, communicationOutcomes, computeLedgerMetrics, computeMonthSpendUsd, computeRepositoryHealth, coordinationRepositoryIdsSchema, costSchema, createCoordination, createInMemoryDriver, createSignalCreator, createStores, defaultApprovalPolicy, defaultExecutionPolicy, defineAgentRoutes, defineFactory, deriveFactoryId, dispatchTask, ensureVerificationTasks, executionPolicySchema, executionReferenceSchema, factoryConfigRepositorySchema, factoryConfigSchema, factoryIdSchema, findingCategorySchema, findingFingerprint, findingForTask, findingPrioritySchema, findingSchema, findingVerificationLevelSchema, findingVerificationMethodSchema, findingVerificationSchema, fixBrief, harnessSchema, isTransitionAllowed, isoDateTimeSchema, legalNextStates, levelSchema, outboxIdSchema, outboxMessageSchema, outboxQueueSchema, outboxStateSchema, receiptIdSchema, receiptKindSchema, receiptPhaseSchema, receiptSchema, receiptStateSchema, reconcileCoordination, replyToSchema, repositoryIdSchema, repositoryIdsSchema, repositorySchema, repositorySlugSchema, requiresApproval, reviewBucket, scanBrief, schemaVersionSchema, signalIdSchema, signalInitialOutcome, signalOutcomeSchema, signalOutcomeTransitions, signalSchema, signalSourceSchema, stallWindowMinutes, standardReceiptKinds, standardReceiptPhases, standardReceiptStates, standardSignalSources, standardTaskKinds, sweepBudget, sweepQueued, sweepSettlements, sweepStalled, taskApprovalSchema, taskExecutionRepositoryIdsSchema, taskIdSchema, taskInitialState, taskKindSchema, taskOriginSchema, taskQuestionSchema, taskSchema, taskStateSchema, taskTransitions, taskUsageSchema, terminalStates, usdSchema, verificationBrief, vocabularySchema };
 //# sourceMappingURL=index.d.mts.map