@mastra/factory 0.0.0-aggregate-trace-20261015182851

package/dist/rules/dispatcher.js

@@ -0,0 +1,1159 @@
+import { FACTORY_RULE_STAGES, externalSourceForWorkItem, externallyAuthoredWorkItem } from "./types.js";
+import { assertFactoryDecisionTarget, validateFactoryRuleDecision } from "./validation.js";
+import { boardForWorkItem, resolvePhaseSemantics, workItemPhaseSemantics } from "../boards/semantics.js";
+import { createBoardRegistry } from "../boards/registry.js";
+import "../boards/index.js";
+import { FactoryDispatchError, factoryDispatchFailureCode, factoryDispatchFailureMetadata } from "./dispatch-errors.js";
+import { FACTORY_RULE_MATERIALIZATION_KEY, WorkItemClaimConflictError } from "../storage/domains/work-items/base.js";
+import { moveCardToBoard } from "../boards/relocate.js";
+import { isHumanActorId } from "../storage/domains/audit/actors.js";
+import { resolvePromptInvocation, resolveSkillInvocation, resolveSkillResumeInvocation } from "../skills/service.js";
+import { decisionOvertaken } from "./decision-applicability.js";
+import { FACTORY_OPEN_RUN_STALE_MS, heartbeatSessionOpenRun, isOpenRunLiveElsewhere, listSessionOpenRuns, recordSessionRunStart, waitForSessionRunAudit } from "../session/run-audit.js";
+import { withWorkItemFeed } from "../storage/domains/comments/feed-context.js";
+import { RequestContext } from "@mastra/core/request-context";
+//#region src/rules/dispatcher.ts
+const LEASE_MS = 3e4;
+const POLL_MS = 1e3;
+const BATCH_SIZE = 10;
+const MAX_ATTEMPTS = 5;
+const MAX_PLAN_APPROVALS = 3;
+const MAX_ERROR_LENGTH = 512;
+const MAX_BACKOFF_MS = 6e4;
+const RUN_REGISTRY_HEARTBEAT_MS = 10 * 6e4;
+const SKILL_COMPLETION_OBSERVATION_TIMEOUT_MS = 360 * 6e4;
+const MAX_IN_FLIGHT = 25;
+/**
+* Decisions that may start or wake an agent run and so hold a run slot. A
+* transition's message is queued as a separate sendMessage, so the transition
+* itself stays bookkeeping.
+*/
+const isRunBearingDecision = (decision) => decision.type === "invokeSkill" || decision.type === "sendMessage";
+const isBookkeepingDecision = (decision) => !isRunBearingDecision(decision);
+const BOOKKEEPING_MAX_IN_FLIGHT = 4;
+const STALE_BINDING_SWEEP_INTERVAL_MS = 10 * 6e4;
+const STALE_BINDING_TTL_MS = 1440 * 6e4;
+const RECONCILE_INTERVAL_MS = 3e4;
+/** The card moved on before this run could act; it settles as superseded, not succeeded. */
+var FactoryDecisionSuperseded = class extends Error {};
+function isTerminalFailure(attempts, failureCode) {
+	return attempts >= MAX_ATTEMPTS || !factoryDispatchFailureMetadata(failureCode).canRetry;
+}
+/**
+* Conservative check for observational-memory failures that a retry cannot fix:
+* a provider rejecting the request outright (HTTP 400 / model unsupported /
+* authentication). Anything ambiguous (timeouts, 5xx, rate limits, network
+* blips) is intentionally left retryable to avoid dead-ending a card that would
+* have recovered on its own.
+*/
+function isPermanentProviderRejection(error) {
+	const normalized = error.toLowerCase();
+	return /\bhttp(?:\/\d(?:\.\d)?)?\s*400\b/.test(normalized) || /\bstatus(?:\s*code)?\s*[:=]?\s*400\b/.test(normalized) || /\b400\s*(?:bad request|status)\b/.test(normalized) || normalized.includes("model not supported") || normalized.includes("model is not supported") || normalized.includes("unsupported model") || normalized.includes("not supported with") || normalized.includes("unauthorized") || normalized.includes("authentication") || normalized.includes("invalid") && normalized.includes("model");
+}
+function watchRun(session, { timeoutMs, approvePlans, onAgentEnd, label, runStillActive }) {
+	let resolveAgentEnd;
+	let agentEnd;
+	let endReason;
+	let supersededAtEnd;
+	let parked;
+	let omFailure;
+	const arm = () => {
+		endReason = void 0;
+		supersededAtEnd = void 0;
+		omFailure = void 0;
+		agentEnd = new Promise((resolve) => {
+			resolveAgentEnd = resolve;
+		});
+	};
+	arm();
+	const unsubscribe = session.subscribe((event) => {
+		if (event.type === "agent_end") {
+			endReason = event.reason;
+			supersededAtEnd = onAgentEnd?.();
+			resolveAgentEnd();
+			return;
+		}
+		if (event.type === "om_observation_failed" || event.type === "om_buffering_failed") {
+			if (event.error) omFailure = event.error;
+			return;
+		}
+		if (event.type === "tool_suspended") {
+			parked = {
+				toolName: event.toolName,
+				toolCallId: event.toolCallId
+			};
+			return;
+		}
+		if (event.type === "tool_suspension_cancelled" && parked?.toolCallId === event.toolCallId) parked = void 0;
+	});
+	const wait = async () => {
+		const deadline = Date.now() + timeoutMs;
+		while (Date.now() < deadline) {
+			const heartbeatMs = Math.min(RUN_REGISTRY_HEARTBEAT_MS, deadline - Date.now());
+			if (await waitForAgentEndOrTimeout(agentEnd, heartbeatMs)) return true;
+			if (!runStillActive()) return false;
+		}
+		throw new FactoryDispatchError("run_overdue", `${label} is still in flight after ${Math.round(timeoutMs / 36e5)} hours and needs a person.`);
+	};
+	return {
+		arm,
+		wait,
+		supersededAtEnd: () => supersededAtEnd,
+		endReason: () => endReason,
+		close: unsubscribe,
+		/** The run's own verdict, thrown as what the dispatcher should record. */
+		async settle() {
+			let observed = await wait();
+			if (approvePlans) for (let approvals = 0; parked?.toolName === "submit_plan" && approvals < MAX_PLAN_APPROVALS; approvals += 1) {
+				const { toolCallId } = parked;
+				parked = void 0;
+				arm();
+				await session.respondToToolSuspension({
+					resumeData: { action: "approved" },
+					toolCallId
+				});
+				observed = await wait();
+			}
+			if (!observed) throw new FactoryDispatchError("run_terminal_event_missing", `${label} terminal event was not observed before timeout.`);
+			if (endReason === "error") throw new Error(`${label} ended in error.`);
+			if (endReason === "aborted") {
+				if (omFailure) {
+					if (isPermanentProviderRejection(omFailure)) throw new FactoryDispatchError("run_configuration_invalid", `${label} was aborted by an observational-memory failure that will not succeed on retry: ${omFailure}`);
+					throw new Error(`${label} was aborted after an observational-memory failure: ${omFailure}`);
+				}
+				throw new Error(`${label} was aborted before it finished.`);
+			}
+		}
+	};
+}
+function waitForAgentEndOrTimeout(agentEnd, timeoutMs) {
+	return new Promise((resolve) => {
+		const timeout = setTimeout(() => resolve(false), timeoutMs);
+		timeout.unref?.();
+		agentEnd.then(() => {
+			clearTimeout(timeout);
+			resolve(true);
+		});
+	});
+}
+function factoryRequestContext(input) {
+	const { session, binding, userId, orgId } = input;
+	const requestContext = new RequestContext();
+	requestContext.set("user", {
+		workosId: userId,
+		organizationId: orgId
+	});
+	requestContext.set("controller", {
+		state: session.state.get(),
+		getState: () => session.state.get(),
+		threadId: binding.threadId,
+		resourceId: binding.resourceId,
+		session: {
+			id: session.identity.getId(),
+			ownerId: session.identity.getOwnerId(),
+			modelId: session.model.get() ?? ""
+		},
+		workspace: session.getWorkspace()
+	});
+	return requestContext;
+}
+function positiveMs(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function sanitizeDispatchError(error) {
+	return (error instanceof Error ? error.message : String(error)).replace(/\b(?:bearer|token|api[-_ ]?key|authorization)\s*[:=]?\s*[^\s,;]+/gi, "[redacted]").slice(0, MAX_ERROR_LENGTH);
+}
+function retryAt(now, attempts) {
+	return new Date(now.getTime() + Math.min(1e3 * 2 ** Math.max(0, attempts - 1), MAX_BACKOFF_MS));
+}
+function externalSourceForDecision(decision) {
+	return externalSourceForWorkItem(decision.source, decision.sourceKey, decision.url ?? void 0);
+}
+function deferredActor(record) {
+	const actor = record.actor;
+	if (actor?.type === "github" && typeof actor.login === "string" && typeof actor.trusted === "boolean" && typeof actor.factoryAuthored === "boolean") return {
+		type: "github",
+		login: actor.login,
+		trusted: actor.trusted,
+		factoryAuthored: actor.factoryAuthored
+	};
+	if (actor?.type === "gitlab" && typeof actor.username === "string" && typeof actor.trusted === "boolean" && typeof actor.factoryAuthored === "boolean") return {
+		type: "gitlab",
+		username: actor.username,
+		trusted: actor.trusted,
+		factoryAuthored: actor.factoryAuthored
+	};
+	return {
+		type: "system",
+		id: "factory-rule-dispatcher"
+	};
+}
+function externalActor(actor) {
+	return actor !== null && actor.type !== "human" && actor.type !== "agent" && actor.type !== "system";
+}
+/** A run start asks for consent; an external event asks before pulling a card back into a working lane. */
+function requestsConsent(boards, record, decision) {
+	if (decision.type === "invokeSkill") return true;
+	if (decision.type !== "transition" || !externalActor(record.actor)) return false;
+	return (resolvePhaseSemantics(boards, decision.board, decision.stage)?.kind ?? "working") === "working";
+}
+function reviewsFactoryAuthoredCode(item, decision) {
+	if (item.metadata?.factoryAuthored !== true) return false;
+	if (decision.type === "transition") return decision.board === "review" && decision.stage === "review";
+	return decision.type === "invokeSkill" && decision.role === "review";
+}
+function leaseIdentity(record, ownerId) {
+	return {
+		id: record.id,
+		orgId: record.orgId,
+		factoryProjectId: record.factoryProjectId,
+		ownerId
+	};
+}
+async function awaitNotification(send, requireDelivery = false) {
+	try {
+		const notification = await send();
+		const [, accepted] = await Promise.all([notification.persisted, notification.accepted]);
+		if (!accepted) {
+			if (requireDelivery) throw new FactoryDispatchError("notification_delivery_failed", "Factory notification was persisted without agent delivery.");
+			return;
+		}
+		if (!requireDelivery) return accepted;
+		if (accepted.action === "wake") {
+			if (!accepted.output) throw new FactoryDispatchError("notification_delivery_failed", "Factory notification wake had no output.");
+			await accepted.output.consumeStream();
+			return accepted;
+		}
+		if (accepted.action !== "deliver") throw new FactoryDispatchError("notification_delivery_failed", `Factory notification did not reach the agent (${String(accepted.action)}).`);
+		return accepted;
+	} catch (error) {
+		if (error instanceof FactoryDispatchError) throw error;
+		throw new FactoryDispatchError("notification_delivery_failed", `Factory notification delivery failed: ${sanitizeDispatchError(error)}`, { cause: error });
+	}
+}
+var FactoryDecisionDispatcher = class {
+	#audit;
+	#controller;
+	#transitionService;
+	#boards;
+	#storage;
+	#ownerId;
+	#isAutoRunEnabled;
+	#autoApprovePlans;
+	#reconcileToolResults;
+	#prepareBinding;
+	#primeCredentials;
+	#feedReader;
+	#dismissStaleReviews;
+	#resolveLinkedWorkItemParentId;
+	#maxInFlight;
+	#staleBindingSweepIntervalMs;
+	#staleBindingTtlMs;
+	#lastStaleBindingSweepAt;
+	#reconcileIntervalMs;
+	#skillCompletionObservationTimeoutMs;
+	#lastReconcileAt;
+	#reconcileInFlight;
+	#timer;
+	#activeClaim;
+	/** Starts and run-bearing decisions; capped by `maxInFlight`. */
+	#runInFlight = /* @__PURE__ */ new Set();
+	/** Fast board bookkeeping (transitions, linked-card upserts); its own small cap. */
+	#bookkeepingInFlight = /* @__PURE__ */ new Set();
+	/** Background work awaited on stop but outside both caps. */
+	#backgroundInFlight = /* @__PURE__ */ new Set();
+	#bindingSkillRuns = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.#audit = options.audit;
+		this.#controller = options.controller;
+		this.#transitionService = options.transitionService;
+		this.#boards = options.boards ?? createBoardRegistry();
+		this.#storage = options.storage;
+		this.#ownerId = options.ownerId ?? `factory-dispatcher:${globalThis.crypto.randomUUID()}`;
+		this.#isAutoRunEnabled = options.isAutoRunEnabled;
+		this.#autoApprovePlans = options.autoApprovePlans;
+		this.#reconcileToolResults = options.reconcileToolResults;
+		this.#prepareBinding = options.prepareBinding;
+		this.#primeCredentials = options.primeCredentials;
+		this.#feedReader = options.feedReader;
+		this.#dismissStaleReviews = options.dismissStaleReviews;
+		this.#resolveLinkedWorkItemParentId = options.resolveLinkedWorkItemParentId;
+		const maxInFlight = options.maxInFlight ?? MAX_IN_FLIGHT;
+		this.#maxInFlight = Number.isFinite(maxInFlight) && maxInFlight > 0 ? Math.floor(maxInFlight) : MAX_IN_FLIGHT;
+		this.#staleBindingSweepIntervalMs = positiveMs(options.staleBindingSweepIntervalMs, STALE_BINDING_SWEEP_INTERVAL_MS);
+		this.#staleBindingTtlMs = positiveMs(options.staleBindingTtlMs, STALE_BINDING_TTL_MS);
+		this.#reconcileIntervalMs = positiveMs(options.reconcileIntervalMs, RECONCILE_INTERVAL_MS);
+		this.#skillCompletionObservationTimeoutMs = positiveMs(options.skillCompletionObservationTimeoutMs, SKILL_COMPLETION_OBSERVATION_TIMEOUT_MS);
+	}
+	start() {
+		if (this.#timer) return;
+		this.#tick();
+		this.#timer = setInterval(() => void this.#tick(), POLL_MS);
+		this.#timer.unref?.();
+	}
+	async stop() {
+		if (this.#timer) clearInterval(this.#timer);
+		this.#timer = void 0;
+		await this.#activeClaim;
+		await Promise.allSettled([
+			...this.#runInFlight,
+			...this.#bookkeepingInFlight,
+			...this.#backgroundInFlight
+		]);
+	}
+	async runOnce(now = /* @__PURE__ */ new Date()) {
+		await Promise.all(await this.#claimAndStart(now));
+	}
+	/**
+	* Claims a batch and starts dispatches without awaiting their completion.
+	* Dispatches can legitimately take minutes (skill kickoffs consume the
+	* agent's run stream; binding preparation provisions sandboxes), so awaiting
+	* them here would freeze the poll loop and starve every other queued
+	* decision. In-flight records stay protected from re-claim by lease renewal.
+	*/
+	async #claimAndStart(now) {
+		this.#maybeSweepStaleBindings(now);
+		this.#maybeReconcileToolResults(now);
+		const leaseExpiresAt = new Date(now.getTime() + LEASE_MS);
+		const dispatches = [];
+		const runCapacity = this.#maxInFlight - this.#runInFlight.size;
+		if (runCapacity > 0) {
+			const limit = Math.min(BATCH_SIZE, runCapacity);
+			const starts = await this.#storage.claimPendingStarts({
+				ownerId: this.#ownerId,
+				now,
+				leaseExpiresAt,
+				limit
+			});
+			const decisionsLimit = limit - starts.length;
+			const decisions = decisionsLimit > 0 ? await this.#storage.claimDeferredDecisions({
+				ownerId: this.#ownerId,
+				now,
+				leaseExpiresAt,
+				limit: decisionsLimit,
+				decisionFilter: isRunBearingDecision
+			}) : [];
+			dispatches.push(...starts.map((start) => this.#track(this.#runInFlight, this.#dispatchPendingStart(start, now))), ...decisions.map((decision) => this.#track(this.#runInFlight, this.#dispatchDecision(decision, now))));
+		}
+		const bookkeepingCapacity = BOOKKEEPING_MAX_IN_FLIGHT - this.#bookkeepingInFlight.size;
+		if (bookkeepingCapacity > 0) {
+			const decisions = await this.#storage.claimDeferredDecisions({
+				ownerId: this.#ownerId,
+				now,
+				leaseExpiresAt,
+				limit: Math.min(BATCH_SIZE, bookkeepingCapacity),
+				decisionFilter: isBookkeepingDecision
+			});
+			dispatches.push(...decisions.map((decision) => this.#track(this.#bookkeepingInFlight, this.#dispatchDecision(decision, now))));
+		}
+		return dispatches;
+	}
+	/**
+	* Throttled, coalesced, non-blocking bound-thread reconcile: dispatch
+	* claiming never waits behind cursor + message reads, and overlapping runs
+	* are skipped while one is still in flight.
+	*/
+	#maybeReconcileToolResults(now) {
+		if (!this.#reconcileToolResults || this.#reconcileInFlight) return;
+		if (this.#lastReconcileAt && now.getTime() - this.#lastReconcileAt.getTime() < this.#reconcileIntervalMs) return;
+		this.#lastReconcileAt = now;
+		const run = this.#reconcileToolResults().catch((error) => {
+			console.error("Factory tool-result reconcile failed", sanitizeDispatchError(error));
+		}).finally(() => {
+			this.#reconcileInFlight = void 0;
+		});
+		this.#reconcileInFlight = run;
+		this.#track(this.#backgroundInFlight, run);
+	}
+	/** Slow-cadence revocation of leaked/legacy bindings; failures never block the claim path. */
+	async #maybeSweepStaleBindings(now) {
+		if (!this.#lastStaleBindingSweepAt) {
+			this.#lastStaleBindingSweepAt = now;
+			return;
+		}
+		if (now.getTime() - this.#lastStaleBindingSweepAt.getTime() < this.#staleBindingSweepIntervalMs) return;
+		this.#lastStaleBindingSweepAt = now;
+		try {
+			const revoked = await this.#storage.revokeStaleRunBindings({
+				olderThan: new Date(now.getTime() - this.#staleBindingTtlMs),
+				now
+			});
+			if (revoked > 0) console.info(`Factory stale-binding sweep revoked ${revoked} binding(s)`);
+		} catch (error) {
+			console.error("Factory stale-binding sweep failed", sanitizeDispatchError(error));
+		}
+	}
+	#track(pool, dispatch) {
+		pool.add(dispatch);
+		dispatch.catch(() => {}).then(() => pool.delete(dispatch));
+		return dispatch;
+	}
+	async #tick() {
+		if (this.#activeClaim) return;
+		this.#activeClaim = this.#claimAndStart(/* @__PURE__ */ new Date()).then((dispatches) => {
+			for (const dispatch of dispatches) dispatch.catch((error) => {
+				console.error("Factory decision dispatch failed", sanitizeDispatchError(error));
+			});
+		}, (error) => {
+			console.error("Factory decision dispatch cycle failed", sanitizeDispatchError(error));
+		});
+		try {
+			await this.#activeClaim;
+		} finally {
+			this.#activeClaim = void 0;
+		}
+	}
+	async #dispatchDecision(record, now) {
+		let executionCompleted = false;
+		try {
+			const decision = validateFactoryRuleDecision(record.decision, record.causalChain.length);
+			if (decision.type === "reject") throw new Error("Deferred Factory decisions cannot reject.");
+			if (await this.#needsApproval(record, decision)) {
+				if (!await this.#storage.proposeDeferredDecision(leaseIdentity(record, this.#ownerId), /* @__PURE__ */ new Date())) throw new Error("Factory decision lease was lost before approval could be requested.");
+				return;
+			}
+			await this.#supersedeProposals(record, decision);
+			await this.#withLease(async (leaseExpiresAt) => this.#storage.renewDeferredDecisionLease(leaseIdentity(record, this.#ownerId), leaseExpiresAt), async () => this.#executeDecision(record, decision));
+			executionCompleted = true;
+			if (!await this.#storage.completeDeferredDecision(leaseIdentity(record, this.#ownerId), /* @__PURE__ */ new Date())) throw new Error("Factory decision lease was lost before completion.");
+		} catch (error) {
+			if (error instanceof FactoryDecisionSuperseded) {
+				await this.#storage.supersedeLeasedDecision(leaseIdentity(record, this.#ownerId), /* @__PURE__ */ new Date());
+				return;
+			}
+			const failureCode = factoryDispatchFailureCode(error);
+			const terminal = isTerminalFailure(record.attempts, failureCode);
+			const failed = await this.#storage.failDeferredDecision({
+				...leaseIdentity(record, this.#ownerId),
+				now: /* @__PURE__ */ new Date(),
+				availableAt: retryAt(now, record.attempts),
+				lastError: sanitizeDispatchError(error),
+				failureCode,
+				terminal,
+				advanceDeliveryGeneration: !executionCompleted
+			});
+			if (terminal && failed) await this.#supersedeFailureOnSettledCard(failed);
+		}
+	}
+	/**
+	* Startup repair and terminal cleanup already settle a failed effect on a done or canceled
+	* card as superseded; a failure landing after the card settled would otherwise page a person
+	* until the next restart.
+	*/
+	async #supersedeFailureOnSettledCard(record) {
+		if (!record.workItemId) return;
+		try {
+			const item = await this.#storage.get({
+				orgId: record.orgId,
+				id: record.workItemId
+			});
+			if (!item || workItemPhaseSemantics(this.#boards, item)?.kind !== "terminal") return;
+			await this.#storage.supersedeDecisionsForWorkItem({
+				orgId: record.orgId,
+				factoryProjectId: record.factoryProjectId,
+				workItemId: record.workItemId,
+				supersededAt: /* @__PURE__ */ new Date()
+			});
+		} catch (error) {
+			console.error("Factory settled-card supersede failed", sanitizeDispatchError(error));
+		}
+	}
+	/**
+	* A proposal is a question: "should this run start?" Once that run is
+	* starting anyway — because a person approved a later copy, or armed the item
+	* — the question has been answered and the card must stop asking it. Left
+	* alone the badge outlives the work it describes, and the one affordance that
+	* means "the loop is stopped, answer this" cries wolf.
+	*/
+	async #supersedeProposals(record, decision) {
+		if (decision.type !== "invokeSkill" || !record.workItemId) return;
+		try {
+			await this.#storage.supersedeDecisionsForWorkItem({
+				orgId: record.orgId,
+				factoryProjectId: record.factoryProjectId,
+				workItemId: record.workItemId,
+				role: decision.role,
+				supersededAt: /* @__PURE__ */ new Date()
+			});
+		} catch (error) {
+			console.error("Factory proposal supersede failed", sanitizeDispatchError(error));
+		}
+	}
+	async #needsApproval(record, decision) {
+		if (record.approvedAt !== null || !requestsConsent(this.#boards, record, decision)) return false;
+		const item = record.workItemId ? await this.#storage.get({
+			orgId: record.orgId,
+			id: record.workItemId
+		}) : null;
+		if (item && externallyAuthoredWorkItem(item)) return true;
+		if (item?.autonomyArmedAt != null) return false;
+		if (item && reviewsFactoryAuthoredCode(item, decision)) return false;
+		return !await this.#isAutoRunEnabled({
+			orgId: record.orgId,
+			factoryProjectId: record.factoryProjectId
+		});
+	}
+	async #executeDecision(record, decision) {
+		const nextChain = [...record.causalChain, {
+			ingressId: record.idempotencyKey,
+			decisionType: decision.type
+		}];
+		if (nextChain.length > 8) throw new Error("Factory rule causal depth exceeded.");
+		switch (decision.type) {
+			case "transition": {
+				const item = await this.#requireItem(record);
+				if (!await this.#storage.getTransitionResultByIngress(record.orgId, record.factoryProjectId, `decision:${record.idempotencyKey}`)) assertFactoryDecisionTarget(decision, this.#boards, item.board ?? void 0);
+				const result = await this.#transitionService.transition({
+					orgId: record.orgId,
+					factoryProjectId: record.factoryProjectId,
+					workItemId: item.id,
+					board: decision.board,
+					stage: decision.stage,
+					expectedRevision: item.revision,
+					actor: record.approvedBy ? {
+						type: "human",
+						id: record.approvedBy
+					} : {
+						type: "system",
+						id: "factory-rule-dispatcher"
+					},
+					ingress: {
+						type: "rule",
+						identity: `decision:${record.idempotencyKey}`
+					},
+					cause: "rule_decision",
+					causalChain: nextChain,
+					...decision.reenter ? { reenter: true } : {}
+				});
+				if (result.status === "rejected") throw new Error(`${result.code}: ${result.reason}`);
+				const transitionMessage = decision.message;
+				if (!transitionMessage) return;
+				const moved = await this.#storage.get({
+					orgId: record.orgId,
+					id: item.id
+				});
+				if (!moved) return;
+				const messageKey = `${record.idempotencyKey}:message`;
+				const queued = await this.#storage.commitRuleEvaluation({
+					orgId: record.orgId,
+					factoryProjectId: record.factoryProjectId,
+					workItemId: item.id,
+					ingress: {
+						identity: `decision:${messageKey}@${moved.revision}`,
+						triggerType: "transition.message"
+					},
+					configVersion: this.#transitionService.configVersion,
+					expectedRevision: moved.revision,
+					actor: record.actor ?? {
+						type: "system",
+						id: "factory-rule-dispatcher"
+					},
+					outcome: { status: "accepted" },
+					decisions: [{
+						type: "sendMessage",
+						idempotencyKey: messageKey,
+						message: transitionMessage.text,
+						priority: "high",
+						idleBehavior: "wake",
+						...transitionMessage.role !== void 0 ? { role: transitionMessage.role } : {}
+					}],
+					causalChain: nextChain,
+					now: /* @__PURE__ */ new Date()
+				});
+				if (queued.status === "missing") return;
+				if (queued.status === "stale") throw new Error("Factory transition message was not queued: the work item changed concurrently.");
+				const queuedStatus = queued.result.status;
+				if (queuedStatus !== "accepted") throw new Error(`Factory transition message was not queued: ${queuedStatus ?? "unknown"}.`);
+				return;
+			}
+			case "upsertLinkedWorkItem":
+				await this.#upsertLinkedItem(record, decision, nextChain);
+				return;
+			case "invokeSkill": {
+				if (await this.#roleSuperseded(record, decision.role) || await this.#decisionOvertaken(record, decision.role)) throw new FactoryDecisionSuperseded();
+				const binding = await this.#requireOrPrepareBinding(record, decision.role);
+				await this.#withBindingSkillRun(binding.id, async () => {
+					const item = record.workItemId ? await this.#storage.get({
+						orgId: record.orgId,
+						id: record.workItemId
+					}) : null;
+					const startedBy = item?.sessions[binding.role]?.startedBy;
+					if (!startedBy) throw new Error(`Factory binding ${binding.id} has no authenticated session owner.`);
+					await this.#primeCredentials?.({
+						orgId: record.orgId,
+						userId: startedBy
+					});
+					const session = await this.#requireSession(binding);
+					const requestContext = factoryRequestContext({
+						session,
+						binding,
+						userId: startedBy,
+						orgId: record.orgId
+					});
+					const resolved = decision.skillName === void 0 ? await resolvePromptInvocation(this.#controller, {
+						resourceId: binding.resourceId,
+						prompt: decision.prompt
+					}) : decision.resume === true ? await resolveSkillResumeInvocation(this.#controller, {
+						resourceId: binding.resourceId,
+						name: decision.skillName,
+						arguments: decision.arguments
+					}) : await resolveSkillInvocation(this.#controller, {
+						resourceId: binding.resourceId,
+						name: decision.skillName,
+						arguments: decision.arguments
+					});
+					await this.#switchThread(session, binding);
+					const deliveryId = record.deliveryGeneration === 0 ? record.id : `${record.id}:retry:${record.deliveryGeneration}`;
+					const kickoffLanded = async () => (await session.thread.listActiveMessages()).some((message) => message.id === deliveryId);
+					const kickoffStale = async () => await this.#roleSuperseded(record, decision.role) || (await this.#findBinding(record, decision.role))?.id !== binding.id || await this.#decisionOvertaken(record, decision.role);
+					const runStillActive = () => this.#controller.listActiveThreadRuns().some((active) => active.threadId === binding.threadId);
+					while (true) {
+						const openRun = watchRun(session, {
+							timeoutMs: this.#skillCompletionObservationTimeoutMs,
+							approvePlans: false,
+							label: "Factory skill run",
+							runStillActive
+						});
+						try {
+							const open = (await listSessionOpenRuns(session)).filter((entry) => entry.bindingId === binding.id);
+							if (open.length === 0) break;
+							if (open.some((entry) => isOpenRunLiveElsewhere(entry, this.#ownerId))) throw new FactoryDispatchError("session_unavailable", `Factory binding ${binding.id} has a run in flight on another dispatcher.`);
+							if (!runStillActive()) break;
+							if (!await openRun.wait()) break;
+						} finally {
+							openRun.close();
+						}
+						await waitForSessionRunAudit(session);
+					}
+					if (await this.#roleSuperseded(record, decision.role)) throw new FactoryDecisionSuperseded();
+					if ((await this.#requireBinding(record, decision.role)).id !== binding.id) throw new FactoryDispatchError("session_unavailable", `Factory binding ${binding.id} changed while waiting for its open run to end.`);
+					if (await kickoffLanded()) return;
+					if (await kickoffStale()) throw new FactoryDecisionSuperseded();
+					const kickoffContents = await withWorkItemFeed(this.#feedReader, {
+						orgId: record.orgId,
+						factoryProjectId: record.factoryProjectId,
+						workItemId: record.workItemId
+					}, resolved.message);
+					if (await kickoffLanded()) return;
+					if (await kickoffStale()) throw new FactoryDecisionSuperseded();
+					if (decision.cancelInFlight && session.stream.isActive()) session.abort();
+					const precedingMessage = decision.precedingMessage;
+					if (precedingMessage) {
+						await awaitNotification(() => session.sendNotificationSignal({
+							source: "factory",
+							kind: "stage-transition",
+							summary: precedingMessage,
+							priority: "medium",
+							payload: { message: precedingMessage },
+							sourceId: `${record.id}:stage-transition`,
+							dedupeKey: `${record.idempotencyKey}:stage-transition`
+						}, {
+							ifActive: { behavior: "deliver" },
+							ifIdle: { behavior: "persist" },
+							requestContext
+						}));
+						if (await kickoffStale()) throw new FactoryDecisionSuperseded();
+					}
+					const run = watchRun(session, {
+						timeoutMs: this.#skillCompletionObservationTimeoutMs,
+						approvePlans: await this.#plansAreAutoApproved(record),
+						onAgentEnd: () => this.#roleSuperseded(record, decision.role),
+						label: "Factory skill run",
+						runStillActive
+					});
+					const sendKickoff = async () => {
+						const settled = await session.sendSignal({
+							id: deliveryId,
+							type: "user",
+							tagName: "user",
+							contents: kickoffContents
+						}, {
+							requestContext,
+							requireDelivery: true
+						}).accepted;
+						if (settled.action !== "wake" && settled.action !== "deliver") throw new FactoryDispatchError(settled.action ? "notification_delivery_failed" : "skill_delivery_ambiguous", `Factory skill invocation signal did not reach the agent (${String(settled.action)}).`);
+						return settled;
+					};
+					try {
+						let settled = await sendKickoff();
+						while (settled.action === "deliver") {
+							if (await kickoffLanded()) break;
+							if (!await run.wait()) throw new FactoryDispatchError("run_terminal_event_missing", "Factory skill invocation is waiting on a run whose terminal event was not observed.");
+							if (await kickoffLanded()) break;
+							if (await kickoffStale()) throw new FactoryDecisionSuperseded();
+							run.arm();
+							settled = await sendKickoff();
+						}
+						await this.#recordRunStart(session, binding, deliveryId, record.approvedBy ?? void 0, run.endReason, item?.title);
+						try {
+							await this.#withOpenRunHeartbeat(session, deliveryId, () => run.settle());
+						} catch (error) {
+							if (!(await run.supersededAtEnd() ?? await this.#roleSuperseded(record, decision.role))) throw error;
+						}
+					} finally {
+						run.close();
+					}
+				});
+				return;
+			}
+			case "sendMessage": {
+				const binding = await this.#messageBinding(record, decision);
+				if (!binding) return;
+				const startedBy = (record.workItemId ? await this.#storage.get({
+					orgId: record.orgId,
+					id: record.workItemId
+				}) : null)?.sessions[binding.role]?.startedBy;
+				if (!startedBy) throw new Error(`Factory binding ${binding.id} has no authenticated session owner.`);
+				await this.#primeCredentials?.({
+					orgId: record.orgId,
+					userId: startedBy
+				});
+				const session = await this.#requireSession(binding);
+				const requestContext = factoryRequestContext({
+					session,
+					binding,
+					userId: startedBy,
+					orgId: record.orgId
+				});
+				await awaitNotification(() => session.sendNotificationSignal({
+					source: "factory",
+					kind: "rule-message",
+					summary: decision.message,
+					priority: decision.priority ?? "high",
+					payload: { message: decision.message },
+					sourceId: record.id,
+					dedupeKey: record.idempotencyKey
+				}, {
+					ifActive: { behavior: "deliver" },
+					ifIdle: { behavior: decision.idleBehavior ?? "wake" },
+					requestContext
+				}), true);
+				return;
+			}
+			case "dismissStaleReviews":
+				if (!this.#dismissStaleReviews) throw new Error("GitHub review dismissal is not configured.");
+				await this.#dismissStaleReviews(decision);
+				return;
+			case "notify": {
+				const binding = await this.#requireBinding(record);
+				const session = await this.#requireSession(binding);
+				await awaitNotification(() => session.sendNotificationSignal({
+					source: "factory",
+					kind: "rule-notification",
+					summary: decision.title,
+					payload: {
+						body: decision.body,
+						level: decision.level
+					},
+					sourceId: record.id,
+					dedupeKey: record.idempotencyKey
+				}));
+			}
+		}
+	}
+	async #upsertLinkedItem(record, decision, causalChain) {
+		const existing = await this.#storage.getByProjectSource({
+			orgId: record.orgId,
+			factoryProjectId: record.factoryProjectId,
+			source: externalSourceForDecision(decision)
+		});
+		if (existing?.metadata?.["factoryRuleMaterializationKey"] === record.idempotencyKey) {
+			if (decision.skipRules === true) return;
+			for (const suffix of ["destination", "initial-entry"]) {
+				const replay = await this.#storage.getTransitionResultByIngress(record.orgId, record.factoryProjectId, `decision:${record.idempotencyKey}:${existing.id}:${suffix}`);
+				if (replay?.status === "accepted" && replay.stage === decision.stage) return;
+			}
+		}
+		assertFactoryDecisionTarget(decision, this.#boards);
+		const definition = this.#boards.get(decision.board);
+		if (!definition) throw new Error("Factory decision target board is not installed.");
+		const initialPhase = definition.initialPhase;
+		const skipRules = decision.skipRules === true;
+		const entryStage = skipRules ? decision.stage : initialPhase;
+		const parentWorkItemId = record.workItemId ?? await this.#resolveLinkedWorkItemParentId?.({
+			orgId: record.orgId,
+			factoryProjectId: record.factoryProjectId,
+			decision
+		}) ?? null;
+		let result;
+		try {
+			result = await this.#storage.upsert({
+				orgId: record.orgId,
+				userId: "factory-rule-dispatcher",
+				factoryProjectId: record.factoryProjectId,
+				input: {
+					externalSource: externalSourceForDecision(decision),
+					...decision.claimKey ? { claimKey: decision.claimKey } : {},
+					parentWorkItemId,
+					title: decision.title,
+					board: decision.board,
+					stages: [entryStage],
+					sessions: {},
+					metadata: {
+						...decision.metadata,
+						[FACTORY_RULE_MATERIALIZATION_KEY]: record.idempotencyKey
+					}
+				},
+				reuseMode: "preserve"
+			});
+		} catch (error) {
+			if (error instanceof WorkItemClaimConflictError) return;
+			throw error;
+		}
+		if (!result.created && decision.claimKey && !result.item.claimKey) {
+			const claimed = await this.#storage.claimWorkItem({
+				orgId: record.orgId,
+				id: result.item.id,
+				claimKey: decision.claimKey
+			});
+			if (claimed) result = {
+				...result,
+				item: claimed
+			};
+		}
+		const itemBoard = boardForWorkItem(result.item);
+		if (!skipRules && itemBoard !== decision.board) throw new Error(`The work item belongs to board "${itemBoard}", not "${decision.board}".`);
+		if (!result.item.parentWorkItemId && parentWorkItemId && parentWorkItemId !== result.item.id) {
+			const item = await this.#storage.setParentWorkItemIfMissing({
+				orgId: record.orgId,
+				id: result.item.id,
+				userId: "factory-rule-dispatcher",
+				parentWorkItemId
+			});
+			if (item) result = {
+				...result,
+				item
+			};
+		}
+		if (!result.created && !skipRules) {
+			const missing = Object.fromEntries(Object.entries(decision.metadata ?? {}).filter(([key]) => key !== "factoryRuleMaterializationKey" && result.item.metadata?.[key] === void 0));
+			if (Object.keys(missing).length > 0) {
+				const filled = await this.#storage.update({
+					orgId: record.orgId,
+					id: result.item.id,
+					userId: "factory-rule-dispatcher",
+					patch: { metadata: missing }
+				});
+				if (filled) result = {
+					...result,
+					item: filled.item
+				};
+			}
+		}
+		if (skipRules) {
+			if (!result.created) await moveCardToBoard({
+				workItems: this.#storage,
+				boardRegistry: this.#boards,
+				userId: "factory-rule-dispatcher",
+				item: result.item,
+				targetBoard: decision.board,
+				targetStage: decision.stage
+			});
+			return;
+		}
+		const materializedByDecision = result.item.metadata?.[FACTORY_RULE_MATERIALIZATION_KEY] === record.idempotencyKey;
+		if (!materializedByDecision && (decision.stage === initialPhase || !result.item.stages.includes(initialPhase))) return;
+		const board = decision.board;
+		let expectedRevision = result.item.revision;
+		if (materializedByDecision) {
+			const initial = await this.#transitionService.transition({
+				orgId: record.orgId,
+				factoryProjectId: record.factoryProjectId,
+				workItemId: result.item.id,
+				board,
+				stage: initialPhase,
+				expectedRevision,
+				actor: deferredActor(record),
+				ingress: {
+					type: "rule",
+					identity: `decision:${record.idempotencyKey}:${result.item.id}:initial-entry`
+				},
+				cause: "linked_item_materialized",
+				causalChain,
+				initialEntry: true
+			});
+			if (initial.status === "rejected") {
+				if (result.created) await this.#storage.delete({
+					orgId: record.orgId,
+					id: result.item.id,
+					purgeRuleState: false
+				});
+				throw new Error(`${initial.code}: ${initial.reason}`);
+			}
+			expectedRevision = initial.revision;
+		}
+		if (decision.stage === initialPhase) return;
+		const moved = await this.#transitionService.transition({
+			orgId: record.orgId,
+			factoryProjectId: record.factoryProjectId,
+			workItemId: result.item.id,
+			board,
+			stage: decision.stage,
+			expectedRevision,
+			actor: {
+				type: "system",
+				id: "factory-rule-dispatcher"
+			},
+			ingress: {
+				type: "rule",
+				identity: `decision:${record.idempotencyKey}:${result.item.id}:destination`
+			},
+			cause: materializedByDecision ? "linked_item_materialized" : "linked_item_reconciled",
+			causalChain
+		});
+		if (moved.status === "rejected") throw new Error(`${moved.code}: ${moved.reason}`);
+	}
+	async #requireItem(record) {
+		if (!record.workItemId) throw new Error("Factory decision is not linked to a work item.");
+		const item = await this.#storage.get({
+			orgId: record.orgId,
+			id: record.workItemId
+		});
+		if (!item) throw new Error("Factory work item not found.");
+		return item;
+	}
+	async #findBinding(record, role) {
+		if (!record.workItemId) throw new Error("Factory decision is not linked to a work item.");
+		return (await this.#storage.listRunBindings(record.orgId, record.factoryProjectId, record.workItemId)).filter((candidate) => candidate.status === "active" && (role === void 0 || candidate.role === role)).sort((left, right) => {
+			if (role === void 0 && left.role === "work" && right.role !== "work") return -1;
+			if (role === void 0 && right.role === "work" && left.role !== "work") return 1;
+			return right.createdAt.getTime() - left.createdAt.getTime() || left.id.localeCompare(right.id);
+		})[0];
+	}
+	async #requireBinding(record, role) {
+		const binding = await this.#findBinding(record, role);
+		if (!binding) throw new FactoryDispatchError("session_unavailable", role ? `No active Factory binding for role ${role}.` : "No active Factory binding.");
+		return binding;
+	}
+	async #messageBinding(record, decision) {
+		if (decision.prepareBinding && decision.role !== void 0) return this.#requireOrPrepareBinding(record, decision.role);
+		return this.#findBinding(record, decision.role);
+	}
+	/**
+	* A role is superseded when its binding was revoked by a later role taking
+	* the same session (`prepareRunBinding` revokes every other active binding on
+	* that session). Only a hand-on — the running agent or a person moving the
+	* card — produces that shape, so the role's job is done: its decision is not
+	* owed a retry, and whatever ends the shared turn afterwards belongs to the
+	* successor's decision. A revoke with no successor (terminal cleanup, an
+	* operator pulling the seat) is not supersession and still fails as before.
+	* Only a hand-on that happened after this decision was queued counts: a
+	* fresh decision for the role (the card came back to it) must still dispatch
+	* even though an older revoked binding for that role is on record.
+	*/
+	async #decisionOvertaken(record, role) {
+		if (!record.workItemId) return false;
+		const [item, siblings] = await Promise.all([this.#storage.get({
+			orgId: record.orgId,
+			id: record.workItemId
+		}), this.#storage.listDecisionsForEvaluations(record.orgId, record.factoryProjectId, [record.evaluationId])]);
+		return decisionOvertaken({
+			boards: this.#boards,
+			item,
+			record,
+			role,
+			siblings
+		});
+	}
+	async #roleSuperseded(record, role) {
+		if (!record.workItemId) return false;
+		const bindings = await this.#storage.listRunBindings(record.orgId, record.factoryProjectId, record.workItemId);
+		const own = bindings.filter((candidate) => candidate.role === role);
+		if (own.some((candidate) => candidate.status === "active")) return false;
+		const item = await this.#storage.get({
+			orgId: record.orgId,
+			id: record.workItemId
+		}).catch(() => null);
+		if (item && workItemPhaseSemantics(this.#boards, item)?.kind === "terminal") return true;
+		return own.some((revoked) => revoked.revokedAt !== null && revoked.revokedAt.getTime() >= record.createdAt.getTime() && bindings.some((successor) => successor.role !== role && successor.status === "active" && successor.resourceId === revoked.resourceId && successor.sessionId === revoked.sessionId && successor.threadId === revoked.threadId && successor.createdAt.getTime() >= revoked.revokedAt.getTime()));
+	}
+	async #requireOrPrepareBinding(record, role) {
+		const binding = await this.#findBinding(record, role);
+		if (binding) {
+			if (await this.#controller.getSessionByResource(binding.resourceId)) return binding;
+		}
+		if (!this.#prepareBinding) throw new FactoryDispatchError("session_unavailable", binding ? "Bound Factory session not found." : `No active Factory binding for role ${role}.`);
+		const item = await this.#requireItem(record);
+		await this.#prepareBinding({
+			record,
+			item,
+			role
+		});
+		return this.#requireBinding(record, role);
+	}
+	async #findSession(binding) {
+		const session = await this.#controller.getSessionByResource(binding.resourceId);
+		if (!session) return void 0;
+		await this.#switchThread(session, binding);
+		return session;
+	}
+	/** Unset means off: a plan nobody asked us to answer is a plan someone should see. */
+	async #plansAreAutoApproved({ orgId, factoryProjectId }) {
+		return this.#autoApprovePlans ? await this.#autoApprovePlans({
+			orgId,
+			factoryProjectId
+		}) : false;
+	}
+	async #requireSession(binding) {
+		const session = await this.#findSession(binding);
+		if (!session) throw new FactoryDispatchError("session_unavailable", "Bound Factory session not found.");
+		return session;
+	}
+	async #switchThread(session, binding) {
+		if (session.thread.requireId() === binding.threadId) return;
+		await session.thread.switch({ threadId: binding.threadId });
+	}
+	async #withBindingSkillRun(bindingId, effect) {
+		const run = (this.#bindingSkillRuns.get(bindingId) ?? Promise.resolve()).catch(() => {}).then(effect);
+		this.#bindingSkillRuns.set(bindingId, run);
+		try {
+			await run;
+		} finally {
+			if (this.#bindingSkillRuns.get(bindingId) === run) this.#bindingSkillRuns.delete(bindingId);
+		}
+	}
+	async #withLease(renew, effect) {
+		let renewalFailure;
+		let renewal = Promise.resolve();
+		const timer = setInterval(() => {
+			renewal = renewal.then(async () => {
+				try {
+					if (!await renew(new Date(Date.now() + LEASE_MS))) renewalFailure = /* @__PURE__ */ new Error("Factory dispatch lease was lost during execution.");
+				} catch (error) {
+					renewalFailure = error;
+				}
+			});
+		}, Math.floor(LEASE_MS / 3));
+		timer.unref?.();
+		try {
+			await effect();
+			await renewal;
+			if (renewalFailure) throw renewalFailure;
+		} finally {
+			clearInterval(timer);
+			await renewal;
+		}
+	}
+	/** Keep this process's claim on an open run fresh for as long as it is watching the run. */
+	async #withOpenRunHeartbeat(session, kickoffId, effect) {
+		if (!this.#audit) return effect();
+		const timer = setInterval(() => void heartbeatSessionOpenRun(session, kickoffId), Math.floor(FACTORY_OPEN_RUN_STALE_MS / 3));
+		timer.unref?.();
+		try {
+			return await effect();
+		} finally {
+			clearInterval(timer);
+		}
+	}
+	async #recordRunStart(session, binding, kickoffId, approvedBy, observedEnd, workItemName) {
+		if (!this.#audit) return;
+		const humanApproved = isHumanActorId(approvedBy);
+		await recordSessionRunStart(session, {
+			audit: this.#audit,
+			actorType: humanApproved ? "human" : "system",
+			observedEnd,
+			run: {
+				kickoffId,
+				ownerId: this.#ownerId,
+				heartbeatAt: Date.now(),
+				bindingId: binding.id,
+				role: binding.role,
+				startedBy: humanApproved ? approvedBy : "factory-rule-dispatcher",
+				orgId: binding.orgId,
+				factoryProjectId: binding.factoryProjectId,
+				workItemId: binding.workItemId,
+				workItemName,
+				sessionId: binding.sessionId,
+				threadId: binding.threadId,
+				branch: binding.branch
+			}
+		});
+	}
+	async #dispatchPendingStart(record, now) {
+		try {
+			await this.#withLease(async (leaseExpiresAt) => this.#storage.renewPendingStartLease(leaseIdentity(record, this.#ownerId), leaseExpiresAt), async () => {
+				if (record.message === null) return;
+				const binding = (await this.#storage.listRunBindings(record.orgId, record.factoryProjectId)).find((candidate) => candidate.id === record.bindingId && candidate.status === "active");
+				if (!binding) throw new FactoryDispatchError("session_unavailable", "Prepared Factory binding is unavailable or revoked.");
+				const item = await this.#storage.get({
+					orgId: record.orgId,
+					id: binding.workItemId
+				});
+				const startedBy = item?.sessions[binding.role]?.startedBy;
+				if (!startedBy) throw new Error(`Factory binding ${binding.id} has no authenticated session owner.`);
+				await this.#primeCredentials?.({
+					orgId: record.orgId,
+					userId: startedBy
+				});
+				const session = await this.#requireSession(binding);
+				const requestContext = factoryRequestContext({
+					session,
+					binding,
+					userId: startedBy,
+					orgId: record.orgId
+				});
+				const run = watchRun(session, {
+					timeoutMs: this.#skillCompletionObservationTimeoutMs,
+					approvePlans: await this.#plansAreAutoApproved(record),
+					label: "Factory kickoff run",
+					runStillActive: () => this.#controller.listActiveThreadRuns().some((active) => active.threadId === binding.threadId)
+				});
+				const sendKickoff = (dedupeKey) => awaitNotification(() => session.sendNotificationSignal({
+					source: "factory",
+					kind: "run-kickoff",
+					summary: record.message,
+					priority: "high",
+					payload: { message: record.message },
+					sourceId: record.id,
+					dedupeKey
+				}, {
+					ifActive: { behavior: "deliver" },
+					ifIdle: { behavior: "wake" },
+					requestContext
+				}), true);
+				try {
+					let settled = await sendKickoff(`factory-kickoff:${record.kickoffKey}`);
+					let deliveryGeneration = 0;
+					while (settled?.action === "deliver") {
+						if (!await run.wait()) throw new Error("Factory kickoff is waiting on a run that has not ended.");
+						run.arm();
+						deliveryGeneration += 1;
+						settled = await sendKickoff(`factory-kickoff:${record.kickoffKey}:retry:${record.attempts}:${deliveryGeneration}`);
+					}
+					await this.#recordRunStart(session, binding, `factory-kickoff:${record.kickoffKey}:${record.attempts}`, startedBy, run.endReason, item?.title);
+					await run.settle();
+				} finally {
+					run.close();
+				}
+			});
+			if (!await this.#storage.completePendingStart(leaseIdentity(record, this.#ownerId), /* @__PURE__ */ new Date())) throw new Error("Factory kickoff lease was lost before completion.");
+		} catch (error) {
+			const failureCode = factoryDispatchFailureCode(error);
+			await this.#storage.failPendingStart({
+				...leaseIdentity(record, this.#ownerId),
+				now: /* @__PURE__ */ new Date(),
+				availableAt: retryAt(now, record.attempts),
+				lastError: sanitizeDispatchError(error),
+				failureCode,
+				terminal: isTerminalFailure(record.attempts, failureCode)
+			});
+		}
+	}
+};
+const FACTORY_DISPATCH_CONSTANTS = {
+	leaseMs: LEASE_MS,
+	pollMs: POLL_MS,
+	batchSize: BATCH_SIZE,
+	maxAttempts: MAX_ATTEMPTS,
+	maxErrorLength: MAX_ERROR_LENGTH,
+	maxBackoffMs: MAX_BACKOFF_MS,
+	skillCompletionObservationTimeoutMs: SKILL_COMPLETION_OBSERVATION_TIMEOUT_MS,
+	runRegistryHeartbeatMs: RUN_REGISTRY_HEARTBEAT_MS,
+	openRunStaleMs: FACTORY_OPEN_RUN_STALE_MS,
+	maxInFlight: MAX_IN_FLIGHT,
+	stages: FACTORY_RULE_STAGES
+};
+//#endregion
+export { FACTORY_DISPATCH_CONSTANTS, FactoryDecisionDispatcher };
+
+//# sourceMappingURL=dispatcher.js.map