@mastra/factory 0.9.0 → 0.10.0-alpha.10

package/dist/storage/domains/work-items/base.js

@@ -1,3 +1,4 @@
+import { isTerminalFactoryRuleStage } from "../../../rules/types.js";
 import { createHash } from "crypto";
 import { FactoryStorageDomain, UniqueViolationError } from "@mastra/core/storage";
 //#region src/storage/domains/work-items/base.ts
@@ -20,6 +21,7 @@ function factoryDecisionHash(decision) {
 }
 /** Dispatcher upsert idempotency token — server bookkeeping, dropped from the read wire. */
 const FACTORY_RULE_MATERIALIZATION_KEY = "factoryRuleMaterializationKey";
+const FACTORY_PULL_REQUEST_RECONCILIATION_KEY = "factoryPullRequestReconciliation";
 /**
 * Whether an actor id marks a move an agent run performed: the binding id the
 * transition tool stamps (`agent:*`), or the rule that fires off a bound run's
@@ -34,6 +36,35 @@ function isAgentActor(by) {
 	if (by === void 0) return false;
 	return by.startsWith("agent:") || by === "factory-tool-result-rule";
 }
+const FACTORY_DISPATCH_FAILURE_CODES = [
+	"session_unavailable",
+	"source_control_missing",
+	"source_repository_missing",
+	"unsupported_provider_item",
+	"notification_delivery_failed",
+	"repository_git_missing",
+	"repository_egress_blocked",
+	"repository_clone_failed",
+	"repository_pull_failed",
+	"repository_push_failed",
+	"repository_commit_failed",
+	"repository_cli_missing",
+	"repository_pr_failed",
+	"unknown"
+];
+function isFactoryDispatchFailureCode(value) {
+	return FACTORY_DISPATCH_FAILURE_CODES.some((code) => code === value);
+}
+function factoryDecisionAttentionIdentity(decisionId, failureOccurrence) {
+	return {
+		kind: "automation-failed",
+		sourceId: decisionId,
+		occurrence: failureOccurrence
+	};
+}
+function factoryAttentionKey(factoryProjectId, identity) {
+	return `factory:${factoryProjectId}:attention:${identity.kind}:${identity.sourceId}:${identity.occurrence}`;
+}
 /**
 * Stages in which a bound run can still act on its work item. Mirrors the
 * non-terminal subset of `FACTORY_RULE_STAGES` (rules/types.ts); bindings for
@@ -89,11 +120,12 @@ const WORK_ITEMS_SCHEMA = {
 		columns: ["factory_project_id", "source_key"]
 	}],
 	indexes: [{
-		name: "work_items_org_project_updated_at_idx",
+		name: "work_items_org_project_created_at_id_idx",
 		columns: [
 			"org_id",
 			"factory_project_id",
-			"updated_at"
+			"created_at",
+			"id"
 		]
 	}, {
 		name: "work_items_project_parent_idx",
@@ -223,6 +255,8 @@ function applyUpdate({ current, userId, input }) {
 		updated_at: now
 	};
 }
+const ATTENTION_RECEIPT_QUERY_BATCH_SIZE = 200;
+const ATTENTION_RECEIPT_WRITE_BATCH_SIZE = 25;
 const projectRelationLocks = /* @__PURE__ */ new Map();
 function withInProcessProjectLock(key, fn) {
 	const result = (projectRelationLocks.get(key) ?? Promise.resolve()).then(fn, fn);
@@ -240,6 +274,13 @@ function decisionSourceKey(decision) {
 	if (record.type !== "upsertLinkedWorkItem" || typeof record.sourceKey !== "string") return null;
 	return record.sourceKey;
 }
+function deferredDecisionType(decision) {
+	return typeof decision.decision.type === "string" ? decision.decision.type : void 0;
+}
+function ingressWasAccepted(row) {
+	if (!row || typeof row.result !== "object" || row.result === null || Array.isArray(row.result)) return false;
+	return "status" in row.result && row.result.status === "accepted";
+}
 const FACTORY_GOVERNANCE_SCHEMAS = [
 	{
 		name: "factory_rule_ingress",
@@ -315,6 +356,14 @@ const FACTORY_GOVERNANCE_SCHEMAS = [
 			decision: { type: "json" },
 			status: { type: "text" },
 			attempts: { type: "integer" },
+			delivery_generation: {
+				type: "integer",
+				default: 0
+			},
+			failure_occurrence: {
+				type: "integer",
+				default: 0
+			},
 			available_at: { type: "timestamp" },
 			lease_owner: {
 				type: "text",
@@ -328,10 +377,18 @@ const FACTORY_GOVERNANCE_SCHEMAS = [
 				type: "text",
 				nullable: true
 			},
+			failure_code: {
+				type: "text",
+				nullable: true
+			},
 			approved_at: {
 				type: "timestamp",
 				nullable: true
 			},
+			approved_by: {
+				type: "text",
+				nullable: true
+			},
 			completed_at: {
 				type: "timestamp",
 				nullable: true
@@ -347,9 +404,80 @@ const FACTORY_GOVERNANCE_SCHEMAS = [
 				"idempotency_key"
 			]
 		}],
+		indexes: [
+			{
+				name: "factory_deferred_decisions_claim_idx",
+				columns: ["status", "created_at"]
+			},
+			{
+				name: "factory_deferred_decisions_tenant_status_created_idx",
+				columns: [
+					"org_id",
+					"factory_project_id",
+					"status",
+					"created_at",
+					"id"
+				]
+			},
+			{
+				name: "factory_deferred_decisions_tenant_status_failed_idx",
+				columns: [
+					"org_id",
+					"factory_project_id",
+					"status",
+					"updated_at",
+					"id"
+				]
+			}
+		]
+	},
+	{
+		name: "factory_attention_receipts",
+		columns: {
+			id: { type: "uuid-pk" },
+			org_id: { type: "text" },
+			factory_project_id: { type: "text" },
+			user_id: { type: "text" },
+			kind: { type: "text" },
+			source_id: { type: "text" },
+			occurrence: { type: "integer" },
+			state: { type: "text" },
+			read_at: { type: "timestamp" },
+			archived_at: {
+				type: "timestamp",
+				nullable: true
+			},
+			created_at: { type: "timestamp" },
+			updated_at: { type: "timestamp" }
+		},
+		uniqueIndexes: [{
+			name: "factory_attention_receipts_user_source_unique",
+			columns: [
+				"org_id",
+				"factory_project_id",
+				"user_id",
+				"kind",
+				"source_id",
+				"occurrence"
+			]
+		}],
 		indexes: [{
-			name: "factory_deferred_decisions_claim_idx",
-			columns: ["status", "created_at"]
+			name: "factory_attention_receipts_user_state_idx",
+			columns: [
+				"org_id",
+				"factory_project_id",
+				"user_id",
+				"state"
+			]
+		}, {
+			name: "factory_attention_receipts_source_idx",
+			columns: [
+				"org_id",
+				"factory_project_id",
+				"kind",
+				"source_id",
+				"occurrence"
+			]
 		}]
 	},
 	{
@@ -477,16 +605,52 @@ function toDeferredDecision(row) {
 		decision: row.decision,
 		status: row.status,
 		attempts: Number(row.attempts),
+		deliveryGeneration: Number(row.delivery_generation ?? 0),
+		failureOccurrence: Number(row.failure_occurrence ?? 0),
 		availableAt: row.available_at,
 		leaseOwner: row.lease_owner ?? null,
 		leaseExpiresAt: row.lease_expires_at ?? null,
 		lastError: row.last_error ?? null,
+		failureCode: isFactoryDispatchFailureCode(row.failure_code) ? row.failure_code : null,
 		approvedAt: row.approved_at ?? null,
+		approvedBy: row.approved_by ?? null,
 		completedAt: row.completed_at ?? null,
 		createdAt: row.created_at,
 		updatedAt: row.updated_at
 	};
 }
+function attentionReceiptKind(value) {
+	if (value === "automation-failed") return value;
+	throw new Error(`Unsupported attention receipt kind '${String(value)}'.`);
+}
+function attentionReceiptState(value) {
+	if (value === "read" || value === "archived") return value;
+	throw new Error(`Unsupported attention receipt state '${String(value)}'.`);
+}
+function toAttentionReceipt(row) {
+	if (typeof row.source_id !== "string" || !row.source_id) throw new Error("Attention receipt source_id must be a non-empty string.");
+	const occurrence = Number(row.occurrence);
+	if (!Number.isSafeInteger(occurrence) || occurrence < 0) throw new Error("Attention receipt occurrence must be a non-negative safe integer.");
+	if (!(row.read_at instanceof Date)) throw new Error("Attention receipt read_at must be a timestamp.");
+	const archivedAt = row.archived_at;
+	if (archivedAt !== null && archivedAt !== void 0 && !(archivedAt instanceof Date)) throw new Error("Attention receipt archived_at must be a timestamp or null.");
+	if (!(row.created_at instanceof Date)) throw new Error("Attention receipt created_at must be a timestamp.");
+	if (!(row.updated_at instanceof Date)) throw new Error("Attention receipt updated_at must be a timestamp.");
+	return {
+		id: row.id,
+		orgId: row.org_id,
+		factoryProjectId: String(row.factory_project_id),
+		userId: String(row.user_id),
+		kind: attentionReceiptKind(row.kind),
+		sourceId: row.source_id,
+		occurrence,
+		state: attentionReceiptState(row.state),
+		readAt: row.read_at,
+		archivedAt: archivedAt ?? null,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
 function toPendingStart(row) {
 	return {
 		id: row.id,
@@ -512,6 +676,7 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 	}
 	async init() {
 		await this.ensureCollections([WORK_ITEMS_SCHEMA, ...FACTORY_GOVERNANCE_SCHEMAS]);
+		await this.repairLegacyAttentionState();
 	}
 	async dangerouslyClearAll() {
 		await this.ops.deleteMany("work_items", {});
@@ -519,6 +684,11 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 	get #db() {
 		return this.ops;
 	}
+	async #countRows(collection, where) {
+		const count = this.#db.count;
+		if (!count) throw new Error("[WorkItemsStorage] storage backend does not support collection counts.");
+		return count.call(this.#db, collection, where);
+	}
 	async #withProjectRelationTransaction(orgId, factoryProjectId, fn) {
 		return withInProcessProjectLock(`work-items:${orgId}:${factoryProjectId}`, () => this.storage.withTransaction(fn, { isolationLevel: "serializable" }));
 	}
@@ -608,11 +778,14 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 			failed = true;
 			return {
 				status: input.terminal ? "failed" : "retry",
+				...table === "factory_deferred_decisions" && !input.terminal && input.advanceDeliveryGeneration !== false ? { delivery_generation: Number(current.delivery_generation ?? 0) + 1 } : {},
 				available_at: input.availableAt,
 				lease_owner: null,
 				lease_expires_at: null,
 				last_error: input.lastError,
+				...table === "factory_deferred_decisions" ? { failure_code: input.failureCode } : {},
 				completed_at: input.terminal ? input.now : null,
+				...table === "factory_deferred_decisions" && input.terminal ? { failure_occurrence: Number(current.failure_occurrence ?? 0) + 1 } : {},
 				updated_at: input.now
 			};
 		});
@@ -622,12 +795,24 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 		return (await ops.findMany("work_items", {
 			org_id: orgId,
 			factory_project_id: factoryProjectId
-		}, { orderBy: [["updated_at", "desc"]] })).map(toWorkItem);
+		}, { orderBy: [["created_at", "desc"], ["id", "desc"]] })).map(toWorkItem);
 	}
-	/** List the org's work items for a project, newest first. */
+	/**
+	* List the org's work items for a project, newest first. Ordered on `created_at` with an id
+	* tiebreak so the order is stable: `updated_at` moves under every write, which makes it useless
+	* as a cursor and non-deterministic for the callers that iterate this list.
+	*/
 	async list({ orgId, factoryProjectId }) {
 		return this.#listWithOps(this.#db, orgId, factoryProjectId);
 	}
+	async listByIds({ orgId, factoryProjectId, ids }) {
+		if (ids.length === 0) return [];
+		return (await this.#db.findMany("work_items", {
+			org_id: orgId,
+			factory_project_id: factoryProjectId,
+			id: { in: [...new Set(ids)] }
+		})).map(toWorkItem);
+	}
 	async get({ orgId, id }) {
 		const row = await this.#db.findOne("work_items", {
 			org_id: orgId,
@@ -749,6 +934,7 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 					decision,
 					status: "pending",
 					attempts: 0,
+					delivery_generation: 0,
 					available_at: now,
 					lease_owner: null,
 					lease_expires_at: null,
@@ -865,6 +1051,7 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 				decision,
 				status: "pending",
 				attempts: 0,
+				delivery_generation: 0,
 				available_at: input.now,
 				lease_owner: null,
 				lease_expires_at: null,
@@ -934,6 +1121,143 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 			hasMore: rows.length > input.limit
 		};
 	}
+	async listFailedDecisionPage(input) {
+		const rows = await this.#db.findMany("factory_deferred_decisions", {
+			org_id: input.orgId,
+			factory_project_id: input.factoryProjectId,
+			status: "failed"
+		}, {
+			orderBy: [["updated_at", "desc"], ["id", "desc"]],
+			limit: input.limit + 1,
+			...input.before ? { cursor: { values: [input.before.occurredAt, input.before.id] } } : {}
+		});
+		return {
+			decisions: rows.slice(0, input.limit).map(toDeferredDecision),
+			hasMore: rows.length > input.limit
+		};
+	}
+	async countDeferredDecisionsByStatuses({ orgId, factoryProjectId, statuses }) {
+		return this.#countRows("factory_deferred_decisions", {
+			org_id: orgId,
+			factory_project_id: factoryProjectId,
+			status: { in: statuses }
+		});
+	}
+	async getDeferredDecision(orgId, factoryProjectId, decisionId) {
+		const row = await this.#db.findOne("factory_deferred_decisions", {
+			id: decisionId,
+			org_id: orgId,
+			factory_project_id: factoryProjectId
+		});
+		return row ? toDeferredDecision(row) : null;
+	}
+	async listAttentionReceipts({ orgId, factoryProjectId, userId, identities }) {
+		if (identities.length === 0) return [];
+		const requested = new Set(identities.map((identity) => `${identity.kind}\0${identity.sourceId}\0${identity.occurrence}`));
+		const sourceIds = [...new Set(identities.map((identity) => identity.sourceId))];
+		const kinds = [...new Set(identities.map((identity) => identity.kind))];
+		const receipts = [];
+		for (let index = 0; index < sourceIds.length; index += ATTENTION_RECEIPT_QUERY_BATCH_SIZE) {
+			const rows = await this.#db.findMany("factory_attention_receipts", {
+				org_id: orgId,
+				factory_project_id: factoryProjectId,
+				user_id: userId,
+				kind: { in: kinds },
+				source_id: { in: sourceIds.slice(index, index + ATTENTION_RECEIPT_QUERY_BATCH_SIZE) }
+			});
+			receipts.push(...rows.map(toAttentionReceipt).filter((receipt) => requested.has(`${receipt.kind}\0${receipt.sourceId}\0${receipt.occurrence}`)));
+		}
+		return receipts;
+	}
+	async countAttentionReceipts({ orgId, factoryProjectId, userId, state }) {
+		return this.#countRows("factory_attention_receipts", {
+			org_id: orgId,
+			factory_project_id: factoryProjectId,
+			user_id: userId,
+			kind: "automation-failed",
+			...state ? { state } : {}
+		});
+	}
+	async deleteAttentionReceipts({ orgId, factoryProjectId, identities }) {
+		const unique = [...new Map(identities.map((identity) => [`${identity.kind}\0${identity.sourceId}\0${identity.occurrence}`, identity])).values()];
+		for (let index = 0; index < unique.length; index += ATTENTION_RECEIPT_WRITE_BATCH_SIZE) await Promise.all(unique.slice(index, index + ATTENTION_RECEIPT_WRITE_BATCH_SIZE).map((identity) => this.#db.deleteMany("factory_attention_receipts", {
+			org_id: orgId,
+			factory_project_id: factoryProjectId,
+			kind: identity.kind,
+			source_id: identity.sourceId,
+			occurrence: identity.occurrence
+		})));
+	}
+	async setAttentionReceipt(input) {
+		return this.#retryAttentionReceiptWrite(() => this.storage.withTransaction((ops) => this.#setAttentionReceiptWithOps(ops, input)));
+	}
+	async #retryAttentionReceiptWrite(write) {
+		try {
+			return await write();
+		} catch (error) {
+			if (!(error instanceof UniqueViolationError)) throw error;
+			return write();
+		}
+	}
+	async #setAttentionReceiptWithOps(ops, { orgId, factoryProjectId, userId, decisionId, failureOccurrence, action, now }) {
+		const identity = factoryDecisionAttentionIdentity(decisionId, failureOccurrence);
+		let currentOccurrence = false;
+		if (!await ops.updateAtomic("factory_deferred_decisions", {
+			id: decisionId,
+			org_id: orgId,
+			factory_project_id: factoryProjectId
+		}, (current) => {
+			currentOccurrence = current.status === "failed" && Number(current.failure_occurrence ?? 0) === failureOccurrence;
+			return null;
+		}) || !currentOccurrence) return null;
+		const where = {
+			org_id: orgId,
+			factory_project_id: factoryProjectId,
+			user_id: userId,
+			kind: identity.kind,
+			source_id: identity.sourceId,
+			occurrence: identity.occurrence
+		};
+		const existing = await ops.findOne("factory_attention_receipts", where);
+		if (!existing) return toAttentionReceipt(await ops.insertOne("factory_attention_receipts", {
+			...where,
+			state: action === "archive" ? "archived" : "read",
+			read_at: now,
+			archived_at: action === "archive" ? now : null,
+			created_at: now,
+			updated_at: now
+		}));
+		const row = await ops.updateAtomic("factory_attention_receipts", {
+			id: existing.id,
+			...where
+		}, (current) => {
+			const preserveArchive = action === "read" && current.state === "archived";
+			const archived = action === "archive" || preserveArchive;
+			return {
+				state: archived ? "archived" : "read",
+				read_at: current.read_at,
+				archived_at: action === "archive" ? now : archived ? current.archived_at ?? now : null,
+				updated_at: now
+			};
+		});
+		return row ? toAttentionReceipt(row) : null;
+	}
+	async markAttentionReceiptsRead({ orgId, factoryProjectId, userId, occurrences, now }) {
+		const uniqueOccurrences = [...new Map(occurrences.map((occurrence) => [`${occurrence.decisionId}:${occurrence.failureOccurrence}`, occurrence])).values()];
+		for (let index = 0; index < uniqueOccurrences.length; index += ATTENTION_RECEIPT_WRITE_BATCH_SIZE) {
+			const batch = uniqueOccurrences.slice(index, index + ATTENTION_RECEIPT_WRITE_BATCH_SIZE);
+			await this.#retryAttentionReceiptWrite(() => this.storage.withTransaction(async (ops) => {
+				for (const occurrence of batch) await this.#setAttentionReceiptWithOps(ops, {
+					orgId,
+					factoryProjectId,
+					userId,
+					...occurrence,
+					action: "read",
+					now
+				});
+			}));
+		}
+	}
 	async claimDeferredDecisions(input) {
 		return this.#claimLeases("factory_deferred_decisions", input, toDeferredDecision);
 	}
@@ -974,7 +1298,7 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 	* is armed in the same transaction — a crash cannot release the run while
 	* leaving its follow-up work parked for re-approval.
 	*/
-	async approveDeferredDecision(orgId, factoryProjectId, decisionId, now) {
+	async approveDeferredDecision(orgId, factoryProjectId, decisionId, now, approvedBy) {
 		return this.storage.withTransaction(async (ops) => {
 			let settled = false;
 			const row = await ops.updateAtomic("factory_deferred_decisions", {
@@ -989,6 +1313,7 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 					attempts: 0,
 					available_at: now,
 					approved_at: now,
+					approved_by: approvedBy ?? null,
 					updated_at: now
 				};
 			});
@@ -1014,27 +1339,38 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 		});
 	}
 	/**
-	* Retire proposals parked on a work item. A merged pull request (or an item
-	* closed out any other way) leaves its queued runs with nothing left to do,
-	* and they would otherwise sit on the card forever asking to be answered.
-	*
-	* Pass `role` to retire only the proposals a run now starting has overtaken:
-	* a parked "start triage" is moot the moment triage is actually running.
+	* Automatically retire proposed or failed work that a newer run or terminal
+	* work-item state has overtaken. Human dismissal remains `dismissed`.
 	*/
-	async dismissProposalsForWorkItem(input) {
+	async supersedeDecisionsForWorkItem(input) {
 		const rows = await this.#db.findMany("factory_deferred_decisions", {
 			org_id: input.orgId,
 			factory_project_id: input.factoryProjectId,
 			work_item_id: input.workItemId,
-			status: "proposed"
+			status: { in: ["proposed", "failed"] }
 		});
-		const dismissed = [];
+		const superseded = [];
 		for (const row of rows) {
-			if (input.role !== void 0 && toDeferredDecision(row).decision.role !== input.role) continue;
-			const record = await this.dismissDeferredDecision(input.orgId, input.factoryProjectId, row.id, input.dismissedAt);
-			if (record) dismissed.push(record);
+			const decision = toDeferredDecision(row);
+			if (input.role !== void 0 && decision.decision.role !== input.role) continue;
+			const record = decision.status === "proposed" ? await this.#settleProposedDecision({
+				orgId: input.orgId,
+				factoryProjectId: input.factoryProjectId,
+				decisionId: decision.id
+			}, {
+				status: "superseded",
+				updated_at: input.supersededAt,
+				completed_at: input.supersededAt
+			}) : await this.#resolveFailedDecision({
+				orgId: input.orgId,
+				factoryProjectId: input.factoryProjectId,
+				decisionId: decision.id,
+				status: "superseded",
+				now: input.supersededAt
+			});
+			if (record) superseded.push(record);
 		}
-		return dismissed;
+		return superseded;
 	}
 	async #settleProposedDecision({ orgId, factoryProjectId, decisionId }, patch) {
 		let settled = false;
@@ -1049,28 +1385,119 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 		});
 		return settled && row ? toDeferredDecision(row) : null;
 	}
+	async #resolveFailedDecision({ orgId, factoryProjectId, decisionId, status, now }) {
+		return this.storage.withTransaction(async (ops) => {
+			let resolved = false;
+			const row = await ops.updateAtomic("factory_deferred_decisions", {
+				id: decisionId,
+				org_id: orgId,
+				factory_project_id: factoryProjectId
+			}, (current) => {
+				if (current.status !== "failed") return null;
+				resolved = true;
+				return {
+					status,
+					updated_at: now
+				};
+			});
+			if (!resolved || !row) return null;
+			await ops.deleteMany("factory_attention_receipts", {
+				org_id: orgId,
+				factory_project_id: factoryProjectId,
+				kind: "automation-failed",
+				source_id: decisionId,
+				occurrence: Number(row.failure_occurrence ?? 0)
+			});
+			return toDeferredDecision(row);
+		});
+	}
+	async supersedeTerminalDecisionsForWorkItem(input) {
+		await this.supersedeDecisionsForWorkItem(input);
+	}
+	async repairLegacyAttentionState() {
+		let cursor;
+		const inspectedWorkItems = /* @__PURE__ */ new Set();
+		while (true) {
+			const rows = await this.#db.findMany("factory_deferred_decisions", { status: { in: ["failed", "proposed"] } }, {
+				orderBy: [["created_at", "asc"], ["id", "asc"]],
+				limit: 201,
+				...cursor ? { cursor } : {}
+			});
+			const page = rows.slice(0, ATTENTION_RECEIPT_QUERY_BATCH_SIZE);
+			for (const row of page) {
+				const decision = toDeferredDecision(row);
+				if (decision.status === "failed" && decision.failureOccurrence === 0 && deferredDecisionType(decision) === "transition") {
+					if (ingressWasAccepted(await this.#db.findOne("factory_rule_ingress", {
+						org_id: decision.orgId,
+						factory_project_id: decision.factoryProjectId,
+						identity: `decision:${decision.idempotencyKey}`
+					}))) {
+						await this.#resolveFailedDecision({
+							orgId: decision.orgId,
+							factoryProjectId: decision.factoryProjectId,
+							decisionId: decision.id,
+							status: "succeeded",
+							now: /* @__PURE__ */ new Date()
+						});
+						continue;
+					}
+				}
+				if (!decision.workItemId) continue;
+				const itemKey = `${decision.orgId}\0${decision.factoryProjectId}\0${decision.workItemId}`;
+				if (inspectedWorkItems.has(itemKey)) continue;
+				inspectedWorkItems.add(itemKey);
+				const item = await this.get({
+					orgId: decision.orgId,
+					id: decision.workItemId
+				});
+				if (!item || !isTerminalFactoryRuleStage(item.stages)) continue;
+				await this.supersedeDecisionsForWorkItem({
+					orgId: decision.orgId,
+					factoryProjectId: decision.factoryProjectId,
+					workItemId: decision.workItemId,
+					supersededAt: /* @__PURE__ */ new Date()
+				});
+			}
+			const last = page.at(-1);
+			if (rows.length <= ATTENTION_RECEIPT_QUERY_BATCH_SIZE || !last) return;
+			if (!(last.created_at instanceof Date)) throw new Error("Deferred decision created_at is not a timestamp.");
+			cursor = { values: [last.created_at, last.id] };
+		}
+	}
 	/** Requeue the same idempotent terminal effect; non-failed decisions are never rerun. */
 	async retryDeferredDecision(orgId, factoryProjectId, decisionId, now) {
-		let retried = false;
-		const row = await this.#db.updateAtomic("factory_deferred_decisions", {
-			id: decisionId,
-			org_id: orgId,
-			factory_project_id: factoryProjectId
-		}, (current) => {
-			if (current.status !== "failed") return null;
-			retried = true;
-			return {
-				status: "retry",
-				attempts: 0,
-				available_at: now,
-				lease_owner: null,
-				lease_expires_at: null,
-				last_error: null,
-				completed_at: null,
-				updated_at: now
-			};
+		return this.storage.withTransaction(async (ops) => {
+			let retried = false;
+			const row = await ops.updateAtomic("factory_deferred_decisions", {
+				id: decisionId,
+				org_id: orgId,
+				factory_project_id: factoryProjectId
+			}, (current) => {
+				if (current.status !== "failed") return null;
+				retried = true;
+				return {
+					status: "retry",
+					attempts: 0,
+					delivery_generation: Number(current.delivery_generation ?? 0) + 1,
+					available_at: now,
+					lease_owner: null,
+					lease_expires_at: null,
+					last_error: null,
+					failure_code: null,
+					completed_at: null,
+					updated_at: now
+				};
+			});
+			if (!retried || !row) return null;
+			await ops.deleteMany("factory_attention_receipts", {
+				org_id: orgId,
+				factory_project_id: factoryProjectId,
+				kind: "automation-failed",
+				source_id: decisionId,
+				occurrence: Number(row.failure_occurrence ?? 0)
+			});
+			return toDeferredDecision(row);
 		});
-		return retried && row ? toDeferredDecision(row) : null;
 	}
 	/** Resolve exact active agent authority; partial session matches never authorize. */
 	async findActiveRunBinding(address) {
@@ -1256,12 +1683,10 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 			let item;
 			if (row) {
 				row = await ops.updateAtomic("work_items", { id: row.id }, (current) => {
-					const roles = /* @__PURE__ */ new Set([...Object.keys(current.sessions), input.role]);
-					const sessions = Object.fromEntries([...roles].map((role) => [role, input.session]));
 					return applyUpdate({
 						current,
 						userId: input.userId,
-						input: { sessions }
+						input: { sessions: { [input.role]: input.session } }
 					});
 				});
 				item = toRow(row);
@@ -1461,6 +1886,28 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 			previous: emptyPrior()
 		};
 	}
+	async setParentWorkItemIfMissing({ orgId, id, userId, parentWorkItemId }) {
+		const candidate = await this.#db.findOne("work_items", {
+			org_id: orgId,
+			id
+		});
+		if (!candidate) return null;
+		return this.#withProjectRelationTransaction(orgId, candidate.factory_project_id, async (ops) => {
+			const row = await ops.updateAtomic("work_items", {
+				org_id: orgId,
+				id
+			}, async (current) => {
+				if (current.parent_work_item_id !== null) return current;
+				validateParentRelation(await this.#listWithOps(ops, orgId, current.factory_project_id), current.id, parentWorkItemId);
+				return applyUpdate({
+					current,
+					userId,
+					input: { parentWorkItemId }
+				});
+			});
+			return row ? toWorkItem(row) : null;
+		});
+	}
 	async update({ orgId, id, userId, patch }) {
 		const run = async (ops) => {
 			let previous = emptyPrior();
@@ -1518,6 +1965,13 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 			const evaluation = await ops.findOne("factory_rule_evaluations", { id: evaluationId });
 			if (evaluation) ingressIds.add(String(evaluation.ingress_id));
 		}
+		const decisionIds = decisions.map((decision) => decision.id);
+		for (let index = 0; index < decisionIds.length; index += ATTENTION_RECEIPT_QUERY_BATCH_SIZE) await ops.deleteMany("factory_attention_receipts", {
+			org_id: orgId,
+			factory_project_id: factoryProjectId,
+			kind: "automation-failed",
+			source_id: { in: decisionIds.slice(index, index + ATTENTION_RECEIPT_QUERY_BATCH_SIZE) }
+		});
 		await ops.deleteMany("factory_deferred_decisions", {
 			org_id: orgId,
 			factory_project_id: factoryProjectId,
@@ -1559,6 +2013,6 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 	}
 };
 //#endregion
-export { FACTORY_RULE_MATERIALIZATION_KEY, WORK_ITEMS_SCHEMA, WorkItemRelationError, WorkItemsStorage, applyStageTransition, factoryDecisionHash, isAgentActor, stampSessions, validateParentRelation };
+export { FACTORY_PULL_REQUEST_RECONCILIATION_KEY, FACTORY_RULE_MATERIALIZATION_KEY, WORK_ITEMS_SCHEMA, WorkItemRelationError, WorkItemsStorage, applyStageTransition, factoryAttentionKey, factoryDecisionAttentionIdentity, factoryDecisionHash, isAgentActor, stampSessions, validateParentRelation };
 
 //# sourceMappingURL=base.js.map