@mastra/factory 0.0.0-aggregate-trace-20261015182851

package/dist/routes/work-items.js

@@ -0,0 +1,633 @@
+import { createBoardRegistry } from "../boards/registry.js";
+import "../boards/index.js";
+import { effectiveModelScope } from "../storage/domains/projects/base.js";
+import { FACTORY_PULL_REQUEST_RECONCILIATION_KEY, FACTORY_RULE_MATERIALIZATION_KEY, WorkItemRelationError, WorkItemUpdateConflictError } from "../storage/domains/work-items/base.js";
+import { EXTERNAL_SOURCE_MISSING_KEY } from "../integrations/issue-reconciler.js";
+import { FACTORY_ROUTE_CONTRACTS } from "./contracts.js";
+import { Route } from "./route.js";
+import { FactoryStartTransitionError, WorkItemRepositoryError } from "../rules/start-coordinator.js";
+import { auditRequestOrigin } from "../storage/domains/audit/domain.js";
+import { decisionRetryable, overtakenDecisionIds } from "../rules/decision-applicability.js";
+import { thresholdsOrDefault } from "../storage/domains/queue-health/base.js";
+import { computeFactoryMetrics, parseMetricsRange } from "../storage/domains/work-items/metrics.js";
+import { factoryDecisionType } from "./attention-providers.js";
+import { buildAttentionRoutes } from "./attention.js";
+import { buildSupervisorRoutes } from "./supervisor.js";
+import { registerApiRoute } from "@mastra/core/server";
+//#region src/routes/work-items.ts
+/** The card as clients see it, without the dispatcher's internal bookkeeping. */
+function toWireWorkItem(item) {
+	if (!item.metadata || !("factoryRuleMaterializationKey" in item.metadata) && !("factoryPullRequestReconciliation" in item.metadata) && !("externalSourceMissingAt" in item.metadata)) return item;
+	return {
+		...item,
+		metadata: publicWorkItemMetadata(item.metadata) ?? {}
+	};
+}
+/** Session ids of the listed cards that the predicate picks, each once. */
+function sessionIdsWhere(items, predicate) {
+	const picked = /* @__PURE__ */ new Set();
+	for (const item of items) for (const { sessionId } of Object.values(item.sessions)) if (predicate(sessionId)) picked.add(sessionId);
+	return [...picked];
+}
+function loose(c) {
+	return c;
+}
+function publicWorkItemMetadata(value) {
+	if (value === null) return null;
+	const { [FACTORY_RULE_MATERIALIZATION_KEY]: _materialization, [FACTORY_PULL_REQUEST_RECONCILIATION_KEY]: _reconciliation, [EXTERNAL_SOURCE_MISSING_KEY]: _externalSourceMissingAt, ...metadata } = value;
+	return metadata;
+}
+/** Validate an untrusted create body. Unknown keys are dropped. */
+function parseCreateWorkItem(body) {
+	const parsed = FACTORY_ROUTE_CONTRACTS.workItemCreate.bodySchema.safeParse(body);
+	return parsed.success ? parsed.data : null;
+}
+/** Validate an untrusted patch body. Unknown keys are dropped. */
+function parseUpdateWorkItem(body) {
+	const parsed = FACTORY_ROUTE_CONTRACTS.workItemUpdate.bodySchema.safeParse(body);
+	return parsed.success ? parsed.data : null;
+}
+async function readJson(c) {
+	try {
+		return await c.req.json();
+	} catch {
+		return;
+	}
+}
+/** Fields a PATCH touched, for the bounded `updated` event summary. */
+function patchedFields(patch) {
+	return Object.keys(patch).filter((key) => patch[key] !== void 0);
+}
+function parseTransitionBody(body) {
+	const parsed = FACTORY_ROUTE_CONTRACTS.workItemTransition.bodySchema.safeParse(body);
+	return parsed.success ? parsed.data : null;
+}
+function parseStartBody(body, tenant, factoryProjectId, modelScope) {
+	const parsed = FACTORY_ROUTE_CONTRACTS.workItemStart.bodySchema.safeParse(body);
+	return parsed.success ? {
+		...tenant,
+		factoryProjectId,
+		modelScope,
+		...parsed.data
+	} : null;
+}
+function encodeDecisionCursor(decision) {
+	return Buffer.from(JSON.stringify([decision.createdAt.toISOString(), decision.id]), "utf8").toString("base64url");
+}
+/** A proposed transition names the seat its lane addresses, so the card can label what approving starts. */
+function summaryRole(boards, decision) {
+	if (typeof decision.role === "string") return decision.role.slice(0, 32);
+	if (decision.type !== "transition") return null;
+	const { board, stage } = decision;
+	if (typeof board !== "string" || typeof stage !== "string") return null;
+	return boards.get(board)?.roleForPhase(stage) ?? null;
+}
+/** A linked-card decision names where the card is synced from, so the UI can say "GitHub" rather than "a linked card". */
+function summarySource(decision) {
+	if (decision.type !== "upsertLinkedWorkItem") return null;
+	const source = decision.source;
+	return source === "github-issue" || source === "github-pr" || source === "gitlab-issue" || source === "gitlab-pr" || source === "linear-issue" || source === "manual" ? source : null;
+}
+function decisionSummary(boards, decision, overtaken = false) {
+	return {
+		id: decision.id,
+		evaluationId: decision.evaluationId,
+		workItemId: decision.workItemId,
+		type: factoryDecisionType(decision),
+		role: summaryRole(boards, decision.decision),
+		source: summarySource(decision.decision),
+		status: decision.status,
+		attempts: decision.attempts,
+		failureOccurrence: decision.failureOccurrence,
+		failureCode: decision.failureCode,
+		canRetry: decisionRetryable(decision, overtaken),
+		lastError: decision.lastError?.slice(0, 512) ?? null,
+		createdAt: decision.createdAt.toISOString(),
+		updatedAt: decision.updatedAt.toISOString(),
+		completedAt: decision.completedAt?.toISOString() ?? null
+	};
+}
+var WorkItemRoutes = class extends Route {
+	#defaultBoards;
+	get #boards() {
+		return this.deps.boardRegistry ?? (this.#defaultBoards ??= createBoardRegistry());
+	}
+	/** Resolve the `(orgId, userId)` tenant or a ready-to-return error response. */
+	async #resolveTenant(c) {
+		await this.deps.auth.ensureUser(c);
+		const tenant = this.deps.auth.tenant(c);
+		if (!tenant) return { response: c.json({ error: "unauthorized" }, 401) };
+		if (!tenant.orgId) return { response: c.json({
+			error: "organization_required",
+			message: "The Factory board requires an organization."
+		}, 403) };
+		return {
+			orgId: tenant.orgId,
+			userId: tenant.userId
+		};
+	}
+	/**
+	* Resolve the tenant AND the org-owned project from the `:id` param. Work
+	* items hang off a project, so listing/creating requires the project to
+	* exist in the caller's org.
+	*/
+	async #resolveProject(c) {
+		const tenant = await this.#resolveTenant(c);
+		if ("response" in tenant) return tenant;
+		const parsedPath = FACTORY_ROUTE_CONTRACTS.projectGet.pathSchema.safeParse({ id: c.req.param("id") });
+		if (!parsedPath.success) return { response: c.json({ error: "Project not found" }, 404) };
+		const projectId = parsedPath.data.id;
+		const { projects } = this.deps;
+		await projects.ensureReady();
+		const project = await projects.get({
+			orgId: tenant.orgId,
+			id: projectId
+		});
+		if (!project) return { response: c.json({ error: "Project not found" }, 404) };
+		const modelScope = effectiveModelScope(project.modelScope, "run");
+		return {
+			...tenant,
+			factoryProjectId: projectId,
+			modelScope,
+			defaultModelId: modelScope === "factory" ? project.defaultModelId : null
+		};
+	}
+	async #auditWorkItemPatch({ context, item, patch }) {
+		await this.deps.audit.emit({
+			context,
+			input: {
+				action: "factory.work_item.updated",
+				factoryProjectId: item.factoryProjectId,
+				targets: [{
+					type: "work_item",
+					id: item.id,
+					name: item.title
+				}],
+				metadata: { fields: patchedFields(patch) }
+			}
+		});
+	}
+	/** Releasing a parked run and dropping it: same request, opposite outcomes, both audited as consent. */
+	#proposalRoute({ verb, settle }) {
+		const { audit, workItems } = this.deps;
+		const contract = verb === "approve" ? FACTORY_ROUTE_CONTRACTS.decisionApprove : FACTORY_ROUTE_CONTRACTS.decisionDismiss;
+		return registerApiRoute(contract.path, {
+			method: contract.method,
+			requiresAuth: false,
+			handler: async (c) => {
+				const context = loose(c);
+				const resolved = await this.#resolveProject(context);
+				if ("response" in resolved) return resolved.response;
+				const parsedPath = contract.pathSchema.safeParse({
+					id: resolved.factoryProjectId,
+					decisionId: context.req.param("decisionId")
+				});
+				if (!parsedPath.success) return c.json({ error: "invalid_decision_id" }, 422);
+				const { decisionId } = parsedPath.data;
+				await workItems.ensureReady();
+				const now = /* @__PURE__ */ new Date();
+				const decision = await settle(resolved.orgId, resolved.factoryProjectId, decisionId, now, resolved.userId);
+				if (!decision) return c.json({ error: "decision_not_proposed" }, 409);
+				await audit.emit({
+					context,
+					input: {
+						action: verb === "approve" ? "factory.run.approved" : "factory.run.dismissed",
+						factoryProjectId: resolved.factoryProjectId,
+						targets: decision.workItemId ? [{
+							type: "work_item",
+							id: decision.workItemId
+						}] : [{
+							type: "rule_decision",
+							id: decision.id
+						}],
+						metadata: {
+							decisionId: decision.id,
+							effect: factoryDecisionType(decision)
+						}
+					}
+				});
+				return c.json({ decision: decisionSummary(this.#boards, decision) });
+			}
+		});
+	}
+	/** Build the Factory work-item routes as Mastra `apiRoutes`. */
+	routes() {
+		const { audit, workItems, queueHealth, transitionService, startCoordinator, liveSessions } = this.deps;
+		return [
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.boardCatalog.path, {
+				method: FACTORY_ROUTE_CONTRACTS.boardCatalog.method,
+				requiresAuth: false,
+				handler: async (c) => {
+					const resolved = await this.#resolveProject(loose(c));
+					if ("response" in resolved) return resolved.response;
+					return c.json({ boards: [...this.#boards].map(([id, board]) => ({
+						id,
+						title: board.title,
+						initialPhase: board.initialPhase,
+						phases: Object.entries(board.phases).map(([phaseId, phase]) => ({
+							id: phaseId,
+							title: phase.title,
+							kind: phase.kind,
+							...phase.kind === "working" ? { role: phase.role } : {},
+							transitions: (board.transitions[phaseId] ?? []).map(({ outcome, to }) => ({
+								outcome,
+								to
+							}))
+						}))
+					})) });
+				}
+			}),
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.workItemList.path, {
+				method: FACTORY_ROUTE_CONTRACTS.workItemList.method,
+				requiresAuth: false,
+				handler: async (c) => {
+					const resolved = await this.#resolveProject(loose(c));
+					if ("response" in resolved) return resolved.response;
+					await workItems.ensureReady();
+					const items = await workItems.list({
+						orgId: resolved.orgId,
+						factoryProjectId: resolved.factoryProjectId
+					});
+					return c.json({
+						workItems: items.map(toWireWorkItem),
+						runningSessionIds: sessionIdsWhere(items, (sessionId) => liveSessions.isRunning(sessionId)),
+						parkedSessionIds: sessionIdsWhere(items, (sessionId) => liveSessions.parked(sessionId) !== void 0)
+					});
+				}
+			}),
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.metricsGet.path, {
+				method: FACTORY_ROUTE_CONTRACTS.metricsGet.method,
+				requiresAuth: false,
+				handler: async (c) => {
+					const context = loose(c);
+					const resolved = await this.#resolveProject(context);
+					if ("response" in resolved) return resolved.response;
+					const query = FACTORY_ROUTE_CONTRACTS.metricsGet.querySchema.safeParse({
+						from: context.req.query("from"),
+						to: context.req.query("to")
+					});
+					if (!query.success) return c.json({ error: "invalid_metrics_range" }, 400);
+					const { windowStart, windowEnd } = parseMetricsRange(query.data.from, query.data.to, /* @__PURE__ */ new Date());
+					await workItems.ensureReady();
+					const items = await workItems.list({
+						orgId: resolved.orgId,
+						factoryProjectId: resolved.factoryProjectId
+					});
+					return c.json({ metrics: computeFactoryMetrics(items, {
+						windowStart,
+						windowEnd
+					}) });
+				}
+			}),
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.healthThresholdsGet.path, {
+				method: FACTORY_ROUTE_CONTRACTS.healthThresholdsGet.method,
+				requiresAuth: false,
+				handler: async (c) => {
+					const resolved = await this.#resolveProject(loose(c));
+					if ("response" in resolved) return resolved.response;
+					await queueHealth.ensureReady();
+					const stored = await queueHealth.getConfig(resolved.orgId, resolved.factoryProjectId);
+					return c.json({ thresholds: thresholdsOrDefault(stored) });
+				}
+			}),
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.decisionList.path, {
+				method: FACTORY_ROUTE_CONTRACTS.decisionList.method,
+				requiresAuth: false,
+				handler: async (c) => {
+					const context = loose(c);
+					const resolved = await this.#resolveProject(context);
+					if ("response" in resolved) return resolved.response;
+					const query = FACTORY_ROUTE_CONTRACTS.decisionList.querySchema.safeParse({
+						statuses: context.req.query("statuses"),
+						before: context.req.query("before"),
+						limit: context.req.query("limit")
+					});
+					if (!query.success) {
+						const field = query.error.issues[0]?.path[0];
+						return c.json({ error: field === "before" ? "invalid_cursor" : "invalid_decision_query" }, 400);
+					}
+					await workItems.ensureReady();
+					const page = await workItems.listDeferredDecisionPage({
+						orgId: resolved.orgId,
+						factoryProjectId: resolved.factoryProjectId,
+						statuses: query.data.statuses,
+						before: query.data.before,
+						limit: query.data.limit
+					});
+					const last = page.decisions.at(-1);
+					const overtaken = await overtakenDecisionIds(workItems, this.#boards, resolved, page.decisions.filter((decision) => decision.status === "failed"));
+					return c.json({
+						decisions: page.decisions.map((decision) => decisionSummary(this.#boards, decision, overtaken.has(decision.id))),
+						...page.hasMore && last ? { nextCursor: encodeDecisionCursor(last) } : {}
+					});
+				}
+			}),
+			...buildAttentionRoutes({
+				workItems,
+				boards: this.#boards,
+				comments: this.deps.comments,
+				liveSessions,
+				resolveProject: (context) => this.#resolveProject(loose(context))
+			}),
+			...buildSupervisorRoutes({
+				workItems,
+				boards: this.#boards,
+				resolveProject: (context) => this.#resolveProject(loose(context))
+			}),
+			this.#proposalRoute({
+				verb: "approve",
+				settle: workItems.approveDeferredDecision.bind(workItems)
+			}),
+			this.#proposalRoute({
+				verb: "dismiss",
+				settle: workItems.dismissDeferredDecision.bind(workItems)
+			}),
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.decisionRetry.path, {
+				method: FACTORY_ROUTE_CONTRACTS.decisionRetry.method,
+				requiresAuth: false,
+				handler: async (c) => {
+					const context = loose(c);
+					const resolved = await this.#resolveProject(context);
+					if ("response" in resolved) return resolved.response;
+					const parsedPath = FACTORY_ROUTE_CONTRACTS.decisionRetry.pathSchema.safeParse({
+						id: resolved.factoryProjectId,
+						decisionId: context.req.param("decisionId")
+					});
+					if (!parsedPath.success) return c.json({ error: "invalid_decision_id" }, 422);
+					const { decisionId } = parsedPath.data;
+					await workItems.ensureReady();
+					const current = await workItems.getDeferredDecision(resolved.orgId, resolved.factoryProjectId, decisionId);
+					if (!current || !decisionRetryable(current, false)) return c.json({ error: "decision_not_retryable" }, 409);
+					if ((await overtakenDecisionIds(workItems, this.#boards, resolved, [current])).size > 0) return c.json({ error: "decision_not_retryable" }, 409);
+					const decision = await workItems.retryDeferredDecision(resolved.orgId, resolved.factoryProjectId, decisionId, /* @__PURE__ */ new Date());
+					if (!decision) return c.json({ error: "decision_not_retryable" }, 409);
+					return c.json({ decision: decisionSummary(this.#boards, decision) });
+				}
+			}),
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.workItemCreate.path, {
+				method: FACTORY_ROUTE_CONTRACTS.workItemCreate.method,
+				requiresAuth: false,
+				handler: async (c) => {
+					const resolved = await this.#resolveProject(loose(c));
+					if ("response" in resolved) return resolved.response;
+					const body = await readJson(loose(c));
+					if (body === void 0) return c.json({ error: "Invalid JSON body" }, 400);
+					const input = parseCreateWorkItem(body);
+					if (!input) return c.json({ error: "invalid_work_item" }, 400);
+					const boardId = input.board ?? (input.externalSource?.type === "pull-request" ? "review" : "work");
+					const board = this.#boards.get(boardId);
+					if (!board) return c.json({
+						error: "invalid_board",
+						message: `Board '${boardId}' is not installed.`
+					}, 422);
+					const initialStages = input.stages ?? [board.initialPhase];
+					if (initialStages.length !== 1 || initialStages[0] !== board.initialPhase) return c.json({
+						error: "governed_transition_required",
+						message: `New work items must enter through the '${board.initialPhase}' phase of board '${boardId}'.`
+					}, 409);
+					await workItems.ensureReady();
+					try {
+						const result = await workItems.upsert({
+							orgId: resolved.orgId,
+							userId: resolved.userId,
+							factoryProjectId: resolved.factoryProjectId,
+							input: {
+								...input,
+								board: boardId,
+								stages: initialStages
+							},
+							reuseMode: "non-stage"
+						});
+						let item = result.item;
+						if (result.created) {
+							if (!transitionService) {
+								await workItems.delete({
+									orgId: resolved.orgId,
+									id: item.id
+								});
+								return c.json({ error: "factory_transitions_unavailable" }, 503);
+							}
+							const entered = await transitionService.transition({
+								orgId: resolved.orgId,
+								factoryProjectId: resolved.factoryProjectId,
+								workItemId: item.id,
+								board: boardId,
+								stage: board.initialPhase,
+								expectedRevision: item.revision,
+								actor: {
+									type: "human",
+									id: resolved.userId
+								},
+								...auditRequestOrigin(loose(c)),
+								ingress: {
+									type: "human",
+									identity: `work-item:${item.id}:initial-entry`
+								},
+								cause: "work_item_created",
+								initialEntry: true
+							});
+							if (entered.status === "rejected") {
+								await workItems.delete({
+									orgId: resolved.orgId,
+									id: item.id
+								});
+								return c.json({
+									status: "rejected",
+									code: entered.code,
+									reason: entered.reason
+								}, 422);
+							}
+							item = await workItems.getForProject(resolved.orgId, resolved.factoryProjectId, item.id) ?? item;
+							await audit.emit({
+								context: loose(c),
+								input: {
+									action: "factory.work_item.created",
+									factoryProjectId: resolved.factoryProjectId,
+									targets: [{
+										type: "work_item",
+										id: item.id,
+										name: item.title
+									}],
+									metadata: {
+										externalSource: item.externalSource,
+										stages: item.stages
+									}
+								}
+							});
+						} else {
+							const { stages: _stages, sessions: _sessions, ...boundedPatch } = input;
+							await this.#auditWorkItemPatch({
+								context: loose(c),
+								item,
+								patch: boundedPatch
+							});
+						}
+						return c.json({ workItem: toWireWorkItem(item) });
+					} catch (error) {
+						if (error instanceof WorkItemRelationError) return c.json({
+							error: error.code,
+							message: error.message
+						}, 400);
+						throw error;
+					}
+				}
+			}),
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.workItemTransition.path, {
+				method: FACTORY_ROUTE_CONTRACTS.workItemTransition.method,
+				requiresAuth: false,
+				handler: async (c) => {
+					const resolved = await this.#resolveProject(loose(c));
+					if ("response" in resolved) return resolved.response;
+					const context = loose(c);
+					const parsedPath = FACTORY_ROUTE_CONTRACTS.workItemTransition.pathSchema.safeParse({
+						id: resolved.factoryProjectId,
+						workItemId: context.req.param("workItemId")
+					});
+					if (!parsedPath.success) return c.json({ error: "Work item not found" }, 404);
+					const { workItemId } = parsedPath.data;
+					const parsed = parseTransitionBody(await readJson(context));
+					if (!parsed) return c.json({ error: "invalid_transition_request" }, 400);
+					if (!transitionService) return c.json({ error: "factory_transition_unavailable" }, 503);
+					await workItems.ensureReady();
+					const result = await transitionService.transition({
+						...parsed,
+						orgId: resolved.orgId,
+						factoryProjectId: resolved.factoryProjectId,
+						workItemId,
+						actor: {
+							type: "human",
+							id: resolved.userId
+						},
+						...auditRequestOrigin(loose(c)),
+						ingress: {
+							...parsed.ingress,
+							identity: `human:${resolved.userId}:${parsed.ingress.identity}`
+						}
+					});
+					if (result.status === "accepted") return c.json({ result });
+					return c.json({ result }, result.code === "stale" ? 409 : 422);
+				}
+			}),
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.workItemStart.path, {
+				method: FACTORY_ROUTE_CONTRACTS.workItemStart.method,
+				requiresAuth: false,
+				handler: async (c) => {
+					const resolved = await this.#resolveProject(loose(c));
+					if ("response" in resolved) return resolved.response;
+					if (!startCoordinator) return c.json({ error: "factory_start_unavailable" }, 503);
+					const input = parseStartBody(await readJson(loose(c)), resolved, resolved.factoryProjectId, resolved.modelScope);
+					if (!input) return c.json({ error: "invalid_factory_start" }, 400);
+					input.requestContext = loose(c).get("requestContext");
+					input.defaultModelId = resolved.defaultModelId ?? void 0;
+					await workItems.ensureReady();
+					let prepared;
+					try {
+						prepared = await startCoordinator.prepare(input);
+					} catch (error) {
+						if (error instanceof FactoryStartTransitionError) return c.json({ result: error.result }, error.result.code === "stale" ? 409 : 422);
+						if (error instanceof WorkItemRepositoryError) return c.json({
+							error: error.code,
+							message: error.message,
+							candidates: error.candidates
+						}, 409);
+						throw error;
+					}
+					return c.json({ prepared }, 202);
+				}
+			}),
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.workItemUpdate.path, {
+				method: FACTORY_ROUTE_CONTRACTS.workItemUpdate.method,
+				requiresAuth: false,
+				handler: async (c) => {
+					const tenant = await this.#resolveTenant(loose(c));
+					if ("response" in tenant) return tenant.response;
+					const context = loose(c);
+					const parsedPath = FACTORY_ROUTE_CONTRACTS.workItemUpdate.pathSchema.safeParse({ id: context.req.param("id") });
+					if (!parsedPath.success) return c.json({ error: "Work item not found" }, 404);
+					const { id } = parsedPath.data;
+					const body = await readJson(context);
+					if (body === void 0) return c.json({ error: "Invalid JSON body" }, 400);
+					const patch = parseUpdateWorkItem(body);
+					if (!patch) return c.json({ error: "invalid_work_item_patch" }, 400);
+					await workItems.ensureReady();
+					const existing = await workItems.get({
+						orgId: tenant.orgId,
+						id
+					});
+					if (!existing) return c.json({ error: "Work item not found" }, 404);
+					if (patch.board !== void 0) {
+						const board = this.#boards.get(patch.board);
+						const stage = patch.stages?.length === 1 ? patch.stages[0] : void 0;
+						if (existing.board !== null) return c.json({ error: "board_already_assigned" }, 409);
+						if (!board) return c.json({ error: "board_not_installed" }, 400);
+						if (!stage || !Object.prototype.hasOwnProperty.call(board.phases, stage)) return c.json({ error: "invalid_board_migration_phase" }, 400);
+					} else if (patch.stages !== void 0) return c.json({
+						error: "governed_transition_required",
+						message: "Use the Factory transition endpoint to move stages."
+					}, 409);
+					try {
+						const updated = await workItems.update({
+							orgId: tenant.orgId,
+							id,
+							userId: tenant.userId,
+							patch,
+							...patch.board !== void 0 ? {
+								expectedRevision: existing.revision,
+								expectedBoard: null
+							} : {}
+						});
+						if (!updated) return c.json({ error: "Work item not found" }, 404);
+						await this.#auditWorkItemPatch({
+							context: loose(c),
+							item: updated.item,
+							patch
+						});
+						return c.json({ workItem: toWireWorkItem(updated.item) });
+					} catch (error) {
+						if (error instanceof WorkItemRelationError) return c.json({
+							error: error.code,
+							message: error.message
+						}, 400);
+						if (error instanceof WorkItemUpdateConflictError) return c.json({ error: error.reason === "board" ? "board_already_assigned" : error.code }, 409);
+						throw error;
+					}
+				}
+			}),
+			registerApiRoute(FACTORY_ROUTE_CONTRACTS.workItemDelete.path, {
+				method: FACTORY_ROUTE_CONTRACTS.workItemDelete.method,
+				requiresAuth: false,
+				handler: async (c) => {
+					const tenant = await this.#resolveTenant(loose(c));
+					if ("response" in tenant) return tenant.response;
+					const context = loose(c);
+					const parsedPath = FACTORY_ROUTE_CONTRACTS.workItemDelete.pathSchema.safeParse({ id: context.req.param("id") });
+					if (!parsedPath.success) return c.json({ error: "Work item not found" }, 404);
+					const { id } = parsedPath.data;
+					await workItems.ensureReady();
+					const deleted = await workItems.delete({
+						orgId: tenant.orgId,
+						id
+					});
+					if (!deleted) return c.json({ error: "Work item not found" }, 404);
+					await audit.emit({
+						context: loose(c),
+						input: {
+							action: "factory.work_item.deleted",
+							factoryProjectId: deleted.factoryProjectId,
+							targets: [{
+								type: "work_item",
+								id: deleted.id,
+								name: deleted.title
+							}]
+						}
+					});
+					return c.json({ ok: true });
+				}
+			})
+		];
+	}
+};
+//#endregion
+export { WorkItemRoutes, parseCreateWorkItem, parseUpdateWorkItem };
+
+//# sourceMappingURL=work-items.js.map