@vercel/factory 0.0.12 → 0.0.14

package/dist/index.mjs

@@ -1,10 +1,48 @@
-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 { 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-DdvEKLiE.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 { _ as taskSchema, a as DEFAULT_MAX_LAUNCH_ATTEMPTS, c as coordinationRepositoryIdsSchema, d as taskApprovalSchema, f as taskDevboxSchema, g as taskQuestionSchema, h as taskOriginSchema, i as levelSchema, l as harnessSchema, m as taskKindSchema, n as changeSchema, o as DispatchRefusedError, p as taskExecutionRepositoryIdsSchema, r as changeStateSchema, s as dispatchTask, t as changeEvidenceSchema, u as standardTaskKinds, v as taskStateSchema } from "./change-CFNGXVqD.mjs";
-import { a as repositorySlugSchema, i as repositorySchema, n as factoryConfigRepositorySchema, r as factoryConfigSchema, t as defineFactory } from "./factory-config-ifd3JxiU.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."),
+	agent: z.string().regex(/^[a-z][a-z0-9-]{0,31}$/u).describe("Internally addressable Eve agent that executes this route."),
+	taskKind: taskKindSchema.describe("Factory task kind created for this route."),
+	description: z.string().min(1).max(500).describe("Model-facing guidance for when this route is appropriate."),
+	permissions: z.array(z.string().min(1)).default([]).describe("Inspectable capabilities granted to the target agent.")
+});
+/**
+* Define the application-owned routes an agent or workflow may select. Route
+* descriptions inform judgment; this validated registry remains the authority.
+*/
+function defineAgentRoutes(inputs) {
+	const routes = inputs.map((input) => agentRouteSchema.parse(input));
+	const byId = /* @__PURE__ */ new Map();
+	const byTaskKind = /* @__PURE__ */ new Map();
+	for (const route of routes) {
+		if (byId.has(route.id)) throw new Error(`Agent route ${route.id} is registered more than once.`);
+		if (byTaskKind.has(route.taskKind)) throw new Error(`Task kind ${route.taskKind} is handled by more than one agent route.`);
+		byId.set(route.id, route);
+		byTaskKind.set(route.taskKind, route);
+	}
+	const frozen = Object.freeze(routes.map((route) => Object.freeze(route)));
+	return Object.freeze({
+		routes: frozen,
+		get(id) {
+			return byId.get(id);
+		},
+		forTaskKind(kind) {
+			return byTaskKind.get(kind);
+		}
+	});
+}
+//#endregion
 //#region src/briefs.ts
 /** The finding behind a task, when its signal carries one. */
 async function findingForTask(stores, task) {
@@ -48,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",
@@ -64,76 +100,6 @@ async function adoptPullRequest(stores, input) {
 	});
 }
 //#endregion
-//#region src/coordination.ts
-/** Create one non-executable parent and one independently executable child per repository. */
-async function createCoordination(stores, input) {
-	const repositoryIds = [...new Set(input.repositoryIds)];
-	if (repositoryIds.length < 2) throw new Error("coordination requires at least two distinct repositories");
-	const parent = await stores.tasks.create({
-		repositoryIds,
-		kind: "coordination",
-		origin: { signalId: input.signalId },
-		replyTo: input.replyTo
-	});
-	return {
-		parent: await stores.tasks.transition(parent.id, "running", { reason: "repository-scoped child tasks created" }),
-		children: await Promise.all(repositoryIds.map((repositoryId) => stores.tasks.create({
-			repositoryIds: [repositoryId],
-			kind: "code_change",
-			origin: { parentTaskId: parent.id },
-			replyTo: input.replyTo
-		})))
-	};
-}
-/** Reconcile a coordination parent from its direct children without ever dispatching the parent. */
-async function reconcileCoordination(stores, parentTaskId, options) {
-	const parent = await stores.tasks.get(parentTaskId);
-	if (parent === null) throw new RecordNotFoundError("tasks", parentTaskId);
-	if (parent.kind !== "coordination") throw new Error(`task ${parentTaskId} is ${parent.kind}, not coordination`);
-	const children = (await stores.tasks.list()).filter((task) => task.origin.parentTaskId === parentTaskId);
-	if (children.length !== parent.repositoryIds.length) return {
-		status: "pending",
-		parent,
-		children
-	};
-	if (parent.state === "succeeded" || parent.state === "failed") return {
-		status: parent.state,
-		transitioned: false,
-		parent,
-		children
-	};
-	if (children.some((child) => child.state === "failed" || child.state === "cancelled")) {
-		await options.present({
-			status: "failed",
-			parent,
-			children
-		});
-		return {
-			status: "failed",
-			transitioned: true,
-			parent: await stores.tasks.transition(parent.id, "failed", { reason: "one or more repository tasks failed" }),
-			children
-		};
-	}
-	if (!children.every((child) => child.state === "succeeded")) return {
-		status: "pending",
-		parent,
-		children
-	};
-	await options.present({
-		status: "succeeded",
-		parent,
-		children
-	});
-	await stores.tasks.transition(parent.id, "verifying", { reason: "all repository tasks succeeded" });
-	return {
-		status: "succeeded",
-		transitioned: true,
-		parent: await stores.tasks.transition(parent.id, "succeeded", { reason: "aggregate multi-repository handoff is ready" }),
-		children
-	};
-}
-//#endregion
 //#region src/metrics.ts
 const bucketTable = {
 	low: {
@@ -258,15 +224,17 @@ function computeLedgerMetrics(rows, options = {}) {
 }
 const openChangeStates = /* @__PURE__ */ new Set(["verifying", "ready"]);
 /**
-* 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.
 */
 function computeRepositoryHealth(rows, options = {}) {
 	const now = (options.now ?? /* @__PURE__ */ new Date()).getTime();
 	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})`);
@@ -276,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) {
@@ -296,365 +270,6 @@ function computeRepositoryHealth(rows, options = {}) {
 	};
 }
 //#endregion
-//#region src/schema/budget.ts
-const budgetMonthSchema = z.string().regex(/^\d{4}-(0[1-9]|1[0-2])$/);
-const budgetSchema = z.strictObject({
-	schemaVersion: schemaVersionSchema,
-	factoryId: factoryIdSchema,
-	month: budgetMonthSchema,
-	limits: z.strictObject({
-		totalUsd: usdSchema,
-		investigationUsd: usdSchema,
-		perTaskReservationUsd: usdSchema,
-		warningPercent: z.number().int().min(1).max(100),
-		perRepositoryUsd: z.record(repositorySlugSchema, usdSchema).optional()
-	}),
-	notices: z.strictObject({
-		warningAt: isoDateTimeSchema.optional(),
-		exhaustedAt: isoDateTimeSchema.optional()
-	})
-});
-//#endregion
-//#region src/schema/receipt.ts
-/** States the engine writes on transitions. Any vocabulary value is valid. */
-const standardReceiptStates = [
-	"approved",
-	"rejected",
-	"dispatched",
-	"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/schema/transitions.ts
-const taskInitialState = "queued";
-const taskTransitions = [
-	{
-		from: "queued",
-		to: "running",
-		trigger: "dependencies have a change, reservation succeeded, devbox created",
-		actor: "reconciler"
-	},
-	{
-		from: "queued",
-		to: "failed",
-		trigger: "reservation refused",
-		actor: "reconciler"
-	},
-	{
-		from: "queued",
-		to: "needs_human",
-		trigger: "kind is question",
-		actor: "system"
-	},
-	{
-		from: "queued",
-		to: "cancelled",
-		trigger: "cancel or kill",
-		actor: "operator"
-	},
-	{
-		from: "running",
-		to: "verifying",
-		trigger: "devbox task reported complete",
-		actor: "reconciler"
-	},
-	{
-		from: "running",
-		to: "queued",
-		trigger: "launch failed below attempt limit",
-		actor: "reconciler"
-	},
-	{
-		from: "running",
-		to: "failed",
-		trigger: "devbox task errored, deadline exceeded, or launch failed at attempt limit",
-		actor: "reconciler"
-	},
-	{
-		from: "running",
-		to: "needs_human",
-		trigger: "devbox task requires attention",
-		actor: "reconciler"
-	},
-	{
-		from: "running",
-		to: "cancelled",
-		trigger: "cancel or kill",
-		actor: "operator"
-	},
-	{
-		from: "verifying",
-		to: "succeeded",
-		trigger: "kind criterion true",
-		actor: "reconciler"
-	},
-	{
-		from: "verifying",
-		to: "running",
-		trigger: "verification failed below attempt limit",
-		actor: "reconciler"
-	},
-	{
-		from: "verifying",
-		to: "failed",
-		trigger: "verification failed at attempt limit",
-		actor: "reconciler"
-	},
-	{
-		from: "verifying",
-		to: "cancelled",
-		trigger: "cancel or kill",
-		actor: "operator"
-	},
-	{
-		from: "needs_human",
-		to: "succeeded",
-		trigger: "question answered",
-		actor: "operator"
-	},
-	{
-		from: "needs_human",
-		to: "queued",
-		trigger: "operator retry",
-		actor: "operator"
-	},
-	{
-		from: "needs_human",
-		to: "cancelled",
-		trigger: "cancel or kill",
-		actor: "operator"
-	},
-	{
-		from: "failed",
-		to: "queued",
-		trigger: "operator retry",
-		actor: "operator"
-	}
-];
-const changeInitialState = "verifying";
-const changeTransitions = [
-	{
-		from: "verifying",
-		to: "ready",
-		trigger: "verification task succeeded, risk and confidence written",
-		actor: "reconciler"
-	},
-	{
-		from: "verifying",
-		to: "closed",
-		trigger: "verification failed at attempt limit or pr closed upstream",
-		actor: "reconciler"
-	},
-	{
-		from: "ready",
-		to: "merged",
-		trigger: "pr merged on github",
-		actor: "webhook"
-	},
-	{
-		from: "ready",
-		to: "closed",
-		trigger: "pr closed without merge",
-		actor: "webhook"
-	},
-	{
-		from: "merged",
-		to: "deployed",
-		trigger: "production deployment ready containing the merge sha",
-		actor: "webhook"
-	},
-	{
-		from: "deployed",
-		to: "rolled_out",
-		trigger: "no flag, or flag ramped to full and held",
-		actor: "foreman"
-	},
-	{
-		from: "deployed",
-		to: "rolled_back",
-		trigger: "rollback rule crossed",
-		actor: "foreman"
-	},
-	{
-		from: "rolled_out",
-		to: "rolled_back",
-		trigger: "rollback rule crossed or flag flipped off",
-		actor: "foreman"
-	},
-	{
-		from: "rolled_back",
-		to: "deployed",
-		trigger: "human retried the ramp",
-		actor: "human"
-	}
-];
-const signalInitialOutcome = "pending";
-const signalOutcomeTransitions = [
-	{
-		from: "pending",
-		to: "accepted",
-		trigger: "classified as actionable",
-		actor: "reconciler"
-	},
-	{
-		from: "pending",
-		to: "duplicate",
-		trigger: "classified as duplicate",
-		actor: "reconciler"
-	},
-	{
-		from: "pending",
-		to: "unactionable",
-		trigger: "classified as unactionable",
-		actor: "reconciler"
-	},
-	{
-		from: "pending",
-		to: "low_confidence",
-		trigger: "classified below confidence threshold",
-		actor: "reconciler"
-	},
-	{
-		from: "pending",
-		to: "ignored",
-		trigger: "classified as ignorable",
-		actor: "reconciler"
-	}
-];
-function isTransitionAllowed(transitions, from, to) {
-	return transitions.some((transition) => transition.from === from && transition.to === to);
-}
-function legalNextStates(transitions, from) {
-	return [...new Set(transitions.filter((transition) => transition.from === from).map((t) => t.to))];
-}
-var InvalidTransitionError = class extends Error {
-	from;
-	to;
-	legalNextStates;
-	constructor(from, to, legal) {
-		super(legal.length > 0 ? `invalid transition from "${from}" to "${to}"; legal next states: ${legal.map((state) => `"${state}"`).join(", ")}` : `invalid transition from "${from}" to "${to}"; "${from}" is terminal`);
-		this.name = "InvalidTransitionError";
-		this.from = from;
-		this.to = to;
-		this.legalNextStates = legal;
-	}
-};
-function assertTransition(transitions, from, to) {
-	if (!isTransitionAllowed(transitions, from, to)) throw new InvalidTransitionError(from, to, legalNextStates(transitions, from));
-}
-function terminalStates(transitions) {
-	const states = /* @__PURE__ */ new Set();
-	for (const transition of transitions) {
-		states.add(transition.from);
-		states.add(transition.to);
-	}
-	return [...states].filter((state) => !transitions.some((transition) => transition.from === state));
-}
-//#endregion
 //#region src/signals.ts
 /**
 * Bind normalized intake to signal creation alone. Connectors and API routes
@@ -667,346 +282,62 @@ function createSignalCreator(stores) {
 	} };
 }
 //#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;
-	}
-};
-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",
-	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)}`;
+//#region src/stall.ts
+function stallWindowMinutes(policy, kind) {
+	return policy.stallMinutesByKind[kind] ?? policy.stallMinutes;
 }
-function bumpsAttempt(from, to) {
-	return to === "queued" || from === "verifying" && to === "running";
-}
-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()
-		});
+/**
+* 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.
+*/
+async function sweepStalled(stores, options) {
+	const nowMs = (options.now ?? (() => /* @__PURE__ */ new Date()))().getTime();
+	const result = {
+		stalled: [],
+		requeued: [],
+		failed: []
+	};
+	const tasks = await stores.tasks.list();
+	for (const task of tasks) {
+		if (task.state !== "running" || task.kind === "coordination") continue;
+		const minutes = stallWindowMinutes(options.policy, task.kind);
+		const sinceProgress = nowMs - Date.parse(task.lastProgressAt ?? task.updatedAt);
+		if (sinceProgress < minutes * 6e4) continue;
 		try {
-			await driver.insert("receipts", receiptId, full);
-			return full;
-		} catch (error) {
-			if (error instanceof RecordExistsError) return (await mustRead("receipts", receiptId, receiptSchema)).value;
-			throw error;
+			await stores.tasks.transition(task.id, "stalled", {
+				reason: `no progress for ${Math.floor(sinceProgress / 6e4)} minutes (window ${minutes})`,
+				expectFrom: "running"
+			});
+			result.stalled.push(task.id);
+		} catch {
+			continue;
 		}
 	}
-	async function appendReceipt(key, receipt) {
-		await 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 get(id) {
-				const record = await read("tasks", id, taskSchema);
-				return record === null ? null : record.value;
-			},
-			async transition(id, to, transitionOptions = {}) {
-				const existing = await mustRead("tasks", id, taskSchema);
-				assertTransition(taskTransitions, existing.value.state, to);
-				const attempt = bumpsAttempt(existing.value.state, to) ? existing.value.attempt + 1 : existing.value.attempt;
-				const next = taskSchema.parse({
-					...existing.value,
-					...transitionOptions.patch,
-					state: to,
-					attempt,
-					updatedAt: now()
-				});
-				const receiptState = taskReceiptStates[to];
-				if (receiptState !== void 0 && next.repositoryIds !== void 0) await appendReceipt(`task:${id}:${receiptState}:${attempt}`, {
-					repositoryIds: next.repositoryIds,
-					taskId: id,
-					changeId: next.changeId,
-					kind: next.kind,
-					state: receiptState,
-					reason: transitionOptions.reason,
-					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
+	for (const task of await stores.tasks.list()) {
+		if (task.state !== "stalled") continue;
+		try {
+			if (task.attempt < options.policy.maxAttempts) {
+				await stores.tasks.transition(task.id, "queued", {
+					reason: `stalled on attempt ${task.attempt} of ${options.policy.maxAttempts}; replacing`,
+					expectFrom: "stalled"
 				});
-				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
+				result.requeued.push(task.id);
+			} else {
+				await stores.tasks.transition(task.id, "failed", {
+					reason: `stalled on attempt ${task.attempt} of ${options.policy.maxAttempts}; attempts exhausted`,
+					expectFrom: "stalled"
 				});
-			},
-			async get(id) {
-				const record = await read("receipts", id, receiptSchema);
-				return record === null ? null : record.value;
-			},
-			list() {
-				return listAll("receipts", receiptSchema);
+				result.failed.push(task.id);
 			}
+		} catch {
+			continue;
 		}
-	};
+	}
+	return result;
 }
 //#endregion
 //#region src/store/memory.ts
@@ -1057,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
@@ -1071,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({
@@ -1082,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") {
@@ -1097,22 +449,27 @@ 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) });
+			await dispatchTask(stores, task.id, {
+				launch: (dispatched) => launcher(dispatched, repository),
+				budget: options.budget
+			});
 			result.dispatched.push(task.id);
 		} catch (error) {
 			if (error instanceof DispatchRefusedError) {
@@ -1160,6 +517,6 @@ async function ensureVerificationTasks(stores) {
 	return result;
 }
 //#endregion
-export { ApprovalError, ChangeAssociationError, DEFAULT_MAX_LAUNCH_ATTEMPTS, DispatchRefusedError, InvalidTransitionError, RecordExistsError, RecordNotFoundError, SCHEMA_VERSION, 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 { 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