@mastra/factory 0.0.0-fix-thread-subscription-multi-instance-redis-streams-20260730204150

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

@@ -0,0 +1,1309 @@
+import { createHash } from "crypto";
+import { FactoryStorageDomain, UniqueViolationError } from "@mastra/core/storage";
+//#region src/storage/domains/work-items/base.ts
+/**
+* Factory work-items storage domain.
+*
+* Work items belong to a first-class Factory project. External intake items use
+* a provider-neutral source reference; manual work items have no source.
+* Stage history is server-owned, while session and metadata patches merge
+* atomically so concurrent actors do not overwrite each other. The authoritative
+* Factory transition path keeps one exclusive current stage per item.
+*/
+function stableJson(value) {
+	if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+	return JSON.stringify(value) ?? "null";
+}
+function factoryDecisionHash(decision) {
+	return createHash("sha256").update(stableJson(decision)).digest("hex");
+}
+/**
+* Sentinel actor ids that mark a stage transition as automation-driven (vs a
+* human's WorkOS user id): generic sentinels plus the system ids the Factory
+* rules engine stamps (see `actorId` in factory/rules/transition-service.ts).
+* Metrics treat any other actor — including a missing `exitedBy` on
+* pre-existing entries — as human.
+*/
+const AUTOMATION_ACTORS = /* @__PURE__ */ new Set([
+	"factory",
+	"system",
+	"automation",
+	"factory-rule-dispatcher",
+	"factory-tool-result-rule"
+]);
+/**
+* Whether an actor id marks a transition no human performed on the Factory
+* board: a sentinel automation id, an agent binding (`agent:*`), or an
+* external-webhook actor (`github:*` — a human may have acted on GitHub, but
+* the board move itself was automated).
+*/
+function isAutomationActor(by) {
+	if (by === void 0) return false;
+	return AUTOMATION_ACTORS.has(by) || by.startsWith("agent:") || by.startsWith("github:");
+}
+const WORK_ITEMS_SCHEMA = {
+	name: "work_items",
+	columns: {
+		id: { type: "uuid-pk" },
+		org_id: { type: "text" },
+		factory_project_id: { type: "text" },
+		external_source: {
+			type: "json",
+			nullable: true
+		},
+		source_key: {
+			type: "text",
+			nullable: true
+		},
+		parent_work_item_id: {
+			type: "text",
+			nullable: true
+		},
+		title: { type: "text" },
+		stages: { type: "json" },
+		stage_history: { type: "json" },
+		sessions: { type: "json" },
+		metadata: {
+			type: "json",
+			nullable: true
+		},
+		revision: {
+			type: "integer",
+			default: 1
+		},
+		created_by: { type: "text" },
+		created_at: { type: "timestamp" },
+		updated_at: { type: "timestamp" }
+	},
+	uniqueIndexes: [{
+		name: "work_items_project_source_key_unique",
+		columns: ["factory_project_id", "source_key"]
+	}],
+	indexes: [{
+		name: "work_items_org_project_updated_at_idx",
+		columns: [
+			"org_id",
+			"factory_project_id",
+			"updated_at"
+		]
+	}, {
+		name: "work_items_project_parent_idx",
+		columns: [
+			"org_id",
+			"factory_project_id",
+			"parent_work_item_id"
+		]
+	}]
+};
+function sourceKey(source) {
+	return source ? `${source.integrationId}:${source.type}:${source.externalId}` : null;
+}
+function toWorkItem(row) {
+	return {
+		id: row.id,
+		orgId: row.org_id,
+		factoryProjectId: String(row.factory_project_id),
+		externalSource: row.external_source,
+		parentWorkItemId: row.parent_work_item_id,
+		title: row.title,
+		stages: row.stages,
+		stageHistory: row.stage_history,
+		sessions: row.sessions,
+		metadata: row.metadata,
+		revision: row.revision,
+		createdBy: row.created_by,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+const toRow = toWorkItem;
+function patchColumns(changes) {
+	return {
+		...changes.parentWorkItemId !== void 0 ? { parent_work_item_id: changes.parentWorkItemId } : {},
+		...changes.title !== void 0 ? { title: changes.title } : {},
+		...changes.stages !== void 0 ? { stages: changes.stages } : {},
+		...changes.stageHistory !== void 0 ? { stage_history: changes.stageHistory } : {},
+		...changes.sessions !== void 0 ? { sessions: changes.sessions } : {},
+		...changes.metadata !== void 0 ? { metadata: changes.metadata } : {},
+		...changes.revision !== void 0 ? { revision: changes.revision } : {},
+		...changes.updatedAt !== void 0 ? { updated_at: changes.updatedAt } : {}
+	};
+}
+function emptyPrior() {
+	return {
+		stages: [],
+		sessionRoles: []
+	};
+}
+function priorState(row) {
+	return {
+		stages: row.stages,
+		sessionRoles: Object.keys(row.sessions)
+	};
+}
+var WorkItemRelationError = class extends Error {
+	code = "invalid_work_item_relation";
+};
+function validateParentRelation(projectItems, itemId, parentWorkItemId) {
+	if (parentWorkItemId === null) return;
+	const byId = new Map(projectItems.map((item) => [item.id, item]));
+	const parent = byId.get(parentWorkItemId);
+	if (!parent) throw new WorkItemRelationError("Related work item not found in this project.");
+	if (itemId === parentWorkItemId) throw new WorkItemRelationError("A work item cannot relate to itself.");
+	const visited = /* @__PURE__ */ new Set();
+	let cursor = parent;
+	while (cursor?.parentWorkItemId) {
+		if (cursor.parentWorkItemId === itemId) throw new WorkItemRelationError("This relationship would create a cycle.");
+		if (visited.has(cursor.id)) throw new WorkItemRelationError("The related work item chain contains a cycle.");
+		visited.add(cursor.id);
+		cursor = byId.get(cursor.parentWorkItemId);
+	}
+}
+/**
+* Diff `oldStages` → `newStages` and return the updated history: exited stages
+* get `exitedAt` + `exitedBy` stamped on their open entry, entered stages get
+* a new entry.
+*/
+function applyStageTransition(history, oldStages, newStages, by, now) {
+	const timestamp = now.toISOString();
+	const next = history.map((entry) => ({ ...entry }));
+	for (const stage of oldStages) {
+		if (newStages.includes(stage)) continue;
+		for (let i = next.length - 1; i >= 0; i--) {
+			const entry = next[i];
+			if (entry.stage === stage && entry.exitedAt === void 0) {
+				entry.exitedAt = timestamp;
+				entry.exitedBy = by;
+				break;
+			}
+		}
+	}
+	for (const stage of newStages) if (!oldStages.includes(stage)) next.push({
+		stage,
+		enteredAt: timestamp,
+		by
+	});
+	return next;
+}
+function stampSessions(sessions, by) {
+	return Object.fromEntries(Object.entries(sessions).map(([role, session]) => [role, {
+		...session,
+		startedBy: by
+	}]));
+}
+function applyUpdate({ current, userId, input }) {
+	const now = /* @__PURE__ */ new Date();
+	return {
+		...input.parentWorkItemId !== void 0 ? { parent_work_item_id: input.parentWorkItemId } : {},
+		...input.title !== void 0 ? { title: input.title } : {},
+		...input.stages !== void 0 ? {
+			stages: input.stages,
+			stage_history: applyStageTransition(current.stage_history, current.stages, input.stages, userId, now)
+		} : {},
+		...input.sessions !== void 0 ? { sessions: {
+			...current.sessions,
+			...stampSessions(input.sessions, userId)
+		} } : {},
+		...input.metadata !== void 0 ? { metadata: input.metadata === null ? null : {
+			...current.metadata ?? {},
+			...input.metadata
+		} } : {},
+		revision: current.revision + 1,
+		updated_at: now
+	};
+}
+const projectRelationLocks = /* @__PURE__ */ new Map();
+function withInProcessProjectLock(key, fn) {
+	const result = (projectRelationLocks.get(key) ?? Promise.resolve()).then(fn, fn);
+	const tail = result.then(() => void 0, () => void 0);
+	projectRelationLocks.set(key, tail);
+	tail.then(() => {
+		if (projectRelationLocks.get(key) === tail) projectRelationLocks.delete(key);
+	});
+	return result;
+}
+const FACTORY_GOVERNANCE_SCHEMAS = [
+	{
+		name: "factory_rule_ingress",
+		columns: {
+			id: { type: "uuid-pk" },
+			org_id: { type: "text" },
+			factory_project_id: { type: "text" },
+			identity: { type: "text" },
+			trigger_type: { type: "text" },
+			transition_id: { type: "text" },
+			result: { type: "json" },
+			created_at: { type: "timestamp" }
+		},
+		uniqueIndexes: [{
+			name: "factory_rule_ingress_tenant_identity_unique",
+			columns: [
+				"org_id",
+				"factory_project_id",
+				"identity"
+			]
+		}]
+	},
+	{
+		name: "factory_rule_evaluations",
+		columns: {
+			id: { type: "uuid-pk" },
+			ingress_id: { type: "text" },
+			work_item_id: {
+				type: "text",
+				nullable: true
+			},
+			rule_set_version: { type: "text" },
+			expected_revision: {
+				type: "integer",
+				nullable: true
+			},
+			outcome: { type: "text" },
+			code: {
+				type: "text",
+				nullable: true
+			},
+			reason: {
+				type: "text",
+				nullable: true
+			},
+			causal_chain: { type: "json" },
+			created_at: { type: "timestamp" }
+		}
+	},
+	{
+		name: "factory_deferred_decisions",
+		columns: {
+			id: { type: "uuid-pk" },
+			org_id: { type: "text" },
+			factory_project_id: { type: "text" },
+			evaluation_id: { type: "text" },
+			work_item_id: {
+				type: "text",
+				nullable: true
+			},
+			idempotency_key: { type: "text" },
+			effect_ordinal: { type: "integer" },
+			effect_hash: { type: "text" },
+			causal_chain: { type: "json" },
+			actor: {
+				type: "json",
+				nullable: true
+			},
+			decision: { type: "json" },
+			status: { type: "text" },
+			attempts: { type: "integer" },
+			available_at: { type: "timestamp" },
+			lease_owner: {
+				type: "text",
+				nullable: true
+			},
+			lease_expires_at: {
+				type: "timestamp",
+				nullable: true
+			},
+			last_error: {
+				type: "text",
+				nullable: true
+			},
+			completed_at: {
+				type: "timestamp",
+				nullable: true
+			},
+			created_at: { type: "timestamp" },
+			updated_at: { type: "timestamp" }
+		},
+		uniqueIndexes: [{
+			name: "factory_deferred_decisions_tenant_key_unique",
+			columns: [
+				"org_id",
+				"factory_project_id",
+				"idempotency_key"
+			]
+		}],
+		indexes: [{
+			name: "factory_deferred_decisions_claim_idx",
+			columns: ["status", "created_at"]
+		}]
+	},
+	{
+		name: "factory_run_bindings",
+		columns: {
+			id: { type: "uuid-pk" },
+			org_id: { type: "text" },
+			factory_project_id: { type: "text" },
+			work_item_id: { type: "text" },
+			role: { type: "text" },
+			thread_id: { type: "text" },
+			resource_id: { type: "text" },
+			session_id: { type: "text" },
+			branch: { type: "text" },
+			status: { type: "text" },
+			created_at: { type: "timestamp" },
+			revoked_at: {
+				type: "timestamp",
+				nullable: true
+			}
+		},
+		indexes: [{
+			name: "factory_run_bindings_session_idx",
+			columns: [
+				"factory_project_id",
+				"thread_id",
+				"resource_id",
+				"session_id"
+			]
+		}, {
+			name: "factory_run_bindings_status_idx",
+			columns: ["status"]
+		}]
+	},
+	{
+		name: "factory_tool_result_cursors",
+		columns: {
+			binding_id: {
+				type: "text",
+				primaryKey: true
+			},
+			org_id: { type: "text" },
+			factory_project_id: { type: "text" },
+			last_message_id: { type: "text" },
+			last_message_created_at: { type: "timestamp" },
+			updated_at: { type: "timestamp" }
+		}
+	},
+	{
+		name: "factory_pending_starts",
+		columns: {
+			id: { type: "uuid-pk" },
+			org_id: { type: "text" },
+			factory_project_id: { type: "text" },
+			binding_id: { type: "text" },
+			kickoff_key: { type: "text" },
+			message: {
+				type: "text",
+				nullable: true
+			},
+			status: { type: "text" },
+			attempts: { type: "integer" },
+			available_at: { type: "timestamp" },
+			lease_owner: {
+				type: "text",
+				nullable: true
+			},
+			lease_expires_at: {
+				type: "timestamp",
+				nullable: true
+			},
+			last_error: {
+				type: "text",
+				nullable: true
+			},
+			completed_at: {
+				type: "timestamp",
+				nullable: true
+			},
+			created_at: { type: "timestamp" },
+			updated_at: { type: "timestamp" }
+		},
+		uniqueIndexes: [{
+			name: "factory_pending_starts_tenant_kickoff_unique",
+			columns: [
+				"org_id",
+				"factory_project_id",
+				"kickoff_key"
+			]
+		}],
+		indexes: [{
+			name: "factory_pending_starts_claim_idx",
+			columns: ["status", "created_at"]
+		}]
+	}
+];
+function toBinding(row) {
+	return {
+		id: row.id,
+		orgId: row.org_id,
+		factoryProjectId: String(row.factory_project_id),
+		workItemId: String(row.work_item_id),
+		role: String(row.role),
+		threadId: String(row.thread_id),
+		resourceId: String(row.resource_id),
+		sessionId: String(row.session_id),
+		branch: String(row.branch),
+		status: row.status,
+		createdAt: row.created_at,
+		revokedAt: row.revoked_at ?? null
+	};
+}
+function toDeferredDecision(row) {
+	return {
+		id: row.id,
+		orgId: row.org_id,
+		factoryProjectId: String(row.factory_project_id),
+		evaluationId: String(row.evaluation_id),
+		workItemId: row.work_item_id === null || row.work_item_id === void 0 ? null : String(row.work_item_id),
+		idempotencyKey: String(row.idempotency_key),
+		effectOrdinal: Number(row.effect_ordinal),
+		effectHash: String(row.effect_hash),
+		causalChain: row.causal_chain ?? [],
+		actor: row.actor ?? null,
+		decision: row.decision,
+		status: row.status,
+		attempts: Number(row.attempts),
+		availableAt: row.available_at,
+		leaseOwner: row.lease_owner ?? null,
+		leaseExpiresAt: row.lease_expires_at ?? null,
+		lastError: row.last_error ?? null,
+		completedAt: row.completed_at ?? null,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function toPendingStart(row) {
+	return {
+		id: row.id,
+		orgId: row.org_id,
+		factoryProjectId: String(row.factory_project_id),
+		bindingId: String(row.binding_id),
+		kickoffKey: String(row.kickoff_key),
+		message: row.message ?? null,
+		status: row.status,
+		attempts: Number(row.attempts),
+		availableAt: row.available_at,
+		leaseOwner: row.lease_owner ?? null,
+		leaseExpiresAt: row.lease_expires_at ?? null,
+		lastError: row.last_error ?? null,
+		completedAt: row.completed_at ?? null,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+var WorkItemsStorage = class extends FactoryStorageDomain {
+	constructor() {
+		super("work-items");
+	}
+	async init() {
+		await this.ensureCollections([WORK_ITEMS_SCHEMA, ...FACTORY_GOVERNANCE_SCHEMAS]);
+	}
+	async dangerouslyClearAll() {
+		await this.ops.deleteMany("work_items", {});
+	}
+	get #db() {
+		return this.ops;
+	}
+	async #withProjectRelationTransaction(orgId, factoryProjectId, fn) {
+		return withInProcessProjectLock(`work-items:${orgId}:${factoryProjectId}`, () => this.storage.withTransaction(fn, { isolationLevel: "serializable" }));
+	}
+	async #claimLeases(table, input, map) {
+		const claim = () => this.storage.withTransaction(async (ops) => {
+			const candidates = await ops.findMany(table, { status: { in: [
+				"pending",
+				"retry",
+				"leased"
+			] } }, {
+				orderBy: [["created_at", "asc"]],
+				limit: Math.max(input.limit * 5, 50)
+			});
+			const claimed = [];
+			for (const candidate of candidates) {
+				if (claimed.length >= input.limit) break;
+				const availableAt = new Date(candidate.available_at).getTime();
+				const leaseExpiresAt = candidate.lease_expires_at ? new Date(candidate.lease_expires_at).getTime() : 0;
+				const claimable = (candidate.status === "pending" || candidate.status === "retry") && availableAt <= input.now.getTime();
+				const expired = candidate.status === "leased" && leaseExpiresAt <= input.now.getTime();
+				if (!claimable && !expired) continue;
+				let didClaim = false;
+				const row = await ops.updateAtomic(table, { id: candidate.id }, (current) => {
+					const currentAvailable = new Date(current.available_at).getTime();
+					const currentExpiry = current.lease_expires_at ? new Date(current.lease_expires_at).getTime() : 0;
+					const currentClaimable = (current.status === "pending" || current.status === "retry") && currentAvailable <= input.now.getTime();
+					const currentExpired = current.status === "leased" && currentExpiry <= input.now.getTime();
+					if (!currentClaimable && !currentExpired) return null;
+					didClaim = true;
+					return {
+						status: "leased",
+						attempts: Number(current.attempts) + 1,
+						lease_owner: input.ownerId,
+						lease_expires_at: input.leaseExpiresAt,
+						updated_at: input.now
+					};
+				});
+				if (didClaim && row) claimed.push(map(row));
+			}
+			return claimed;
+		});
+		return claim();
+	}
+	async #renewLease(table, identity, leaseExpiresAt) {
+		let renewed = false;
+		await this.#db.updateAtomic(table, {
+			id: identity.id,
+			org_id: identity.orgId,
+			factory_project_id: identity.factoryProjectId
+		}, (current) => {
+			if (current.status !== "leased" || current.lease_owner !== identity.ownerId) return null;
+			renewed = true;
+			return {
+				lease_expires_at: leaseExpiresAt,
+				updated_at: /* @__PURE__ */ new Date()
+			};
+		});
+		return renewed;
+	}
+	async #completeLease(table, identity, now) {
+		let completed = false;
+		const row = await this.#db.updateAtomic(table, {
+			id: identity.id,
+			org_id: identity.orgId,
+			factory_project_id: identity.factoryProjectId
+		}, (current) => {
+			if (current.status !== "leased" || current.lease_owner !== identity.ownerId) return null;
+			completed = true;
+			return {
+				status: table === "factory_pending_starts" ? "sent" : "succeeded",
+				lease_owner: null,
+				lease_expires_at: null,
+				completed_at: now,
+				updated_at: now
+			};
+		});
+		return completed ? row : null;
+	}
+	async #failLease(table, input) {
+		let failed = false;
+		const row = await this.#db.updateAtomic(table, {
+			id: input.id,
+			org_id: input.orgId,
+			factory_project_id: input.factoryProjectId
+		}, (current) => {
+			if (current.status !== "leased" || current.lease_owner !== input.ownerId) return null;
+			failed = true;
+			return {
+				status: input.terminal ? "failed" : "retry",
+				available_at: input.availableAt,
+				lease_owner: null,
+				lease_expires_at: null,
+				last_error: input.lastError,
+				completed_at: input.terminal ? input.now : null,
+				updated_at: input.now
+			};
+		});
+		return failed ? row : null;
+	}
+	async #listWithOps(ops, orgId, factoryProjectId) {
+		return (await ops.findMany("work_items", {
+			org_id: orgId,
+			factory_project_id: factoryProjectId
+		}, { orderBy: [["updated_at", "desc"]] })).map(toWorkItem);
+	}
+	/** List the org's work items for a project, newest first. */
+	async list({ orgId, factoryProjectId }) {
+		return this.#listWithOps(this.#db, orgId, factoryProjectId);
+	}
+	async get({ orgId, id }) {
+		const row = await this.#db.findOne("work_items", {
+			org_id: orgId,
+			id
+		});
+		return row ? toWorkItem(row) : null;
+	}
+	async getForProject(orgId, factoryProjectId, id) {
+		const row = await this.#db.findOne("work_items", {
+			id,
+			org_id: orgId,
+			factory_project_id: factoryProjectId
+		});
+		return row ? toRow(row) : null;
+	}
+	async getTransitionResultByIngress(orgId, factoryProjectId, identity) {
+		return (await this.#db.findOne("factory_rule_ingress", {
+			org_id: orgId,
+			factory_project_id: factoryProjectId,
+			identity
+		}))?.result ?? null;
+	}
+	async commitTransition(input) {
+		const commit = () => this.storage.withTransaction(async (ops) => {
+			const prior = await ops.findOne("factory_rule_ingress", {
+				org_id: input.orgId,
+				factory_project_id: input.factoryProjectId,
+				identity: input.ingress.identity
+			});
+			if (prior) return {
+				status: "replayed",
+				item: await this.getForProject(input.orgId, input.factoryProjectId, input.workItemId),
+				result: prior.result
+			};
+			const now = /* @__PURE__ */ new Date();
+			let item = null;
+			let code = null;
+			let reason = null;
+			let result;
+			const updated = await ops.updateAtomic("work_items", {
+				id: input.workItemId,
+				org_id: input.orgId,
+				factory_project_id: input.factoryProjectId
+			}, (row) => {
+				const existing = toRow(row);
+				item = existing;
+				if (existing.revision !== input.expectedRevision) {
+					code = "stale";
+					reason = "The work item changed before this transition committed.";
+					return null;
+				}
+				if (input.evaluation.outcome === "rejected") {
+					code = input.evaluation.code;
+					reason = input.evaluation.reason;
+					return null;
+				}
+				if (existing.stages.length === 1 && existing.stages[0] === input.destinationStage) return null;
+				return patchColumns({
+					stages: [input.destinationStage],
+					stageHistory: applyStageTransition(existing.stageHistory, existing.stages, [input.destinationStage], input.actorId, now),
+					revision: existing.revision + 1,
+					updatedAt: now
+				});
+			});
+			if (updated) item = toRow(updated);
+			if (!item) {
+				code = input.evaluation.outcome === "rejected" ? input.evaluation.code : "invalid_transition";
+				reason = input.evaluation.outcome === "rejected" ? input.evaluation.reason : "Work item not found.";
+			}
+			const outcome = item && code === null && input.evaluation.outcome === "accepted" ? "accepted" : "rejected";
+			result = outcome === "accepted" ? {
+				status: "accepted",
+				transitionId: input.ingress.transitionId,
+				itemId: item.id,
+				revision: item.revision,
+				stage: input.destinationStage,
+				decisions: input.evaluation.outcome === "accepted" ? input.evaluation.decisions : []
+			} : {
+				status: "rejected",
+				transitionId: input.ingress.transitionId,
+				itemId: input.workItemId,
+				code,
+				reason
+			};
+			const ingress = await ops.insertOne("factory_rule_ingress", {
+				org_id: input.orgId,
+				factory_project_id: input.factoryProjectId,
+				identity: input.ingress.identity,
+				trigger_type: input.ingress.triggerType,
+				transition_id: input.ingress.transitionId,
+				result,
+				created_at: now
+			});
+			if (item) {
+				const evaluation = await ops.insertOne("factory_rule_evaluations", {
+					ingress_id: ingress.id,
+					work_item_id: item.id,
+					rule_set_version: input.ruleSetVersion,
+					expected_revision: input.expectedRevision,
+					outcome,
+					code,
+					reason,
+					causal_chain: input.causalChain,
+					created_at: now
+				});
+				if (outcome === "accepted" && input.evaluation.outcome === "accepted") for (const [index, decision] of input.evaluation.decisions.entries()) await ops.insertOne("factory_deferred_decisions", {
+					org_id: input.orgId,
+					factory_project_id: input.factoryProjectId,
+					evaluation_id: evaluation.id,
+					work_item_id: item.id,
+					idempotency_key: String(decision.idempotencyKey),
+					effect_ordinal: index,
+					effect_hash: factoryDecisionHash(decision),
+					causal_chain: input.causalChain,
+					actor: null,
+					decision,
+					status: "pending",
+					attempts: 0,
+					available_at: now,
+					lease_owner: null,
+					lease_expires_at: null,
+					last_error: null,
+					completed_at: null,
+					created_at: new Date(now.getTime() + index),
+					updated_at: now
+				});
+			}
+			return {
+				status: "committed",
+				item,
+				result
+			};
+		});
+		try {
+			return await commit();
+		} catch (error) {
+			if (!(error instanceof UniqueViolationError)) throw error;
+			return commit();
+		}
+	}
+	async commitRuleEvaluation(input) {
+		const commit = () => this.storage.withTransaction(async (ops) => {
+			const prior = await ops.findOne("factory_rule_ingress", {
+				org_id: input.orgId,
+				factory_project_id: input.factoryProjectId,
+				identity: input.ingress.identity
+			});
+			if (prior) {
+				const result = prior.result;
+				const decisions = Array.isArray(result.decisions) ? result.decisions : [];
+				const evaluation = await ops.findOne("factory_rule_evaluations", { ingress_id: prior.id });
+				for (const decision of decisions) {
+					if (!evaluation || !decision || typeof decision !== "object" || decision.type !== "upsertLinkedWorkItem" || typeof decision.sourceKey !== "string" || typeof decision.idempotencyKey !== "string") continue;
+					const materialization = decision;
+					if (await ops.findOne("work_items", {
+						org_id: input.orgId,
+						factory_project_id: input.factoryProjectId,
+						source_key: materialization.sourceKey
+					})) continue;
+					await ops.updateAtomic("factory_deferred_decisions", {
+						org_id: input.orgId,
+						factory_project_id: input.factoryProjectId,
+						evaluation_id: evaluation.id,
+						idempotency_key: materialization.idempotencyKey
+					}, (current) => current.status === "succeeded" ? {
+						status: "retry",
+						attempts: 0,
+						available_at: input.now,
+						lease_owner: null,
+						lease_expires_at: null,
+						last_error: null,
+						completed_at: null,
+						updated_at: input.now
+					} : null);
+				}
+				return {
+					status: "replayed",
+					result
+				};
+			}
+			const itemRow = input.workItemId ? await ops.findOne("work_items", {
+				id: input.workItemId,
+				org_id: input.orgId,
+				factory_project_id: input.factoryProjectId
+			}) : null;
+			if (input.workItemId !== null && !itemRow) return { status: "missing" };
+			const item = itemRow ? toRow(itemRow) : null;
+			const stale = item !== null && item.revision !== input.expectedRevision;
+			const outcome = stale ? "rejected" : input.outcome.status;
+			const code = stale ? "stale" : input.outcome.code ?? null;
+			const reason = stale ? "The work item changed before this rule evaluation committed." : input.outcome.reason ?? null;
+			const decisions = outcome === "accepted" ? input.decisions : [];
+			const result = {
+				status: outcome,
+				itemId: item?.id ?? null,
+				revision: item?.revision ?? null,
+				code,
+				reason,
+				decisions
+			};
+			const ingress = await ops.insertOne("factory_rule_ingress", {
+				org_id: input.orgId,
+				factory_project_id: input.factoryProjectId,
+				identity: input.ingress.identity,
+				trigger_type: input.ingress.triggerType,
+				transition_id: input.ingress.identity,
+				result,
+				created_at: input.now
+			});
+			const evaluation = await ops.insertOne("factory_rule_evaluations", {
+				ingress_id: ingress.id,
+				work_item_id: item?.id ?? null,
+				rule_set_version: input.ruleSetVersion,
+				expected_revision: input.expectedRevision,
+				outcome,
+				code,
+				reason,
+				causal_chain: input.causalChain,
+				created_at: input.now
+			});
+			for (const [effectOrdinal, decision] of decisions.entries()) await ops.insertOne("factory_deferred_decisions", {
+				org_id: input.orgId,
+				factory_project_id: input.factoryProjectId,
+				evaluation_id: evaluation.id,
+				work_item_id: item?.id ?? null,
+				idempotency_key: String(decision.idempotencyKey),
+				effect_ordinal: effectOrdinal,
+				effect_hash: factoryDecisionHash(decision),
+				causal_chain: input.causalChain,
+				actor: input.actor,
+				decision,
+				status: "pending",
+				attempts: 0,
+				available_at: input.now,
+				lease_owner: null,
+				lease_expires_at: null,
+				last_error: null,
+				completed_at: null,
+				created_at: new Date(input.now.getTime() + effectOrdinal),
+				updated_at: input.now
+			});
+			return {
+				status: "committed",
+				result
+			};
+		});
+		try {
+			return await commit();
+		} catch (error) {
+			if (!(error instanceof UniqueViolationError)) throw error;
+			return commit();
+		}
+	}
+	async getToolResultCursor(orgId, factoryProjectId, bindingId) {
+		const row = await this.#db.findOne("factory_tool_result_cursors", {
+			org_id: orgId,
+			factory_project_id: factoryProjectId,
+			binding_id: bindingId
+		});
+		return row ? {
+			bindingId: String(row.binding_id),
+			orgId: row.org_id,
+			factoryProjectId: String(row.factory_project_id),
+			lastMessageId: String(row.last_message_id),
+			lastMessageCreatedAt: row.last_message_created_at,
+			updatedAt: row.updated_at
+		} : null;
+	}
+	async advanceToolResultCursor(cursor) {
+		const current = await this.getToolResultCursor(cursor.orgId, cursor.factoryProjectId, cursor.bindingId);
+		if (current && current.lastMessageCreatedAt > cursor.lastMessageCreatedAt) return;
+		await this.#db.upsertOne("factory_tool_result_cursors", ["binding_id"], {
+			binding_id: cursor.bindingId,
+			org_id: cursor.orgId,
+			factory_project_id: cursor.factoryProjectId,
+			last_message_id: cursor.lastMessageId,
+			last_message_created_at: cursor.lastMessageCreatedAt,
+			updated_at: cursor.updatedAt
+		});
+	}
+	async listDeferredDecisions(orgId, factoryProjectId) {
+		return (await this.#db.findMany("factory_deferred_decisions", {
+			org_id: orgId,
+			factory_project_id: factoryProjectId
+		}, { orderBy: [["created_at", "asc"]] })).map(toDeferredDecision);
+	}
+	/** Read a bounded newest-first status page without exposing another tenant. */
+	async listDeferredDecisionPage(input) {
+		const rows = await this.#db.findMany("factory_deferred_decisions", {
+			org_id: input.orgId,
+			factory_project_id: input.factoryProjectId,
+			...input.statuses ? { status: { in: input.statuses } } : {}
+		}, {
+			orderBy: [["created_at", "desc"], ["id", "desc"]],
+			limit: input.limit + 1,
+			...input.before ? { cursor: { values: [input.before.createdAt, input.before.id] } } : {}
+		});
+		return {
+			decisions: rows.slice(0, input.limit).map(toDeferredDecision),
+			hasMore: rows.length > input.limit
+		};
+	}
+	async claimDeferredDecisions(input) {
+		return this.#claimLeases("factory_deferred_decisions", input, toDeferredDecision);
+	}
+	async renewDeferredDecisionLease(identity, leaseExpiresAt) {
+		return this.#renewLease("factory_deferred_decisions", identity, leaseExpiresAt);
+	}
+	async completeDeferredDecision(identity, now) {
+		const row = await this.#completeLease("factory_deferred_decisions", identity, now);
+		return row ? toDeferredDecision(row) : null;
+	}
+	async failDeferredDecision(input) {
+		const row = await this.#failLease("factory_deferred_decisions", input);
+		return row ? toDeferredDecision(row) : null;
+	}
+	/** 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 retried && row ? toDeferredDecision(row) : null;
+	}
+	/** Resolve exact active agent authority; partial session matches never authorize. */
+	async findActiveRunBinding(address) {
+		const row = await this.#db.findOne("factory_run_bindings", {
+			org_id: address.orgId,
+			factory_project_id: address.factoryProjectId,
+			thread_id: address.threadId,
+			resource_id: address.resourceId,
+			session_id: address.sessionId,
+			status: "active"
+		});
+		return row ? toBinding(row) : null;
+	}
+	/** Resolve exact bound-session state for processor awareness; ambiguous cross-tenant matches return null. */
+	async findRunBindingBySession(address) {
+		const rows = await this.#db.findMany("factory_run_bindings", {
+			factory_project_id: address.factoryProjectId,
+			thread_id: address.threadId,
+			resource_id: address.resourceId,
+			session_id: address.sessionId
+		});
+		if (new Set(rows.map((row) => row.org_id)).size !== 1) return null;
+		const row = rows.sort((left, right) => {
+			if (left.status === "active" && right.status !== "active") return -1;
+			if (right.status === "active" && left.status !== "active") return 1;
+			return right.created_at.getTime() - left.created_at.getTime();
+		})[0];
+		return row ? toBinding(row) : null;
+	}
+	/** Revoke one exact tenant-scoped binding. */
+	async revokeRunBinding(input) {
+		let revoked = false;
+		const row = await this.#db.updateAtomic("factory_run_bindings", {
+			id: input.bindingId,
+			org_id: input.orgId,
+			factory_project_id: input.factoryProjectId
+		}, (current) => {
+			if (current.status !== "active") return null;
+			revoked = true;
+			return {
+				status: "revoked",
+				revoked_at: input.revokedAt
+			};
+		});
+		return revoked && row ? toBinding(row) : null;
+	}
+	/** Enumerate active bindings for the server-owned restart reconciler. */
+	async listActiveRunBindings() {
+		return (await this.#db.findMany("factory_run_bindings", { status: "active" })).map(toBinding);
+	}
+	/** List binding history, optionally narrowed to one work item. */
+	async listRunBindings(orgId, factoryProjectId, workItemId) {
+		return (await this.#db.findMany("factory_run_bindings", {
+			org_id: orgId,
+			factory_project_id: factoryProjectId,
+			...workItemId ? { work_item_id: workItemId } : {}
+		}, { orderBy: [["created_at", "asc"]] })).map(toBinding);
+	}
+	async listPendingStarts(orgId, factoryProjectId) {
+		return (await this.#db.findMany("factory_pending_starts", {
+			org_id: orgId,
+			factory_project_id: factoryProjectId
+		}, { orderBy: [["created_at", "asc"]] })).map(toPendingStart);
+	}
+	async claimPendingStarts(input) {
+		return this.#claimLeases("factory_pending_starts", input, toPendingStart);
+	}
+	async renewPendingStartLease(identity, leaseExpiresAt) {
+		return this.#renewLease("factory_pending_starts", identity, leaseExpiresAt);
+	}
+	async completePendingStart(identity, now) {
+		const row = await this.#completeLease("factory_pending_starts", identity, now);
+		return row ? toPendingStart(row) : null;
+	}
+	async failPendingStart(input) {
+		const row = await this.#failLease("factory_pending_starts", input);
+		return row ? toPendingStart(row) : null;
+	}
+	async prepareRunStart(input) {
+		const prepare = () => this.storage.withTransaction(async (ops) => {
+			const prior = await ops.findOne("factory_pending_starts", {
+				org_id: input.orgId,
+				factory_project_id: input.factoryProjectId,
+				kickoff_key: input.kickoffKey
+			});
+			if (prior) {
+				const bindingRow = await ops.findOne("factory_run_bindings", {
+					id: String(prior.binding_id),
+					org_id: input.orgId,
+					factory_project_id: input.factoryProjectId
+				});
+				const itemRow = bindingRow && await ops.findOne("work_items", {
+					id: String(bindingRow.work_item_id),
+					org_id: input.orgId,
+					factory_project_id: input.factoryProjectId
+				});
+				if (!bindingRow || !itemRow) throw new Error("Factory start replay references missing state.");
+				return {
+					item: toRow(itemRow),
+					binding: toBinding(bindingRow),
+					pendingStart: toPendingStart(prior),
+					replayed: true
+				};
+			}
+			const now = /* @__PURE__ */ new Date();
+			const create = input.workItem.input;
+			let row = input.workItem.id ? await ops.findOne("work_items", {
+				id: input.workItem.id,
+				org_id: input.orgId,
+				factory_project_id: input.factoryProjectId
+			}) : sourceKey(create.externalSource) ? await ops.findOne("work_items", {
+				org_id: input.orgId,
+				factory_project_id: input.factoryProjectId,
+				source_key: sourceKey(create.externalSource)
+			}) : null;
+			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 }
+					});
+				});
+				item = toRow(row);
+			} else {
+				if (create.parentWorkItemId) validateParentRelation((await ops.findMany("work_items", {
+					org_id: input.orgId,
+					factory_project_id: input.factoryProjectId
+				})).map(toRow), void 0, create.parentWorkItemId);
+				row = await ops.insertOne("work_items", {
+					org_id: input.orgId,
+					created_by: input.userId,
+					factory_project_id: input.factoryProjectId,
+					external_source: create.externalSource ?? null,
+					source_key: sourceKey(create.externalSource),
+					parent_work_item_id: create.parentWorkItemId ?? null,
+					title: create.title,
+					stages: create.stages ?? [],
+					stage_history: applyStageTransition([], [], create.stages ?? [], input.userId, now),
+					sessions: stampSessions({ [input.role]: input.session }, input.userId),
+					metadata: create.metadata ?? null,
+					revision: 1,
+					created_at: now,
+					updated_at: now
+				});
+				item = toRow(row);
+			}
+			await ops.updateMany("factory_run_bindings", {
+				org_id: input.orgId,
+				factory_project_id: input.factoryProjectId,
+				work_item_id: item.id,
+				role: input.role,
+				status: "active"
+			}, {
+				status: "revoked",
+				revoked_at: now
+			});
+			const bindingRow = await ops.insertOne("factory_run_bindings", {
+				org_id: input.orgId,
+				factory_project_id: input.factoryProjectId,
+				work_item_id: item.id,
+				role: input.role,
+				thread_id: input.session.threadId,
+				resource_id: input.resourceId,
+				session_id: input.session.sessionId,
+				branch: input.session.branch,
+				status: "active",
+				created_at: now,
+				revoked_at: null
+			});
+			const pendingRow = await ops.insertOne("factory_pending_starts", {
+				org_id: input.orgId,
+				factory_project_id: input.factoryProjectId,
+				binding_id: bindingRow.id,
+				kickoff_key: input.kickoffKey,
+				message: input.kickoffMessage,
+				status: "pending",
+				attempts: 0,
+				available_at: now,
+				lease_owner: null,
+				lease_expires_at: null,
+				last_error: null,
+				completed_at: null,
+				created_at: now,
+				updated_at: now
+			});
+			return {
+				item,
+				binding: toBinding(bindingRow),
+				pendingStart: toPendingStart(pendingRow),
+				replayed: false
+			};
+		});
+		let lastError;
+		for (let attempt = 0; attempt < 3; attempt++) try {
+			return await prepare();
+		} catch (error) {
+			if (!(error instanceof UniqueViolationError)) throw error;
+			lastError = error;
+		}
+		throw lastError;
+	}
+	async markPendingStart(bindingId, status, lastError) {
+		const row = await this.#db.updateAtomic("factory_pending_starts", { binding_id: bindingId }, () => ({
+			status,
+			last_error: lastError ?? null,
+			updated_at: /* @__PURE__ */ new Date()
+		}));
+		return row ? toPendingStart(row) : null;
+	}
+	/**
+	* Create a work item, reusing the existing record when `sourceKey` already
+	* has one for the project (acting twice on the same issue must not duplicate
+	* the card). On reuse the provided stages replace the current ones (with the
+	* transition recorded in history) and sessions/metadata are merged in. The
+	* result discriminates insert from reuse so callers can audit the actual
+	* outcome.
+	*/
+	async upsert(params) {
+		const run = (ops) => this.#upsert(params, ops);
+		const execute = () => params.input.parentWorkItemId ? this.#withProjectRelationTransaction(params.orgId, params.factoryProjectId, run) : run(this.#db);
+		try {
+			return await execute();
+		} catch (error) {
+			if (!(error instanceof UniqueViolationError)) throw error;
+			return execute();
+		}
+	}
+	async #upsert({ orgId, userId, factoryProjectId, input, reuseMode = "update" }, ops) {
+		const key = sourceKey(input.externalSource);
+		const reuse = async () => {
+			if (!key) return null;
+			const existing = await ops.findOne("work_items", {
+				org_id: orgId,
+				factory_project_id: factoryProjectId,
+				source_key: key
+			});
+			if (!existing) return null;
+			if (reuseMode === "preserve") return {
+				created: false,
+				item: toWorkItem(existing),
+				previous: priorState(existing)
+			};
+			let previous = emptyPrior();
+			const updated = await ops.updateAtomic("work_items", {
+				org_id: orgId,
+				factory_project_id: factoryProjectId,
+				source_key: key
+			}, async (current) => {
+				previous = priorState(current);
+				const fullPatch = input.parentWorkItemId === null ? {
+					...input,
+					parentWorkItemId: void 0
+				} : input;
+				const patch = reuseMode === "non-stage" ? {
+					title: input.title,
+					parentWorkItemId: input.parentWorkItemId ?? void 0,
+					metadata: input.metadata
+				} : fullPatch;
+				if (patch.parentWorkItemId !== void 0) validateParentRelation(await this.#listWithOps(ops, orgId, factoryProjectId), current.id, patch.parentWorkItemId);
+				return {
+					external_source: input.externalSource ?? null,
+					...applyUpdate({
+						current,
+						userId,
+						input: patch
+					})
+				};
+			});
+			return updated ? {
+				item: toWorkItem(updated),
+				created: false,
+				previous
+			} : null;
+		};
+		const reused = await reuse();
+		if (reused) return reused;
+		const now = /* @__PURE__ */ new Date();
+		const stages = input.stages ?? ["intake"];
+		validateParentRelation(await this.#listWithOps(ops, orgId, factoryProjectId), void 0, input.parentWorkItemId ?? null);
+		return {
+			item: toWorkItem(await ops.insertOne("work_items", {
+				org_id: orgId,
+				factory_project_id: factoryProjectId,
+				external_source: input.externalSource ?? null,
+				source_key: key,
+				parent_work_item_id: input.parentWorkItemId ?? null,
+				title: input.title,
+				stages,
+				stage_history: stages.map((stage) => ({
+					stage,
+					enteredAt: now.toISOString(),
+					by: userId
+				})),
+				sessions: stampSessions(input.sessions ?? {}, userId),
+				metadata: input.metadata ?? null,
+				revision: 1,
+				created_by: userId,
+				created_at: now,
+				updated_at: now
+			})),
+			created: true,
+			previous: emptyPrior()
+		};
+	}
+	async update({ orgId, id, userId, patch }) {
+		const run = async (ops) => {
+			let previous = emptyPrior();
+			const row = await ops.updateAtomic("work_items", {
+				org_id: orgId,
+				id
+			}, async (current) => {
+				previous = priorState(current);
+				if (patch.parentWorkItemId !== void 0) validateParentRelation(await this.#listWithOps(ops, orgId, current.factory_project_id), current.id, patch.parentWorkItemId);
+				return applyUpdate({
+					current,
+					userId,
+					input: patch
+				});
+			});
+			return row ? {
+				item: toWorkItem(row),
+				previous
+			} : null;
+		};
+		if (patch.parentWorkItemId === void 0) return run(this.#db);
+		const candidate = await this.#db.findOne("work_items", {
+			org_id: orgId,
+			id
+		});
+		if (!candidate) return null;
+		return this.#withProjectRelationTransaction(orgId, candidate.factory_project_id, run);
+	}
+	async delete({ orgId, id }) {
+		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 existing = await ops.findOne("work_items", {
+				org_id: orgId,
+				id
+			});
+			if (!existing) return null;
+			if (await ops.deleteMany("work_items", {
+				org_id: orgId,
+				id
+			}) === 0) return null;
+			await ops.updateMany("work_items", {
+				org_id: orgId,
+				parent_work_item_id: id
+			}, {
+				parent_work_item_id: null,
+				updated_at: /* @__PURE__ */ new Date()
+			});
+			return toWorkItem(existing);
+		});
+	}
+};
+//#endregion
+export { AUTOMATION_ACTORS, WORK_ITEMS_SCHEMA, WorkItemRelationError, WorkItemsStorage, applyStageTransition, factoryDecisionHash, isAutomationActor, stampSessions, validateParentRelation };
+
+//# sourceMappingURL=base.js.map