@mastra/factory 0.8.0-alpha.13 → 0.8.0-alpha.14

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

@@ -32,6 +32,18 @@ function isAgentActor(by) {
 	if (by === void 0) return false;
 	return by.startsWith("agent:") || by === "factory-tool-result-rule";
 }
+/**
+* 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
+* items outside these stages are dead weight in the reconcile walk.
+*/
+const ACTIVE_RUN_BINDING_STAGES = /* @__PURE__ */ new Set([
+	"intake",
+	"triage",
+	"planning",
+	"execute",
+	"review"
+]);
 const WORK_ITEMS_SCHEMA = {
 	name: "work_items",
 	columns: {
@@ -58,6 +70,10 @@ const WORK_ITEMS_SCHEMA = {
 			type: "json",
 			nullable: true
 		},
+		autonomy_armed_at: {
+			type: "timestamp",
+			nullable: true
+		},
 		revision: {
 			type: "integer",
 			default: 1
@@ -101,6 +117,7 @@ function toWorkItem(row) {
 		stageHistory: row.stage_history,
 		sessions: row.sessions,
 		metadata: row.metadata,
+		autonomyArmedAt: row.autonomy_armed_at ?? null,
 		revision: row.revision,
 		createdBy: row.created_by,
 		createdAt: row.created_at,
@@ -116,6 +133,7 @@ function patchColumns(changes) {
 		...changes.stageHistory !== void 0 ? { stage_history: changes.stageHistory } : {},
 		...changes.sessions !== void 0 ? { sessions: changes.sessions } : {},
 		...changes.metadata !== void 0 ? { metadata: changes.metadata } : {},
+		...changes.autonomyArmedAt !== void 0 && changes.autonomyArmedAt !== null ? { autonomy_armed_at: changes.autonomyArmedAt } : {},
 		...changes.revision !== void 0 ? { revision: changes.revision } : {},
 		...changes.updatedAt !== void 0 ? { updated_at: changes.updatedAt } : {}
 	};
@@ -664,8 +682,10 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 					reason = input.evaluation.reason;
 					return null;
 				}
-				if (existing.stages.length === 1 && existing.stages[0] === input.destinationStage) return null;
+				const arm = input.armAutonomy === true && !existing.autonomyArmedAt;
+				if (existing.stages.length === 1 && existing.stages[0] === input.destinationStage) return arm ? patchColumns({ autonomyArmedAt: now }) : null;
 				return patchColumns({
+					...arm ? { autonomyArmedAt: now } : {},
 					stages: [input.destinationStage],
 					stageHistory: applyStageTransition(existing.stageHistory, existing.stages, [input.destinationStage], input.actorId, now),
 					revision: existing.revision + 1,
@@ -946,18 +966,37 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 		});
 		return proposed && row ? toDeferredDecision(row) : null;
 	}
-	/** Release an approved effect back to the dispatcher; only `proposed` rows are approvable. */
+	/**
+	* Release an approved effect back to the dispatcher; only `proposed` rows are
+	* approvable. Approval is a person taking the item on, so the item's autonomy
+	* 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) {
-		return this.#settleProposedDecision({
-			orgId,
-			factoryProjectId,
-			decisionId
-		}, {
-			status: "pending",
-			attempts: 0,
-			available_at: now,
-			approved_at: now,
-			updated_at: now
+		return this.storage.withTransaction(async (ops) => {
+			let settled = false;
+			const row = await ops.updateAtomic("factory_deferred_decisions", {
+				id: decisionId,
+				org_id: orgId,
+				factory_project_id: factoryProjectId
+			}, (current) => {
+				if (current.status !== "proposed") return null;
+				settled = true;
+				return {
+					status: "pending",
+					attempts: 0,
+					available_at: now,
+					approved_at: now,
+					updated_at: now
+				};
+			});
+			if (!settled || !row) return null;
+			const record = toDeferredDecision(row);
+			if (record.workItemId) await ops.updateAtomic("work_items", {
+				org_id: orgId,
+				id: record.workItemId
+			}, (current) => current.autonomy_armed_at ? null : { autonomy_armed_at: now });
+			return record;
 		});
 	}
 	/** Retire a proposal nobody wants: `dismissed` is terminal, so the run never happens. */
@@ -972,6 +1011,29 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 			completed_at: now
 		});
 	}
+	/**
+	* 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.
+	*/
+	async dismissProposalsForWorkItem(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"
+		});
+		const dismissed = [];
+		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);
+		}
+		return dismissed;
+	}
 	async #settleProposedDecision({ orgId, factoryProjectId, decisionId }, patch) {
 		let settled = false;
 		const row = await this.#db.updateAtomic("factory_deferred_decisions", {
@@ -1070,6 +1132,56 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 		});
 		return revoked && row ? toBinding(row) : null;
 	}
+	/**
+	* Revoke every active binding for one work item (all roles). Called from
+	* terminal-stage cleanup so completed items stop paying the reconcile walk.
+	* Returns the number of bindings revoked.
+	*/
+	async revokeRunBindingsForWorkItem(input) {
+		return this.#db.updateMany("factory_run_bindings", {
+			org_id: input.orgId,
+			factory_project_id: input.factoryProjectId,
+			work_item_id: input.workItemId,
+			status: "active"
+		}, {
+			status: "revoked",
+			revoked_at: input.revokedAt
+		});
+	}
+	/**
+	* Revoke leaked/legacy active bindings: older than `olderThan`, or whose
+	* work item is gone, malformed, or already terminal. Terminal-stage cleanup
+	* handles bindings go-forward; this sweep drains anything that slipped past
+	* it. Returns the number of bindings revoked.
+	*/
+	async revokeStaleRunBindings(input) {
+		const bindings = await this.listActiveRunBindings();
+		const itemCache = /* @__PURE__ */ new Map();
+		let revoked = 0;
+		for (const binding of bindings) {
+			let stale = binding.createdAt.getTime() < input.olderThan.getTime();
+			if (!stale) {
+				const key = `${binding.orgId}:${binding.workItemId}`;
+				let item = itemCache.get(key);
+				if (item === void 0) {
+					item = await this.get({
+						orgId: binding.orgId,
+						id: binding.workItemId
+					});
+					itemCache.set(key, item);
+				}
+				stale = !item || item.stages.length !== 1 || !ACTIVE_RUN_BINDING_STAGES.has(item.stages[0]) || item.factoryProjectId !== binding.factoryProjectId;
+			}
+			if (!stale) continue;
+			if (await this.revokeRunBinding({
+				orgId: binding.orgId,
+				factoryProjectId: binding.factoryProjectId,
+				bindingId: binding.id,
+				revokedAt: input.now
+			})) revoked += 1;
+		}
+		return revoked;
+	}
 	/** Enumerate active bindings for the server-owned restart reconciler. */
 	async listActiveRunBindings() {
 		return (await this.#db.findMany("factory_run_bindings", { status: "active" })).map(toBinding);
@@ -1174,6 +1286,10 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 				});
 				item = toRow(row);
 			}
+			if (input.armAutonomy && !item.autonomyArmedAt) {
+				const armedRow = await ops.updateAtomic("work_items", { id: item.id }, (current) => current.autonomy_armed_at ? null : { autonomy_armed_at: now });
+				if (armedRow) item = toRow(armedRow);
+			}
 			await ops.updateMany("factory_run_bindings", {
 				org_id: input.orgId,
 				factory_project_id: input.factoryProjectId,
@@ -1372,6 +1488,18 @@ var WorkItemsStorage = class extends FactoryStorageDomain {
 		return this.#withProjectRelationTransaction(orgId, candidate.factory_project_id, run);
 	}
 	/**
+	* Record that a person committed this item to the Factory. Only the first
+	* time counts: the timestamp marks when the item stopped needing permission,
+	* so later runs must not push it forward. Bumps no revision, because arming
+	* is not a change anyone is editing against.
+	*/
+	async armAutonomy({ orgId, id, now }) {
+		await this.#db.updateAtomic("work_items", {
+			org_id: orgId,
+			id
+		}, (current) => current.autonomy_armed_at ? null : { autonomy_armed_at: now });
+	}
+	/**
 	* Drop the governance rows that materialized a source key so a deleted work item
 	* is not resurrected by the prior-ingress replay path on the next intake poll.
 	*/