@mastra/factory 0.2.2-alpha.0 → 0.2.2-alpha.2

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

@@ -1,1173 +1,1307 @@
-// src/storage/domains/work-items/base.ts
 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";
+	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");
+	return createHash("sha256").update(stableJson(decision)).digest("hex");
 }
-var AUTOMATION_ACTORS = /* @__PURE__ */ new Set([
-  "factory",
-  "system",
-  "automation",
-  "factory-rule-dispatcher",
-  "factory-tool-result-rule"
+/**
+* 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:");
+	if (by === void 0) return false;
+	return AUTOMATION_ACTORS.has(by) || by.startsWith("agent:") || by.startsWith("github:");
 }
-var 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"]
-    }
-  ]
+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;
+	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
-  };
+	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
+	};
 }
-var toRow = toWorkItem;
+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 } : {}
-  };
+	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: [] };
+	return {
+		stages: [],
+		sessionRoles: []
+	};
 }
 function priorState(row) {
-  return { stages: row.stages, sessionRoles: Object.keys(row.sessions) };
+	return {
+		stages: row.stages,
+		sessionRoles: Object.keys(row.sessions)
+	};
 }
 var WorkItemRelationError = class extends Error {
-  code = "invalid_work_item_relation";
+	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);
-  }
+	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;
+	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 }]));
+	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
-  };
+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
+	};
 }
-var projectRelationLocks = /* @__PURE__ */ new Map();
+const projectRelationLocks = /* @__PURE__ */ new Map();
 function withInProcessProjectLock(key, fn) {
-  const previous = projectRelationLocks.get(key) ?? Promise.resolve();
-  const result = previous.then(fn, fn);
-  const tail = result.then(
-    () => void 0,
-    () => void 0
-  );
-  projectRelationLocks.set(key, tail);
-  void tail.then(() => {
-    if (projectRelationLocks.get(key) === tail) projectRelationLocks.delete(key);
-  });
-  return result;
+	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;
 }
-var 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"]
-      }
-    ]
-  },
-  {
-    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 }
-    }
-  },
-  {
-    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"]
-      }
-    ]
-  }
+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
-  };
+	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
-  };
+	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
-  };
+	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) {
-    const key = `work-items:${orgId}:${factoryProjectId}`;
-    return withInProcessProjectLock(key, () => this.storage.withTransaction(fn, { isolationLevel: "serializable" }));
-  }
-  async #claimLeases(table, input, map) {
-    const claim = () => this.storage.withTransaction(async (ops) => {
-      const candidates = await ops.findMany(table, {}, { orderBy: [["created_at", "asc"]] });
-      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) {
-    const rows = await ops.findMany(
-      "work_items",
-      { org_id: orgId, factory_project_id: factoryProjectId },
-      { orderBy: [["updated_at", "desc"]] }
-    );
-    return rows.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) {
-    const row = await this.#db.findOne("factory_rule_ingress", {
-      org_id: orgId,
-      factory_project_id: factoryProjectId,
-      identity
-    });
-    return row?.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 result2 = prior.result;
-        const decisions2 = Array.isArray(result2.decisions) ? result2.decisions : [];
-        const evaluation2 = await ops.findOne("factory_rule_evaluations", { ingress_id: prior.id });
-        for (const decision of decisions2) {
-          if (!evaluation2 || !decision || typeof decision !== "object" || decision.type !== "upsertLinkedWorkItem" || typeof decision.sourceKey !== "string" || typeof decision.idempotencyKey !== "string") {
-            continue;
-          }
-          const materialization = decision;
-          const item2 = await ops.findOne("work_items", {
-            org_id: input.orgId,
-            factory_project_id: input.factoryProjectId,
-            source_key: materialization.sourceKey
-          });
-          if (item2) continue;
-          await ops.updateAtomic(
-            "factory_deferred_decisions",
-            {
-              org_id: input.orgId,
-              factory_project_id: input.factoryProjectId,
-              evaluation_id: evaluation2.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: result2 };
-      }
-      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((row2) => row2.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 bindingRow2 = await ops.findOne("factory_run_bindings", {
-          id: String(prior.binding_id),
-          org_id: input.orgId,
-          factory_project_id: input.factoryProjectId
-        });
-        const itemRow = bindingRow2 && await ops.findOne("work_items", {
-          id: String(bindingRow2.work_item_id),
-          org_id: input.orgId,
-          factory_project_id: input.factoryProjectId
-        });
-        if (!bindingRow2 || !itemRow) throw new Error("Factory start replay references missing state.");
-        return {
-          item: toRow(itemRow),
-          binding: toBinding(bindingRow2),
-          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 };
-    });
-    try {
-      return await prepare();
-    } catch (error) {
-      if (!(error instanceof UniqueViolationError)) throw error;
-      return prepare();
-    }
-  }
-  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") {
-        const item = toWorkItem(existing);
-        return { created: false, item, 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
-    );
-    const row = 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
-    });
-    return { item: toWorkItem(row), 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;
-      const deleted = await ops.deleteMany("work_items", { org_id: orgId, id });
-      if (deleted === 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);
-    });
-  }
-};
-export {
-  AUTOMATION_ACTORS,
-  WORK_ITEMS_SCHEMA,
-  WorkItemRelationError,
-  WorkItemsStorage,
-  applyStageTransition,
-  factoryDecisionHash,
-  isAutomationActor,
-  stampSessions,
-  validateParentRelation
+	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
+			};
+		});
+		try {
+			return await prepare();
+		} catch (error) {
+			if (!(error instanceof UniqueViolationError)) throw error;
+			return prepare();
+		}
+	}
+	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