@vercel/factory 0.0.13 → 0.0.14

package/dist/index.mjs

@@ -1,10 +1,14 @@
-import { a as repositoryIdsSchema, c as SCHEMA_VERSION, d as schemaVersionSchema, f as usdSchema, i as repositoryIdSchema, l as isoDateTimeSchema, n as factoryIdSchema, o as signalIdSchema, p as vocabularySchema, r as receiptIdSchema, s as taskIdSchema, t as changeIdSchema, u as replyToSchema } from "./id-DwCihQr4.mjs";
-import { C as taskUsageSchema, S as taskStateSchema, _ as taskExecutionRepositoryIdsSchema, a as findingCategorySchema, b as taskQuestionSchema, c as findingSchema, d as findingVerificationSchema, f as coordinationRepositoryIdsSchema, g as taskApprovalSchema, h as standardTaskKinds, i as requiresApproval, l as findingVerificationLevelSchema, m as harnessSchema, n as approvalRuleSchema, o as findingFingerprint, p as executionReferenceSchema, r as defaultApprovalPolicy, s as findingPrioritySchema, t as approvalPolicySchema, u as findingVerificationMethodSchema, v as taskKindSchema, x as taskSchema, y as taskOriginSchema } from "./approval-CwhTP1XB.mjs";
-import { C as budgetStatus, D as sweepBudget, E as deriveFactoryId, O as sweepSettlements, S as budgetMonthOf, T as computeMonthSpendUsd, _ as taskInitialState, a as BudgetExhaustedError, b as createCoordination, c as dispatchTask, d as changeInitialState, f as changeTransitions, g as signalOutcomeTransitions, h as signalInitialOutcome, i as levelSchema, l as InvalidTransitionError, m as legalNextStates, n as changeSchema, o as DEFAULT_MAX_LAUNCH_ATTEMPTS, p as isTransitionAllowed, r as changeStateSchema, s as DispatchRefusedError, t as changeEvidenceSchema, u as assertTransition, v as taskTransitions, w as canReserve, x as reconcileCoordination, y as terminalStates } from "./change-CzEAoFVE.mjs";
+import { a as receiptIdSchema, c as signalIdSchema, d as isoDateTimeSchema, f as replyToSchema, h as vocabularySchema, i as outboxIdSchema, l as taskIdSchema, m as usdSchema, n as changeIdSchema, o as repositoryIdSchema, p as schemaVersionSchema, r as factoryIdSchema, s as repositoryIdsSchema, t as answerIdSchema, u as SCHEMA_VERSION } from "./id-BLIkCVue.mjs";
+import { a as taskApprovalSchema, c as taskOriginSchema, d as taskStateSchema, f as taskUsageSchema, i as standardTaskKinds, l as taskQuestionSchema, n as executionReferenceSchema, o as taskExecutionRepositoryIdsSchema, r as harnessSchema, s as taskKindSchema, t as coordinationRepositoryIdsSchema, u as taskSchema } from "./task-CcOyOJ3k.mjs";
+import { a as findingCategorySchema, c as findingSchema, d as findingVerificationSchema, i as requiresApproval, l as findingVerificationLevelSchema, n as approvalRuleSchema, o as findingFingerprint, r as defaultApprovalPolicy, s as findingPrioritySchema, t as approvalPolicySchema, u as findingVerificationMethodSchema } from "./approval-JX2Px9IC.mjs";
+import { C as computeMonthSpendUsd, E as sweepSettlements, S as canReserve, T as sweepBudget, _ as taskInitialState, a as BudgetExhaustedError, b as budgetMonthOf, c as dispatchTask, d as changeInitialState, f as changeTransitions, g as signalOutcomeTransitions, h as signalInitialOutcome, i as levelSchema, l as InvalidTransitionError, m as legalNextStates, n as changeSchema, o as DEFAULT_MAX_LAUNCH_ATTEMPTS, p as isTransitionAllowed, r as changeStateSchema, s as DispatchRefusedError, t as changeEvidenceSchema, u as assertTransition, v as taskTransitions, w as deriveFactoryId, x as budgetStatus, y as terminalStates } from "./change-D2U6v7Ek.mjs";
 import { n as RecordNotFoundError, r as VersionConflictError, t as RecordExistsError } from "./driver-Bbd25rNM.mjs";
-import { a as factoryConfigSchema, c as budgetSchema, i as factoryConfigRepositorySchema, l as repositorySchema, n as defineFactory, o as budgetLimitsSchema, r as executionPolicySchema, s as budgetMonthSchema, t as defaultExecutionPolicy, u as repositorySlugSchema } from "./factory-config-BJcjsPKl.mjs";
+import { n as reconcileCoordination, t as createCoordination } from "./coordination-Cq08hb1l.mjs";
+import { a as repositorySlugSchema, i as repositorySchema, n as budgetMonthSchema, r as budgetSchema, t as budgetLimitsSchema } from "./budget-DzSiIA4t.mjs";
+import { C as standardReceiptPhases, S as standardReceiptKinds, T as answerEventSchema, _ as costSchema, a as SessionConflictError, b as receiptSchema, c as agentSessionIdSchema, d as signalSchema, f as signalSourceSchema, g as outboxStateSchema, h as outboxQueueSchema, i as OutboxEventConflictError, l as agentSessionSchema, m as outboxMessageSchema, n as ApprovalError, o as SettlementError, p as standardSignalSources, r as ChangeAssociationError, s as createStores, t as AnswerEventConflictError, u as signalOutcomeSchema, v as receiptKindSchema, w as standardReceiptStates, x as receiptStateSchema, y as receiptPhaseSchema } from "./engine-WaUM2cGA.mjs";
+import { n as communicationOutcomeSchema, r as communicationOutcomes, t as communicationEventSchema } from "./communication-Kd9nU5RP.mjs";
+import { a as factoryConfigSchema, i as factoryConfigRepositorySchema, n as defineFactory, r as executionPolicySchema, t as defaultExecutionPolicy } from "./factory-config-BoRXOw43.mjs";
 import { z } from "zod";
-import { createHash, randomUUID } from "node:crypto";
 //#region src/agent-routes.ts
 const agentRouteSchema = z.strictObject({
 	id: z.string().regex(/^[a-z][a-z0-9-]{0,63}$/u).describe("Stable route selected by a conversational agent or workflow."),
@@ -82,8 +86,6 @@ function verificationBrief(task, repository, change) {
 //#endregion
 //#region src/changes.ts
 async function adoptPullRequest(stores, input) {
-	const existing = (await stores.changes.list()).find((change) => change.repositoryId === input.repositoryId && change.prNumber === input.prNumber && (change.state === "verifying" || change.state === "ready"));
-	if (existing !== void 0) return existing;
 	return stores.changes.create({
 		...input,
 		risk: "low",
@@ -232,6 +234,7 @@ function computeRepositoryHealth(rows, options = {}) {
 	const dayMs = 864e5;
 	const red = [];
 	const yellow = [];
+	const tasksById = new Map(rows.tasks.map((task) => [task.id, task]));
 	for (const receipt of rows.receipts) {
 		if (now - Date.parse(receipt.recordedAt) >= dayMs) continue;
 		if (receipt.state === "rolled_back") red.push(`rollback in the last 24h (${receipt.receiptId})`);
@@ -241,6 +244,12 @@ function computeRepositoryHealth(rows, options = {}) {
 	if (openQuestions > 0) yellow.push(`${openQuestions} open question(s)`);
 	const needsHuman = rows.tasks.filter((task) => task.kind !== "question" && task.state === "needs_human").length;
 	if (needsHuman > 0) yellow.push(`${needsHuman} task(s) waiting on a human`);
+	const maxQueuedMinutes = options.maxQueuedMinutes ?? 5;
+	const staleQueued = rows.tasks.filter((task) => {
+		if (task.state !== "queued" || task.kind === "question" || task.kind === "coordination" || task.approval === "required") return false;
+		return (task.dependsOn ?? []).every((dependencyId) => tasksById.get(dependencyId)?.changeId !== void 0) && now - Date.parse(task.updatedAt) >= maxQueuedMinutes * 60 * 1e3;
+	}).length;
+	if (staleQueued > 0) yellow.push(`${staleQueued} eligible task(s) queued for at least ${maxQueuedMinutes} minutes`);
 	const blocked = rows.changes.filter((change) => openChangeStates.has(change.state) && reviewBucket(change.risk, change.confidence) === "blocked").length;
 	if (blocked > 0) yellow.push(`${blocked} change(s) in the blocked bucket`);
 	if (options.maxOpenChanges !== void 0) {
@@ -261,121 +270,6 @@ function computeRepositoryHealth(rows, options = {}) {
 	};
 }
 //#endregion
-//#region src/schema/receipt.ts
-/** States the engine writes on transitions. Any vocabulary value is valid. */
-const standardReceiptStates = [
-	"approved",
-	"rejected",
-	"dispatched",
-	"stalled",
-	"succeeded",
-	"failed",
-	"needs_human",
-	"cancelled",
-	"settled",
-	"ready",
-	"merged",
-	"deployed",
-	"rolled_out",
-	"rolled_back"
-];
-/** Phases the standard loop uses. Any vocabulary value is valid. */
-const standardReceiptPhases = [
-	"approval",
-	"budget",
-	"dispatch",
-	"implementation",
-	"verification",
-	"pull_request",
-	"cleanup"
-];
-/** Kinds the standard loop writes: the standard task kinds plus "change". */
-const standardReceiptKinds = [...standardTaskKinds, "change"];
-const receiptStateSchema = vocabularySchema.describe("What happened, e.g. dispatched, settled, merged, or a custom event name.");
-const receiptPhaseSchema = vocabularySchema.describe("Where in the process it happened, e.g. dispatch or verification.");
-const receiptKindSchema = vocabularySchema.describe("What the receipt is about: a task kind, change, or a custom kind.");
-const costSchema = z.strictObject({ totalUsd: usdSchema });
-const receiptSchema = z.strictObject({
-	schemaVersion: schemaVersionSchema,
-	receiptId: receiptIdSchema,
-	repositoryIds: repositoryIdsSchema.describe("Repositories the recorded event concerns."),
-	taskId: taskIdSchema.optional(),
-	changeId: changeIdSchema.optional(),
-	kind: receiptKindSchema,
-	state: receiptStateSchema,
-	phase: receiptPhaseSchema.optional(),
-	reason: z.string().min(1).max(2e3).optional().describe("Why it happened. Scrubbed and truncated; never secrets."),
-	attempt: z.number().int().min(1).describe("Attempt the event belongs to."),
-	cost: costSchema.optional().describe("Measured cost. Settled receipts only."),
-	decidedBy: z.string().min(1).optional().describe("Human who made the decision. Change and approval receipts only."),
-	recordedAt: isoDateTimeSchema
-}).superRefine((receipt, ctx) => {
-	if (receipt.state === "settled" && receipt.cost === void 0) ctx.addIssue({
-		code: "custom",
-		path: ["cost"],
-		message: "settled receipts require cost"
-	});
-	if (receipt.state !== "settled" && receipt.cost !== void 0) ctx.addIssue({
-		code: "custom",
-		path: ["cost"],
-		message: "cost is only valid on settled receipts"
-	});
-	if (receipt.decidedBy !== void 0 && receipt.kind !== "change" && receipt.state !== "approved" && receipt.state !== "rejected") ctx.addIssue({
-		code: "custom",
-		path: ["decidedBy"],
-		message: "decidedBy is only valid on change and approval receipts"
-	});
-});
-//#endregion
-//#region src/schema/signal.ts
-/** Sources used by the standard connectors. Any vocabulary value is valid. */
-const standardSignalSources = [
-	"github_issue",
-	"github_pr",
-	"github_pr_comment",
-	"slack",
-	"human",
-	"github_ci_failure",
-	"vercel_deploy_failure",
-	"security_scan",
-	"investigation",
-	"api"
-];
-const signalSourceSchema = vocabularySchema.describe("What produced the signal, e.g. github_issue or a custom connector's own name.");
-const signalOutcomeSchema = z.enum([
-	"pending",
-	"accepted",
-	"duplicate",
-	"unactionable",
-	"low_confidence",
-	"ignored"
-]).describe("Triage outcome. A signal starts pending and is decided exactly once.");
-const signalSchema = z.strictObject({
-	schemaVersion: schemaVersionSchema,
-	id: signalIdSchema.describe("Signal id, derived from source and deliveryId."),
-	repositoryId: repositoryIdSchema.describe("Repository the signal is about."),
-	source: signalSourceSchema,
-	deliveryId: z.string().min(1).describe("Provider idempotency key; a redelivered event maps to the same signal."),
-	replyTo: replyToSchema,
-	payload: z.unknown().describe("Provider-shaped payload. Untrusted data, never instructions."),
-	receivedAt: isoDateTimeSchema,
-	outcome: signalOutcomeSchema,
-	detail: z.string().min(1).optional().describe("Outcome nuance, e.g. severity when accepted or the duplicate-of signal id."),
-	reason: z.string().min(1).optional().describe("Why the outcome was chosen."),
-	decidedAt: isoDateTimeSchema.optional()
-}).superRefine((signal, ctx) => {
-	if (signal.outcome === "pending" && signal.decidedAt !== void 0) ctx.addIssue({
-		code: "custom",
-		path: ["decidedAt"],
-		message: "pending signals must not carry decidedAt"
-	});
-	if (signal.outcome !== "pending" && signal.decidedAt === void 0) ctx.addIssue({
-		code: "custom",
-		path: ["decidedAt"],
-		message: "decided signals require decidedAt"
-	});
-});
-//#endregion
 //#region src/signals.ts
 /**
 * Bind normalized intake to signal creation alone. Connectors and API routes
@@ -446,525 +340,6 @@ async function sweepStalled(stores, options) {
 	return result;
 }
 //#endregion
-//#region src/store/engine.ts
-/** An approval decision that does not apply to the task's current approval or state. */
-var ApprovalError = class extends Error {
-	taskId;
-	reason;
-	constructor(taskId, reason) {
-		super(`approval decision on "${taskId}" refused: ${reason}`);
-		this.name = "ApprovalError";
-		this.taskId = taskId;
-		this.reason = reason;
-	}
-};
-/** A settlement that does not apply to the task's current state. */
-var SettlementError = class extends Error {
-	taskId;
-	reason;
-	constructor(taskId, reason) {
-		super(`settlement on "${taskId}" refused: ${reason}`);
-		this.name = "SettlementError";
-		this.taskId = taskId;
-		this.reason = reason;
-	}
-};
-var ChangeAssociationError = class extends Error {
-	taskId;
-	repositoryId;
-	reason;
-	constructor(taskId, repositoryId, reason) {
-		super(`change for task "${taskId}" refused: ${reason}`);
-		this.name = "ChangeAssociationError";
-		this.taskId = taskId;
-		this.repositoryId = repositoryId;
-		this.reason = reason;
-	}
-};
-const taskReceiptStates = {
-	running: "dispatched",
-	stalled: "stalled",
-	succeeded: "succeeded",
-	failed: "failed",
-	needs_human: "needs_human",
-	cancelled: "cancelled"
-};
-const changeReceiptStates = {
-	ready: "ready",
-	merged: "merged",
-	deployed: "deployed",
-	rolled_out: "rolled_out",
-	rolled_back: "rolled_back"
-};
-function randomId(prefix) {
-	return `${prefix}_${randomUUID().replaceAll("-", "")}`;
-}
-function derivedId(prefix, key) {
-	return `${prefix}_${createHash("sha256").update(key).digest("hex").slice(0, 32)}`;
-}
-function bumpsAttempt(from, to) {
-	return to === "queued" || from === "verifying" && to === "running";
-}
-const emptyUsage = {
-	costUsd: 0,
-	inputTokens: 0,
-	outputTokens: 0,
-	cacheReadTokens: 0,
-	cacheWriteTokens: 0,
-	steps: {}
-};
-function addUsd(a, b) {
-	return (Math.round(a * 1e6) + Math.round(b * 1e6)) / 1e6;
-}
-function createStores(options) {
-	const { driver } = options;
-	const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-	async function read(collection, id, schema) {
-		const record = await driver.get(collection, id);
-		if (record === null) return null;
-		return {
-			value: schema.parse(record.value),
-			version: record.version
-		};
-	}
-	async function mustRead(collection, id, schema) {
-		const record = await read(collection, id, schema);
-		if (record === null) throw new RecordNotFoundError(collection, id);
-		return record;
-	}
-	async function listAll(collection, schema) {
-		return (await driver.list(collection)).map((entry) => schema.parse(entry.record.value));
-	}
-	async function insertReceipt(receiptId, receipt) {
-		const full = receiptSchema.parse({
-			...receipt,
-			schemaVersion: 1,
-			receiptId,
-			recordedAt: now()
-		});
-		try {
-			await driver.insert("receipts", receiptId, full);
-			return full;
-		} catch (error) {
-			if (error instanceof RecordExistsError) return (await mustRead("receipts", receiptId, receiptSchema)).value;
-			throw error;
-		}
-	}
-	async function appendReceipt(key, receipt) {
-		return insertReceipt(derivedId("rcpt", key), receipt);
-	}
-	return {
-		driverName: driver.name,
-		repositories: {
-			async put(repository) {
-				const parsed = repositorySchema.parse(repository);
-				const existing = await read("repositories", parsed.id, repositorySchema);
-				if (existing === null) await driver.insert("repositories", parsed.id, parsed);
-				else await driver.update("repositories", parsed.id, parsed, existing.version);
-				return parsed;
-			},
-			async get(id) {
-				const record = await read("repositories", id, repositorySchema);
-				return record === null ? null : record.value;
-			},
-			list() {
-				return listAll("repositories", repositorySchema);
-			}
-		},
-		signals: {
-			async create(input) {
-				const id = derivedId("sig", `${input.source}:${input.deliveryId}`);
-				const signal = signalSchema.parse({
-					schemaVersion: 1,
-					id,
-					repositoryId: input.repositoryId,
-					source: input.source,
-					deliveryId: input.deliveryId,
-					replyTo: input.replyTo,
-					payload: input.payload,
-					receivedAt: now(),
-					outcome: "pending"
-				});
-				try {
-					await driver.insert("signals", id, signal);
-					return signal;
-				} catch (error) {
-					if (error instanceof RecordExistsError) return (await mustRead("signals", id, signalSchema)).value;
-					throw error;
-				}
-			},
-			async get(id) {
-				const record = await read("signals", id, signalSchema);
-				return record === null ? null : record.value;
-			},
-			async decide(id, outcome, decideOptions = {}) {
-				const existing = await mustRead("signals", id, signalSchema);
-				assertTransition(signalOutcomeTransitions, existing.value.outcome, outcome);
-				const next = signalSchema.parse({
-					...existing.value,
-					outcome,
-					detail: decideOptions.detail,
-					reason: decideOptions.reason,
-					decidedAt: now()
-				});
-				await driver.update("signals", id, next, existing.version);
-				return next;
-			},
-			list() {
-				return listAll("signals", signalSchema);
-			}
-		},
-		tasks: {
-			async create(input) {
-				const timestamp = now();
-				const id = input.dedupeKey === void 0 ? randomId("task") : derivedId("task", input.dedupeKey);
-				const task = taskSchema.parse({
-					schemaVersion: 1,
-					id,
-					repositoryIds: input.repositoryIds,
-					kind: input.kind,
-					area: input.area,
-					state: taskInitialState,
-					approval: input.approval,
-					origin: input.origin,
-					dependsOn: input.dependsOn,
-					replyTo: input.replyTo,
-					attempt: 1,
-					question: input.question,
-					changeId: input.changeId,
-					createdAt: timestamp,
-					updatedAt: timestamp
-				});
-				try {
-					await driver.insert("tasks", task.id, task);
-					return task;
-				} catch (error) {
-					if (input.dedupeKey !== void 0 && error instanceof RecordExistsError) return (await mustRead("tasks", task.id, taskSchema)).value;
-					throw error;
-				}
-			},
-			async approve(id, decision) {
-				const existing = await mustRead("tasks", id, taskSchema);
-				const task = existing.value;
-				if (task.approval !== "required") throw new ApprovalError(id, `approval is ${task.approval ?? "not required"}`);
-				if (task.state !== "queued") throw new ApprovalError(id, `task is ${task.state}, not queued`);
-				const next = taskSchema.parse({
-					...task,
-					approval: "granted",
-					updatedAt: now()
-				});
-				if (next.repositoryIds !== void 0) await appendReceipt(`task:${id}:approved:${next.attempt}`, {
-					repositoryIds: next.repositoryIds,
-					taskId: id,
-					kind: next.kind,
-					state: "approved",
-					phase: "approval",
-					reason: decision.reason,
-					attempt: next.attempt,
-					decidedBy: decision.by
-				});
-				await driver.update("tasks", id, next, existing.version);
-				return next;
-			},
-			async reject(id, decision) {
-				const existing = await mustRead("tasks", id, taskSchema);
-				const task = existing.value;
-				if (task.approval !== "required") throw new ApprovalError(id, `approval is ${task.approval ?? "not required"}`);
-				if (task.state !== "queued") throw new ApprovalError(id, `task is ${task.state}, not queued`);
-				const next = taskSchema.parse({
-					...task,
-					approval: "denied",
-					state: "cancelled",
-					updatedAt: now()
-				});
-				if (next.repositoryIds !== void 0) {
-					await appendReceipt(`task:${id}:rejected:${next.attempt}`, {
-						repositoryIds: next.repositoryIds,
-						taskId: id,
-						kind: next.kind,
-						state: "rejected",
-						phase: "approval",
-						reason: decision.reason,
-						attempt: next.attempt,
-						decidedBy: decision.by
-					});
-					await appendReceipt(`task:${id}:cancelled:${next.attempt}`, {
-						repositoryIds: next.repositoryIds,
-						taskId: id,
-						kind: next.kind,
-						state: "cancelled",
-						reason: decision.reason ?? `rejected by ${decision.by}`,
-						attempt: next.attempt
-					});
-				}
-				await driver.update("tasks", id, next, existing.version);
-				return next;
-			},
-			async recordExecution(id, execution) {
-				const existing = await mustRead("tasks", id, taskSchema);
-				const task = existing.value;
-				if (task.state !== "running") throw new InvalidTransitionError(task.state, "running", legalNextStates(taskTransitions, task.state));
-				const timestamp = now();
-				const next = taskSchema.parse({
-					...task,
-					execution,
-					lastProgressAt: timestamp,
-					updatedAt: timestamp
-				});
-				await driver.update("tasks", id, next, existing.version);
-				return next;
-			},
-			async recordUsage(id, step) {
-				for (;;) {
-					const existing = await mustRead("tasks", id, taskSchema);
-					const task = existing.value;
-					const usage = task.usage ?? emptyUsage;
-					const recordedIndex = usage.steps[step.turnId];
-					if (recordedIndex !== void 0 && step.stepIndex <= recordedIndex) return task;
-					const timestamp = now();
-					const next = taskSchema.parse({
-						...task,
-						lastProgressAt: timestamp,
-						usage: {
-							costUsd: addUsd(usage.costUsd, step.costUsd ?? 0),
-							inputTokens: usage.inputTokens + (step.inputTokens ?? 0),
-							outputTokens: usage.outputTokens + (step.outputTokens ?? 0),
-							cacheReadTokens: usage.cacheReadTokens + (step.cacheReadTokens ?? 0),
-							cacheWriteTokens: usage.cacheWriteTokens + (step.cacheWriteTokens ?? 0),
-							steps: {
-								...usage.steps,
-								[step.turnId]: step.stepIndex
-							}
-						},
-						updatedAt: timestamp
-					});
-					try {
-						await driver.update("tasks", id, next, existing.version);
-						return next;
-					} catch (error) {
-						if (!(error instanceof VersionConflictError)) throw error;
-					}
-				}
-			},
-			async settle(id, cost, settleOptions = {}) {
-				const existing = await mustRead("tasks", id, taskSchema);
-				const task = existing.value;
-				if (task.settledUsd !== void 0) return task;
-				if (task.state !== "succeeded" && task.state !== "failed" && task.state !== "cancelled") throw new SettlementError(id, `task is ${task.state}, not terminal`);
-				const validated = costSchema.parse(cost);
-				const normalized = { totalUsd: Math.round(validated.totalUsd * 1e6) / 1e6 };
-				let recorded = normalized;
-				if (task.repositoryIds !== void 0) recorded = (await appendReceipt(`task:${id}:settled:${task.attempt}`, {
-					repositoryIds: task.repositoryIds,
-					taskId: id,
-					changeId: task.changeId,
-					kind: task.kind,
-					state: "settled",
-					phase: "budget",
-					reason: settleOptions.reason,
-					attempt: task.attempt,
-					cost: normalized
-				})).cost ?? normalized;
-				const next = taskSchema.parse({
-					...task,
-					settledUsd: recorded.totalUsd,
-					updatedAt: now()
-				});
-				await driver.update("tasks", id, next, existing.version);
-				return next;
-			},
-			async get(id) {
-				const record = await read("tasks", id, taskSchema);
-				return record === null ? null : record.value;
-			},
-			async transition(id, to, transitionOptions = {}) {
-				if (transitionOptions.patch !== void 0 && "settledUsd" in transitionOptions.patch) throw new SettlementError(id, "settledUsd is set only by settle, not a transition");
-				if (transitionOptions.patch !== void 0 && "usage" in transitionOptions.patch) throw new SettlementError(id, "usage is set only by recordUsage, not a transition");
-				const existing = await mustRead("tasks", id, taskSchema);
-				if (transitionOptions.expectFrom !== void 0 && existing.value.state !== transitionOptions.expectFrom) throw new InvalidTransitionError(existing.value.state, to, legalNextStates(taskTransitions, existing.value.state));
-				assertTransition(taskTransitions, existing.value.state, to);
-				if (to === "needs_human" && existing.value.kind !== "question") {
-					if (!(await listAll("tasks", taskSchema)).some((task) => task.kind === "question" && task.state === "needs_human" && task.origin.parentTaskId === id)) throw new Error(`task ${id} cannot enter needs_human without an open QuestionTask`);
-				}
-				const bumps = bumpsAttempt(existing.value.state, to);
-				const timestamp = now();
-				const { stalledAt: _stalledAt, stalledReason: _stalledReason, ...cleared } = existing.value;
-				const next = taskSchema.parse({
-					...cleared,
-					...bumps ? { execution: void 0 } : {},
-					...transitionOptions.patch,
-					...to === "stalled" ? {
-						stalledAt: timestamp,
-						stalledReason: transitionOptions.reason
-					} : {},
-					...to === "running" ? { lastProgressAt: timestamp } : {},
-					state: to,
-					attempt: bumps ? existing.value.attempt + 1 : existing.value.attempt,
-					updatedAt: timestamp
-				});
-				const receiptState = taskReceiptStates[to];
-				if (receiptState !== void 0 && next.repositoryIds !== void 0) await appendReceipt(JSON.stringify([
-					"task",
-					id,
-					receiptState,
-					next.attempt,
-					next.changeId ?? null,
-					transitionOptions.reason ?? null
-				]), {
-					repositoryIds: next.repositoryIds,
-					taskId: id,
-					changeId: next.changeId,
-					kind: next.kind,
-					state: receiptState,
-					reason: transitionOptions.reason,
-					attempt: next.attempt
-				});
-				await driver.update("tasks", id, next, existing.version);
-				return next;
-			},
-			list() {
-				return listAll("tasks", taskSchema);
-			}
-		},
-		changes: {
-			async create(input) {
-				const timestamp = now();
-				const change = changeSchema.parse({
-					schemaVersion: 1,
-					id: randomId("chg"),
-					repositoryId: input.repositoryId,
-					taskId: input.taskId,
-					groupId: input.groupId,
-					prNumber: input.prNumber,
-					prUrl: input.prUrl,
-					author: input.author,
-					risk: input.risk,
-					confidence: input.confidence,
-					evidence: input.evidence,
-					state: changeInitialState,
-					createdAt: timestamp,
-					updatedAt: timestamp
-				});
-				await mustRead("repositories", change.repositoryId, repositorySchema);
-				if (change.taskId !== void 0) {
-					const task = (await mustRead("tasks", change.taskId, taskSchema)).value;
-					if (task.kind !== "code_change") throw new ChangeAssociationError(change.taskId, change.repositoryId, "changes can only be produced by code_change tasks");
-					const taskRepositoryId = task.repositoryIds[0];
-					if (taskRepositoryId !== change.repositoryId) throw new ChangeAssociationError(change.taskId, change.repositoryId, `repository "${change.repositoryId}" does not match task repository "${taskRepositoryId}"`);
-				}
-				await driver.insert("changes", change.id, change);
-				return change;
-			},
-			async get(id) {
-				const record = await read("changes", id, changeSchema);
-				return record === null ? null : record.value;
-			},
-			async transition(id, to, transitionOptions = {}) {
-				const existing = await mustRead("changes", id, changeSchema);
-				assertTransition(changeTransitions, existing.value.state, to);
-				const next = changeSchema.parse({
-					...existing.value,
-					...transitionOptions.patch,
-					state: to,
-					updatedAt: now()
-				});
-				const receiptState = changeReceiptStates[to];
-				if (receiptState !== void 0) await appendReceipt(`change:${id}:${receiptState}`, {
-					repositoryIds: [next.repositoryId],
-					taskId: next.taskId,
-					changeId: id,
-					kind: "change",
-					state: receiptState,
-					reason: transitionOptions.reason,
-					attempt: 1,
-					decidedBy: next.decidedBy
-				});
-				await driver.update("changes", id, next, existing.version);
-				return next;
-			},
-			list() {
-				return listAll("changes", changeSchema);
-			}
-		},
-		receipts: {
-			append(input) {
-				const { dedupeKey, attempt, ...fields } = input;
-				return insertReceipt(dedupeKey === void 0 ? randomId("rcpt") : derivedId("rcpt", `custom:${dedupeKey}`), {
-					...fields,
-					attempt: attempt ?? 1
-				});
-			},
-			async get(id) {
-				const record = await read("receipts", id, receiptSchema);
-				return record === null ? null : record.value;
-			},
-			list() {
-				return listAll("receipts", receiptSchema);
-			}
-		},
-		budgets: {
-			async ensure(input) {
-				const budget = budgetSchema.parse({
-					schemaVersion: 1,
-					factoryId: input.factoryId,
-					month: input.month,
-					limits: input.limits,
-					notices: {}
-				});
-				try {
-					await driver.insert("budgets", input.month, budget);
-					return budget;
-				} catch (error) {
-					if (!(error instanceof RecordExistsError)) throw error;
-				}
-				const existing = await mustRead("budgets", input.month, budgetSchema);
-				const refreshed = budgetSchema.parse({
-					...existing.value,
-					limits: input.limits
-				});
-				if (JSON.stringify(refreshed) === JSON.stringify(existing.value)) return existing.value;
-				try {
-					await driver.update("budgets", input.month, refreshed, existing.version);
-					return refreshed;
-				} catch (error) {
-					if (error instanceof VersionConflictError) return (await mustRead("budgets", input.month, budgetSchema)).value;
-					throw error;
-				}
-			},
-			async get(month) {
-				const record = await read("budgets", month, budgetSchema);
-				return record === null ? null : record.value;
-			},
-			async stampNotice(month, notice) {
-				const field = notice === "warning" ? "warningAt" : "exhaustedAt";
-				for (;;) {
-					const existing = await mustRead("budgets", month, budgetSchema);
-					if (existing.value.notices[field] !== void 0) return {
-						budget: existing.value,
-						stamped: false
-					};
-					const next = budgetSchema.parse({
-						...existing.value,
-						notices: {
-							...existing.value.notices,
-							[field]: now()
-						}
-					});
-					try {
-						await driver.update("budgets", month, next, existing.version);
-						return {
-							budget: next,
-							stamped: true
-						};
-					} catch (error) {
-						if (!(error instanceof VersionConflictError)) throw error;
-					}
-				}
-			}
-		}
-	};
-}
-//#endregion
 //#region src/store/memory.ts
 function createInMemoryDriver() {
 	const collections = /* @__PURE__ */ new Map();
@@ -1013,6 +388,27 @@ function createInMemoryDriver() {
 }
 //#endregion
 //#region src/sweep.ts
+async function failUnrouteable(stores, task, reason, result) {
+	try {
+		await stores.tasks.transition(task.id, "failed", {
+			reason,
+			expectFrom: "queued"
+		});
+		result.failed.push({
+			taskId: task.id,
+			reason
+		});
+	} catch (error) {
+		if (error instanceof InvalidTransitionError || error instanceof VersionConflictError) {
+			result.skipped.push({
+				taskId: task.id,
+				reason: "task changed during routing"
+			});
+			return;
+		}
+		throw error;
+	}
+}
 /**
 * One pass of the factory's dispatcher, meant to run on a schedule inside the
 * deployment: every queued task that is allowed to run is started, in
@@ -1027,7 +423,10 @@ async function sweepQueued(stores, options) {
 		skipped: [],
 		failed: []
 	};
-	const queued = (await stores.tasks.list()).filter((task) => task.state === "queued" && task.kind !== "question").sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+	const maxDispatches = options.maxDispatches ?? Number.POSITIVE_INFINITY;
+	if (!(Number.isInteger(maxDispatches) || maxDispatches === Number.POSITIVE_INFINITY) || maxDispatches < 1) throw new Error("maxDispatches must be a positive integer");
+	let attempted = 0;
+	const queued = (await stores.tasks.list()).filter((task) => task.state === "queued" && task.kind !== "question").sort((a, b) => b.attempt - a.attempt || a.createdAt.localeCompare(b.createdAt));
 	for (const task of queued) {
 		if (task.kind === "coordination") {
 			result.skipped.push({
@@ -1038,10 +437,7 @@ async function sweepQueued(stores, options) {
 		}
 		const executionRepositoryIds = taskExecutionRepositoryIdsSchema.safeParse(task.repositoryIds);
 		if (!executionRepositoryIds.success) {
-			result.skipped.push({
-				taskId: task.id,
-				reason: "task execution requires exactly one repository"
-			});
+			await failUnrouteable(stores, task, "task execution requires exactly one repository", result);
 			continue;
 		}
 		if (task.approval === "required") {
@@ -1053,20 +449,22 @@ async function sweepQueued(stores, options) {
 		}
 		const launcher = options.launchers[task.kind];
 		if (launcher === void 0) {
-			result.skipped.push({
-				taskId: task.id,
-				reason: `no agent handles ${task.kind} tasks`
-			});
+			await failUnrouteable(stores, task, `no registered launcher handles ${task.kind} tasks`, result);
 			continue;
 		}
 		const repository = await stores.repositories.get(executionRepositoryIds.data[0]);
 		if (repository === null) {
+			await failUnrouteable(stores, task, "task has no repository", result);
+			continue;
+		}
+		if (attempted >= maxDispatches) {
 			result.skipped.push({
 				taskId: task.id,
-				reason: "task has no repository"
+				reason: "per-sweep dispatch limit reached"
 			});
 			continue;
 		}
+		attempted += 1;
 		try {
 			await dispatchTask(stores, task.id, {
 				launch: (dispatched) => launcher(dispatched, repository),
@@ -1119,6 +517,6 @@ async function ensureVerificationTasks(stores) {
 	return result;
 }
 //#endregion
-export { ApprovalError, BudgetExhaustedError, ChangeAssociationError, DEFAULT_MAX_LAUNCH_ATTEMPTS, DispatchRefusedError, InvalidTransitionError, RecordExistsError, RecordNotFoundError, SCHEMA_VERSION, SettlementError, VersionConflictError, adoptPullRequest, agentRouteSchema, approvalPolicySchema, approvalRuleSchema, assertTransition, budgetLimitsSchema, budgetMonthOf, budgetMonthSchema, budgetSchema, budgetStatus, canReserve, changeEvidenceSchema, changeIdSchema, changeInitialState, changeSchema, changeStateSchema, changeTransitions, 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, 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 };
+export { AnswerEventConflictError, ApprovalError, BudgetExhaustedError, ChangeAssociationError, DEFAULT_MAX_LAUNCH_ATTEMPTS, DispatchRefusedError, InvalidTransitionError, OutboxEventConflictError, RecordExistsError, RecordNotFoundError, SCHEMA_VERSION, SessionConflictError, SettlementError, 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.mjs.map