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

package/dist/rules/transition-service.js

@@ -1,474 +1,203 @@
-// src/rules/transition-service.ts
+import { resolveFactoryStageRules } from "./resolve.js";
+import { FACTORY_RULE_STAGES, factoryRuleSourceForWorkItem } from "./types.js";
+import { validateFactoryRuleDecision, validateFactoryRuleDecisions } from "./validation.js";
 import { randomUUID } from "crypto";
-
-// src/rules/resolve.ts
-function resolveFactoryStageRules(rules, input) {
-  if (input.fromStage === input.toStage && !input.initialEntry) return [];
-  const boardRules = rules[input.board];
-  const resolved = [];
-  const onExit = input.initialEntry ? void 0 : boardRules[input.fromStage]?.[input.source]?.onExit;
-  if (onExit) resolved.push({ phase: "exit", handler: onExit });
-  const onEnter = boardRules[input.toStage]?.[input.source]?.onEnter;
-  if (onEnter) resolved.push({ phase: "enter", handler: onEnter });
-  return resolved;
-}
-
-// src/rules/types.ts
-var FACTORY_RULE_STAGES = ["intake", "triage", "planning", "execute", "review", "done", "canceled"];
-var FACTORY_RULE_BOARDS = ["work", "review"];
-function factoryRuleSourceForWorkItem(source) {
-  switch (source) {
-    case "github-issue":
-      return "issue";
-    case "github-pr":
-      return "pullRequest";
-    case "linear-issue":
-      return "linearIssue";
-    case "manual":
-      return "manual";
-  }
-}
-
-// src/rules/validation.ts
-var MAX_FACTORY_RULE_CAUSAL_DEPTH = 8;
-var MAX_IDEMPOTENCY_KEY_LENGTH = 256;
-var MAX_REASON_LENGTH = 512;
-var MAX_TITLE_LENGTH = 512;
-var MAX_MESSAGE_LENGTH = 8192;
-var MAX_ARGUMENTS_LENGTH = 4096;
-var MAX_ROLE_LENGTH = 32;
-var MAX_SKILL_NAME_LENGTH = 128;
-var MAX_SOURCE_KEY_LENGTH = 256;
-var MAX_URL_LENGTH = 2048;
-var MAX_METADATA_JSON_LENGTH = 16384;
-var MAX_JSON_DEPTH = 8;
-var MAX_JSON_COLLECTION_SIZE = 100;
-var IDENTIFIER_RE = /^[a-z0-9][a-z0-9_-]*$/i;
-var SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var SENSITIVE_KEY_RE = /(?:authorization|cookie|credential|password|secret|token)/i;
-var WORK_ITEM_SOURCES = ["github-issue", "github-pr", "linear-issue", "manual"];
-var REJECTION_CODES = [
-  "forbidden",
-  "invalid_transition",
-  "missing_binding",
-  "stale",
-  "timeout",
-  "rule_error",
-  "causal_depth_exceeded",
-  "repeated_transition"
-];
-var FactoryRuleValidationError = class extends Error {
-  code = "invalid_factory_rule";
-  constructor(message) {
-    super(message);
-    this.name = "FactoryRuleValidationError";
-  }
-};
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function assertExactKeys(value, keys, label) {
-  const allowed = new Set(keys);
-  if (Object.keys(value).some((key) => !allowed.has(key))) {
-    throw new FactoryRuleValidationError(`${label} contains an unsupported field.`);
-  }
-}
-function boundedString(value, label, max, pattern) {
-  if (typeof value !== "string") throw new FactoryRuleValidationError(`${label} must be a string.`);
-  const normalized = value.trim();
-  if (normalized.length === 0 || normalized.length > max || pattern && !pattern.test(normalized)) {
-    throw new FactoryRuleValidationError(`${label} is invalid.`);
-  }
-  return normalized;
-}
-function optionalBoundedString(value, label, max) {
-  if (value === void 0) return void 0;
-  return boundedString(value, label, max);
-}
-function enumValue(value, allowed, label) {
-  if (typeof value !== "string" || !allowed.includes(value)) {
-    throw new FactoryRuleValidationError(`${label} is invalid.`);
-  }
-  return value;
-}
-function normalizeFactoryRuleJsonValue(value, depth = 0, seen = /* @__PURE__ */ new Set()) {
-  if (value === null || typeof value === "boolean" || typeof value === "string") return value;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) throw new FactoryRuleValidationError("Rule metadata must contain finite numbers.");
-    return value;
-  }
-  if (depth >= MAX_JSON_DEPTH || typeof value !== "object" && !Array.isArray(value)) {
-    throw new FactoryRuleValidationError("Rule metadata is not bounded JSON.");
-  }
-  if (seen.has(value)) throw new FactoryRuleValidationError("Rule metadata must not contain cycles.");
-  seen.add(value);
-  try {
-    if (Array.isArray(value)) {
-      if (value.length > MAX_JSON_COLLECTION_SIZE) {
-        throw new FactoryRuleValidationError("Rule metadata contains too many entries.");
-      }
-      return value.map((entry) => normalizeFactoryRuleJsonValue(entry, depth + 1, seen));
-    }
-    if (!isPlainObject(value)) throw new FactoryRuleValidationError("Rule metadata must use plain objects.");
-    const entries = Object.entries(value);
-    if (entries.length > MAX_JSON_COLLECTION_SIZE) {
-      throw new FactoryRuleValidationError("Rule metadata contains too many fields.");
-    }
-    const sanitized = {};
-    for (const [key, entry] of entries) {
-      const normalizedKey = boundedString(key, "Rule metadata key", 128, IDENTIFIER_RE);
-      sanitized[normalizedKey] = SENSITIVE_KEY_RE.test(normalizedKey) ? "[REDACTED]" : normalizeFactoryRuleJsonValue(entry, depth + 1, seen);
-    }
-    return sanitized;
-  } finally {
-    seen.delete(value);
-  }
-}
-function sanitizeMetadata(value) {
-  if (value === void 0) return void 0;
-  const sanitized = normalizeFactoryRuleJsonValue(value);
-  if (!isPlainObject(sanitized)) throw new FactoryRuleValidationError("Rule metadata must be an object.");
-  if (JSON.stringify(sanitized).length > MAX_METADATA_JSON_LENGTH) {
-    throw new FactoryRuleValidationError("Rule metadata is too large.");
-  }
-  return sanitized;
-}
-function commonCommitFields(value) {
-  return {
-    idempotencyKey: boundedString(value.idempotencyKey, "Factory decision idempotencyKey", MAX_IDEMPOTENCY_KEY_LENGTH)
-  };
-}
-function validateFactoryRuleDecision(value, causalDepth = 0) {
-  if (causalDepth > MAX_FACTORY_RULE_CAUSAL_DEPTH) {
-    throw new FactoryRuleValidationError("Factory rule causal depth exceeded.");
-  }
-  if (!isPlainObject(value)) throw new FactoryRuleValidationError("Factory rule decision must be an object.");
-  const type = value.type;
-  if (typeof type !== "string") throw new FactoryRuleValidationError("Factory rule decision type is required.");
-  switch (type) {
-    case "reject": {
-      assertExactKeys(value, ["type", "code", "reason"], "Factory reject decision");
-      return {
-        type,
-        code: enumValue(value.code, REJECTION_CODES, "Factory rejection code"),
-        reason: boundedString(value.reason, "Factory rejection reason", MAX_REASON_LENGTH)
-      };
-    }
-    case "transition": {
-      assertExactKeys(value, ["type", "idempotencyKey", "board", "stage"], "Factory transition decision");
-      return {
-        type,
-        ...commonCommitFields(value),
-        board: enumValue(value.board, FACTORY_RULE_BOARDS, "Factory transition board"),
-        stage: enumValue(value.stage, FACTORY_RULE_STAGES, "Factory transition stage")
-      };
-    }
-    case "upsertLinkedWorkItem": {
-      assertExactKeys(
-        value,
-        ["type", "idempotencyKey", "board", "source", "sourceKey", "title", "url", "stage", "metadata"],
-        "Factory linked work item decision"
-      );
-      const url = value.url;
-      if (url !== null && (typeof url !== "string" || url.length > MAX_URL_LENGTH || !/^https?:\/\//.test(url))) {
-        throw new FactoryRuleValidationError("Factory linked work item URL is invalid.");
-      }
-      const metadata = sanitizeMetadata(value.metadata);
-      return {
-        type,
-        ...commonCommitFields(value),
-        board: enumValue(value.board, FACTORY_RULE_BOARDS, "Factory linked work item board"),
-        source: enumValue(value.source, WORK_ITEM_SOURCES, "Factory linked work item source"),
-        sourceKey: boundedString(value.sourceKey, "Factory linked work item sourceKey", MAX_SOURCE_KEY_LENGTH),
-        title: boundedString(value.title, "Factory linked work item title", MAX_TITLE_LENGTH),
-        url,
-        stage: enumValue(value.stage, FACTORY_RULE_STAGES, "Factory linked work item stage"),
-        ...metadata ? { metadata } : {}
-      };
-    }
-    case "invokeSkill": {
-      assertExactKeys(
-        value,
-        ["type", "idempotencyKey", "role", "skillName", "arguments", "precedingMessage"],
-        "Factory invoke skill decision"
-      );
-      const args = optionalBoundedString(value.arguments, "Factory skill arguments", MAX_ARGUMENTS_LENGTH);
-      const precedingMessage = optionalBoundedString(
-        value.precedingMessage,
-        "Factory skill preceding message",
-        MAX_MESSAGE_LENGTH
-      );
-      return {
-        type,
-        ...commonCommitFields(value),
-        role: boundedString(value.role, "Factory skill role", MAX_ROLE_LENGTH, IDENTIFIER_RE),
-        skillName: boundedString(value.skillName, "Factory skill name", MAX_SKILL_NAME_LENGTH, SKILL_NAME_RE),
-        ...args ? { arguments: args } : {},
-        ...precedingMessage ? { precedingMessage } : {}
-      };
-    }
-    case "sendMessage": {
-      assertExactKeys(
-        value,
-        ["type", "idempotencyKey", "role", "message", "priority", "idleBehavior", "prepareBinding"],
-        "Factory send message decision"
-      );
-      const priority = value.priority === void 0 ? void 0 : enumValue(value.priority, ["medium", "high", "urgent"], "Factory message priority");
-      const idleBehavior = value.idleBehavior === void 0 ? void 0 : enumValue(value.idleBehavior, ["persist", "wake"], "Factory message idle behavior");
-      if (value.prepareBinding !== void 0 && typeof value.prepareBinding !== "boolean") {
-        throw new FactoryRuleValidationError("Factory message prepareBinding must be a boolean.");
-      }
-      return {
-        type,
-        ...commonCommitFields(value),
-        role: boundedString(value.role, "Factory message role", MAX_ROLE_LENGTH, IDENTIFIER_RE),
-        message: boundedString(value.message, "Factory message", MAX_MESSAGE_LENGTH),
-        ...priority ? { priority } : {},
-        ...idleBehavior ? { idleBehavior } : {},
-        ...value.prepareBinding === true ? { prepareBinding: true } : {}
-      };
-    }
-    case "notify": {
-      assertExactKeys(value, ["type", "idempotencyKey", "title", "body", "level"], "Factory notify decision");
-      const body = optionalBoundedString(value.body, "Factory notification body", MAX_MESSAGE_LENGTH);
-      const level = value.level === void 0 ? void 0 : enumValue(value.level, ["info", "warning", "error"], "Factory notification level");
-      return {
-        type,
-        ...commonCommitFields(value),
-        title: boundedString(value.title, "Factory notification title", MAX_TITLE_LENGTH),
-        ...body ? { body } : {},
-        ...level ? { level } : {}
-      };
-    }
-    default:
-      throw new FactoryRuleValidationError("Factory rule decision type is unsupported.");
-  }
-}
-function validateFactoryRuleDecisions(values, causalDepth = 0) {
-  if (values.length > MAX_JSON_COLLECTION_SIZE) {
-    throw new FactoryRuleValidationError("Factory rule produced too many decisions.");
-  }
-  const decisions = [];
-  for (const value of values) {
-    const decision = validateFactoryRuleDecision(value, causalDepth);
-    if (decision.type === "reject") {
-      throw new FactoryRuleValidationError("A rejection cannot be persisted with commit decisions.");
-    }
-    decisions.push(decision);
-  }
-  const keys = decisions.map((decision) => decision.idempotencyKey);
-  if (new Set(keys).size !== keys.length) {
-    throw new FactoryRuleValidationError("Factory decisions require unique idempotency keys.");
-  }
-  return decisions;
-}
-
-// src/rules/transition-service.ts
-var RULE_TIMEOUT_MS = 5e3;
-var MAX_REJECTION_REASON = 512;
+//#region src/rules/transition-service.ts
+const RULE_TIMEOUT_MS = 5e3;
+const MAX_REJECTION_REASON = 512;
 function rejection(transitionId, itemId, code, reason) {
-  return { status: "rejected", transitionId, itemId, code, reason: reason.slice(0, MAX_REJECTION_REASON) };
+	return {
+		status: "rejected",
+		transitionId,
+		itemId,
+		code,
+		reason: reason.slice(0, MAX_REJECTION_REASON)
+	};
 }
 function actorId(actor) {
-  switch (actor.type) {
-    case "human":
-    case "system":
-      return actor.id;
-    case "agent":
-      return `agent:${actor.bindingId}`;
-    case "github":
-      return `github:${actor.login}`;
-  }
+	switch (actor.type) {
+		case "human":
+		case "system": return actor.id;
+		case "agent": return `agent:${actor.bindingId}`;
+		case "github": return `github:${actor.login}`;
+	}
 }
 function currentStage(stages) {
-  if (stages.length !== 1) return void 0;
-  const stage = stages[0];
-  return FACTORY_RULE_STAGES.includes(stage) ? stage : void 0;
+	if (stages.length !== 1) return void 0;
+	const stage = stages[0];
+	return FACTORY_RULE_STAGES.includes(stage) ? stage : void 0;
 }
 function workItemSource(source) {
-  if (!source) return "manual";
-  if (source.integrationId === "linear") return "linear-issue";
-  return source.type === "pull-request" ? "github-pr" : "github-issue";
+	if (!source) return "manual";
+	if (source.integrationId === "linear") return "linear-issue";
+	return source.type === "pull-request" ? "github-pr" : "github-issue";
 }
 function roleForStage(board, stage) {
-  if (board === "review") return "review";
-  if (stage === "triage") return "triage";
-  if (stage === "planning") return "plan";
-  return "work";
+	if (board === "review") return "review";
+	if (stage === "triage") return "triage";
+	if (stage === "planning") return "plan";
+	return "work";
 }
 function stageTransitionMessage(fromStage, toStage) {
-  return `This work was moved from the ${fromStage} stage to the ${toStage} stage.`;
+	return `This work was moved from the ${fromStage} stage to the ${toStage} stage.`;
 }
 function ruleFailure(error) {
-  return {
-    code: "rule_error",
-    reason: error instanceof Error ? `Factory rule failed: ${error.message}` : "Factory rule failed."
-  };
+	return {
+		code: "rule_error",
+		reason: error instanceof Error ? `Factory rule failed: ${error.message}` : "Factory rule failed."
+	};
 }
 async function withRuleTimeout(operation, timeoutMs) {
-  let timer;
-  const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(new Error("FACTORY_RULE_TIMEOUT")), timeoutMs);
-  });
-  try {
-    return await Promise.race([operation, timeout]);
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
+	let timer;
+	const timeout = new Promise((_, reject) => {
+		timer = setTimeout(() => reject(/* @__PURE__ */ new Error("FACTORY_RULE_TIMEOUT")), timeoutMs);
+	});
+	try {
+		return await Promise.race([operation, timeout]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
 }
 var FactoryTransitionService = class {
-  #rules;
-  #storage;
-  #timeoutMs;
-  constructor(options) {
-    this.#rules = options.rules;
-    this.#storage = options.storage;
-    this.#timeoutMs = options.timeoutMs ?? RULE_TIMEOUT_MS;
-  }
-  get ruleSetVersion() {
-    return this.#rules.version;
-  }
-  async transition(request) {
-    const replay = await this.#storage.getTransitionResultByIngress(
-      request.orgId,
-      request.factoryProjectId,
-      request.ingress.identity
-    );
-    if (replay) return replay;
-    const transitionId = request.ingress.transitionId ?? randomUUID();
-    const item = await this.#storage.get({ orgId: request.orgId, id: request.workItemId });
-    if (!item) {
-      return this.#commitRejection(request, transitionId, "invalid_transition", "Work item not found.");
-    }
-    if (request.causalChain && request.causalChain.length > MAX_FACTORY_RULE_CAUSAL_DEPTH) {
-      return this.#commitRejection(
-        request,
-        transitionId,
-        "causal_depth_exceeded",
-        "Factory rule causal depth exceeded."
-      );
-    }
-    const itemSource = workItemSource(item.externalSource);
-    const source = factoryRuleSourceForWorkItem(itemSource);
-    if (request.board === "review" !== (source === "pullRequest")) {
-      return this.#commitRejection(
-        request,
-        transitionId,
-        "invalid_transition",
-        "The work item does not belong to the requested board."
-      );
-    }
-    const fromStage = currentStage(item.stages);
-    if (!fromStage) {
-      return this.#commitRejection(
-        request,
-        transitionId,
-        "invalid_transition",
-        "The work item does not have one canonical Factory stage."
-      );
-    }
-    const contextBase = {
-      tenant: { orgId: request.orgId, projectId: request.factoryProjectId },
-      actor: request.actor,
-      ingress: { type: request.ingress.type, id: request.ingress.identity },
-      cause: request.cause,
-      causalChain: request.causalChain ?? [],
-      ruleSetVersion: this.#rules.version,
-      item: {
-        id: item.id,
-        source: itemSource,
-        sourceKey: item.externalSource ? `${item.externalSource.integrationId}:${item.externalSource.type}:${item.externalSource.externalId}` : null,
-        parentWorkItemId: item.parentWorkItemId,
-        title: item.title,
-        url: item.externalSource?.url ?? null,
-        stages: [...item.stages]
-      },
-      board: request.board,
-      itemRevision: item.revision,
-      source,
-      fromStage,
-      toStage: request.stage
-    };
-    let evaluation;
-    try {
-      evaluation = await withRuleTimeout(
-        (async () => {
-          const decisions = [];
-          for (const rule of resolveFactoryStageRules(this.#rules, {
-            board: request.board,
-            source,
-            fromStage,
-            toStage: request.stage,
-            initialEntry: request.initialEntry
-          })) {
-            const context = Object.freeze({
-              ...contextBase,
-              stage: rule.phase === "exit" ? fromStage : request.stage
-            });
-            const raw = await rule.handler(context);
-            if (raw === void 0) continue;
-            const decision = validateFactoryRuleDecision(raw, context.causalChain.length);
-            if (decision.type === "reject") {
-              return { outcome: "rejected", code: decision.code, reason: decision.reason };
-            }
-            decisions.push(decision);
-          }
-          const validated = validateFactoryRuleDecisions(decisions);
-          if (request.actor.type === "human" && request.cause === "board_drag" && fromStage !== request.stage) {
-            const message = stageTransitionMessage(fromStage, request.stage);
-            const skill = validated.find((decision) => decision.type === "invokeSkill");
-            if (skill) {
-              skill.precedingMessage = message;
-            } else {
-              validated.unshift({
-                type: "sendMessage",
-                idempotencyKey: `factory-stage:${transitionId}`,
-                role: roleForStage(request.board, request.stage),
-                message,
-                priority: "urgent",
-                idleBehavior: "wake",
-                prepareBinding: true
-              });
-            }
-          }
-          return {
-            outcome: "accepted",
-            decisions: validateFactoryRuleDecisions(validated)
-          };
-        })(),
-        this.#timeoutMs
-      );
-    } catch (error) {
-      const failed = error instanceof Error && error.message === "FACTORY_RULE_TIMEOUT" ? { code: "timeout", reason: "Factory rule evaluation timed out." } : ruleFailure(error);
-      evaluation = { outcome: "rejected", ...failed };
-    }
-    return this.#commit(request, transitionId, evaluation);
-  }
-  async #commitRejection(request, transitionId, code, reason) {
-    return this.#commit(request, transitionId, { outcome: "rejected", code, reason });
-  }
-  async #commit(request, transitionId, evaluation) {
-    const committed = await this.#storage.commitTransition({
-      orgId: request.orgId,
-      factoryProjectId: request.factoryProjectId,
-      workItemId: request.workItemId,
-      expectedRevision: request.expectedRevision,
-      destinationStage: request.stage,
-      actorId: actorId(request.actor),
-      ingress: { identity: request.ingress.identity, triggerType: request.ingress.type, transitionId },
-      ruleSetVersion: this.#rules.version,
-      causalChain: [...request.causalChain ?? []],
-      evaluation
-    });
-    if (committed.status === "missing") {
-      return rejection(transitionId, request.workItemId, "invalid_transition", "Work item not found.");
-    }
-    return committed.result;
-  }
-};
-export {
-  FactoryTransitionService
+	#rules;
+	#storage;
+	#timeoutMs;
+	constructor(options) {
+		this.#rules = options.rules;
+		this.#storage = options.storage;
+		this.#timeoutMs = options.timeoutMs ?? RULE_TIMEOUT_MS;
+	}
+	get ruleSetVersion() {
+		return this.#rules.version;
+	}
+	async transition(request) {
+		const replay = await this.#storage.getTransitionResultByIngress(request.orgId, request.factoryProjectId, request.ingress.identity);
+		if (replay) return replay;
+		const transitionId = request.ingress.transitionId ?? randomUUID();
+		const item = await this.#storage.get({
+			orgId: request.orgId,
+			id: request.workItemId
+		});
+		if (!item) return this.#commitRejection(request, transitionId, "invalid_transition", "Work item not found.");
+		if (request.causalChain && request.causalChain.length > 8) return this.#commitRejection(request, transitionId, "causal_depth_exceeded", "Factory rule causal depth exceeded.");
+		const itemSource = workItemSource(item.externalSource);
+		const source = factoryRuleSourceForWorkItem(itemSource);
+		if (request.board === "review" !== (source === "pullRequest")) return this.#commitRejection(request, transitionId, "invalid_transition", "The work item does not belong to the requested board.");
+		const fromStage = currentStage(item.stages);
+		if (!fromStage) return this.#commitRejection(request, transitionId, "invalid_transition", "The work item does not have one canonical Factory stage.");
+		const contextBase = {
+			tenant: {
+				orgId: request.orgId,
+				projectId: request.factoryProjectId
+			},
+			actor: request.actor,
+			ingress: {
+				type: request.ingress.type,
+				id: request.ingress.identity
+			},
+			cause: request.cause,
+			causalChain: request.causalChain ?? [],
+			ruleSetVersion: this.#rules.version,
+			item: {
+				id: item.id,
+				source: itemSource,
+				sourceKey: item.externalSource ? `${item.externalSource.integrationId}:${item.externalSource.type}:${item.externalSource.externalId}` : null,
+				parentWorkItemId: item.parentWorkItemId,
+				title: item.title,
+				url: item.externalSource?.url ?? null,
+				stages: [...item.stages]
+			},
+			board: request.board,
+			itemRevision: item.revision,
+			source,
+			fromStage,
+			toStage: request.stage
+		};
+		let evaluation;
+		try {
+			evaluation = await withRuleTimeout((async () => {
+				const decisions = [];
+				for (const rule of resolveFactoryStageRules(this.#rules, {
+					board: request.board,
+					source,
+					fromStage,
+					toStage: request.stage,
+					initialEntry: request.initialEntry
+				})) {
+					const context = Object.freeze({
+						...contextBase,
+						stage: rule.phase === "exit" ? fromStage : request.stage
+					});
+					const raw = await rule.handler(context);
+					if (raw === void 0) continue;
+					const decision = validateFactoryRuleDecision(raw, context.causalChain.length);
+					if (decision.type === "reject") return {
+						outcome: "rejected",
+						code: decision.code,
+						reason: decision.reason
+					};
+					decisions.push(decision);
+				}
+				const validated = validateFactoryRuleDecisions(decisions);
+				if (request.actor.type === "human" && request.cause === "board_drag" && fromStage !== request.stage) {
+					const message = stageTransitionMessage(fromStage, request.stage);
+					const skill = validated.find((decision) => decision.type === "invokeSkill");
+					if (skill) skill.precedingMessage = message;
+					else validated.unshift({
+						type: "sendMessage",
+						idempotencyKey: `factory-stage:${transitionId}`,
+						role: roleForStage(request.board, request.stage),
+						message,
+						priority: "urgent",
+						idleBehavior: "wake",
+						prepareBinding: true
+					});
+				}
+				return {
+					outcome: "accepted",
+					decisions: validateFactoryRuleDecisions(validated)
+				};
+			})(), this.#timeoutMs);
+		} catch (error) {
+			evaluation = {
+				outcome: "rejected",
+				...error instanceof Error && error.message === "FACTORY_RULE_TIMEOUT" ? {
+					code: "timeout",
+					reason: "Factory rule evaluation timed out."
+				} : ruleFailure(error)
+			};
+		}
+		return this.#commit(request, transitionId, evaluation);
+	}
+	async #commitRejection(request, transitionId, code, reason) {
+		return this.#commit(request, transitionId, {
+			outcome: "rejected",
+			code,
+			reason
+		});
+	}
+	async #commit(request, transitionId, evaluation) {
+		const committed = await this.#storage.commitTransition({
+			orgId: request.orgId,
+			factoryProjectId: request.factoryProjectId,
+			workItemId: request.workItemId,
+			expectedRevision: request.expectedRevision,
+			destinationStage: request.stage,
+			actorId: actorId(request.actor),
+			ingress: {
+				identity: request.ingress.identity,
+				triggerType: request.ingress.type,
+				transitionId
+			},
+			ruleSetVersion: this.#rules.version,
+			causalChain: [...request.causalChain ?? []],
+			evaluation
+		});
+		if (committed.status === "missing") return rejection(transitionId, request.workItemId, "invalid_transition", "Work item not found.");
+		return committed.result;
+	}
 };
+//#endregion
+export { FactoryTransitionService };
+
 //# sourceMappingURL=transition-service.js.map