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

package/dist/rules/dispatcher.js

@@ -1,701 +1,456 @@
-// src/rules/dispatcher.ts
+import { FACTORY_RULE_STAGES } from "./types.js";
+import { validateFactoryRuleDecision } from "./validation.js";
+import { resolveSkillInvocation } from "../skills/service.js";
 import { randomUUID } from "crypto";
 import { RequestContext } from "@mastra/core/request-context";
-
-// src/skills/service.ts
-import { formatSkillActivation } from "@mastra/core/workspace";
-var SkillInvocationError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "SkillInvocationError";
-    this.code = code;
-  }
-};
-function escapeSkillBoundary(value) {
-  return value.replaceAll("</skill>", "&lt;/skill&gt;");
-}
-async function resolveSkillInvocation(controller, input) {
-  const session = await controller.getSessionByResource(input.resourceId, input.scope);
-  if (!session) throw new SkillInvocationError("session_not_found", "Agent controller session not found.");
-  const skills = session.getWorkspace().skills;
-  await skills?.maybeRefresh();
-  const skill = await skills?.get(input.name);
-  if (!skill || skill["user-invocable"] === false) {
-    throw new SkillInvocationError("skill_not_found", `Skill not found: ${input.name}.`);
-  }
-  const args = input.arguments?.trim();
-  const content = `${formatSkillActivation(skill)}${args ? `
-
-ARGUMENTS: ${args}` : ""}`.trim();
-  return {
-    session,
-    skillName: skill.name,
-    message: `<skill name="${skill.name}">
-${escapeSkillBoundary(content)}
-</skill>`
-  };
-}
-
-// src/rules/types.ts
-var FACTORY_RULE_STAGES = ["intake", "triage", "planning", "execute", "review", "done", "canceled"];
-var FACTORY_RULE_BOARDS = ["work", "review"];
-
-// 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.");
-  }
-}
-
-// src/rules/dispatcher.ts
-var LEASE_MS = 3e4;
-var POLL_MS = 1e3;
-var BATCH_SIZE = 10;
-var MAX_ATTEMPTS = 5;
-var MAX_ERROR_LENGTH = 512;
-var MAX_BACKOFF_MS = 6e4;
+//#region src/rules/dispatcher.ts
+const LEASE_MS = 3e4;
+const POLL_MS = 1e3;
+const BATCH_SIZE = 10;
+const MAX_ATTEMPTS = 5;
+const MAX_ERROR_LENGTH = 512;
+const MAX_BACKOFF_MS = 6e4;
 function sanitizeDispatchError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return message.replace(/\b(?:bearer|token|api[-_ ]?key|authorization)\s*[:=]?\s*[^\s,;]+/gi, "[redacted]").slice(0, MAX_ERROR_LENGTH);
+	return (error instanceof Error ? error.message : String(error)).replace(/\b(?:bearer|token|api[-_ ]?key|authorization)\s*[:=]?\s*[^\s,;]+/gi, "[redacted]").slice(0, MAX_ERROR_LENGTH);
 }
 function retryAt(now, attempts) {
-  return new Date(now.getTime() + Math.min(1e3 * 2 ** Math.max(0, attempts - 1), MAX_BACKOFF_MS));
+	return new Date(now.getTime() + Math.min(1e3 * 2 ** Math.max(0, attempts - 1), MAX_BACKOFF_MS));
 }
 function externalSourceForDecision(decision) {
-  const [integrationId, type] = decision.source === "github-pr" ? ["github", "pull-request"] : decision.source === "github-issue" ? ["github", "issue"] : decision.source === "linear-issue" ? ["linear", "issue"] : ["factory", "manual"];
-  return { integrationId, type, externalId: decision.sourceKey, url: decision.url ?? void 0 };
+	const [integrationId, type] = decision.source === "github-pr" ? ["github", "pull-request"] : decision.source === "github-issue" ? ["github", "issue"] : decision.source === "linear-issue" ? ["linear", "issue"] : ["factory", "manual"];
+	return {
+		integrationId,
+		type,
+		externalId: decision.sourceKey,
+		url: decision.url ?? void 0
+	};
 }
 function deferredActor(record) {
-  const actor = record.actor;
-  if (actor?.type === "github" && typeof actor.login === "string" && typeof actor.trusted === "boolean" && typeof actor.factoryAuthored === "boolean") {
-    return {
-      type: "github",
-      login: actor.login,
-      trusted: actor.trusted,
-      factoryAuthored: actor.factoryAuthored
-    };
-  }
-  return { type: "system", id: "factory-rule-dispatcher" };
+	const actor = record.actor;
+	if (actor?.type === "github" && typeof actor.login === "string" && typeof actor.trusted === "boolean" && typeof actor.factoryAuthored === "boolean") return {
+		type: "github",
+		login: actor.login,
+		trusted: actor.trusted,
+		factoryAuthored: actor.factoryAuthored
+	};
+	return {
+		type: "system",
+		id: "factory-rule-dispatcher"
+	};
 }
 function leaseIdentity(record, ownerId) {
-  return { id: record.id, orgId: record.orgId, factoryProjectId: record.factoryProjectId, ownerId };
+	return {
+		id: record.id,
+		orgId: record.orgId,
+		factoryProjectId: record.factoryProjectId,
+		ownerId
+	};
 }
 async function awaitNotification(result, requireDelivery = false) {
-  await result.persisted;
-  if (!result.accepted) {
-    if (requireDelivery) throw new Error("Factory notification was persisted without agent delivery.");
-    return;
-  }
-  const accepted = await result.accepted;
-  if (!requireDelivery) return;
-  if (accepted.action === "wake") {
-    await accepted.output.consumeStream();
-    return;
-  }
-  if (accepted.action !== "deliver") {
-    throw new Error(`Factory notification did not reach the agent (${String(accepted.action)}).`);
-  }
+	await result.persisted;
+	if (!result.accepted) {
+		if (requireDelivery) throw new Error("Factory notification was persisted without agent delivery.");
+		return;
+	}
+	const accepted = await result.accepted;
+	if (!requireDelivery) return;
+	if (accepted.action === "wake") {
+		await accepted.output.consumeStream();
+		return;
+	}
+	if (accepted.action !== "deliver") throw new Error(`Factory notification did not reach the agent (${String(accepted.action)}).`);
 }
 var FactoryDecisionDispatcher = class {
-  #controller;
-  #transitionService;
-  #storage;
-  #ownerId;
-  #reconcileToolResults;
-  #prepareBinding;
-  #primeCredentials;
-  #timer;
-  #activeRun;
-  constructor(options) {
-    this.#controller = options.controller;
-    this.#transitionService = options.transitionService;
-    this.#storage = options.storage;
-    this.#ownerId = options.ownerId ?? `factory-dispatcher:${randomUUID()}`;
-    this.#reconcileToolResults = options.reconcileToolResults;
-    this.#prepareBinding = options.prepareBinding;
-    this.#primeCredentials = options.primeCredentials;
-  }
-  start() {
-    if (this.#timer) return;
-    void this.#tick();
-    this.#timer = setInterval(() => void this.#tick(), POLL_MS);
-    this.#timer.unref?.();
-  }
-  async stop() {
-    if (this.#timer) clearInterval(this.#timer);
-    this.#timer = void 0;
-    await this.#activeRun;
-  }
-  async runOnce(now = /* @__PURE__ */ new Date()) {
-    await this.#reconcileToolResults?.();
-    const leaseExpiresAt = new Date(now.getTime() + LEASE_MS);
-    const [decisions, starts] = await Promise.all([
-      this.#storage.claimDeferredDecisions({
-        ownerId: this.#ownerId,
-        now,
-        leaseExpiresAt,
-        limit: BATCH_SIZE
-      }),
-      this.#storage.claimPendingStarts({
-        ownerId: this.#ownerId,
-        now,
-        leaseExpiresAt,
-        limit: BATCH_SIZE
-      })
-    ]);
-    await Promise.all([
-      ...decisions.map((decision) => this.#dispatchDecision(decision, now)),
-      ...starts.map((start) => this.#dispatchPendingStart(start, now))
-    ]);
-  }
-  async #tick() {
-    if (this.#activeRun) return;
-    this.#activeRun = this.runOnce().catch((error) => {
-      console.error("Factory decision dispatch cycle failed", sanitizeDispatchError(error));
-    });
-    try {
-      await this.#activeRun;
-    } finally {
-      this.#activeRun = void 0;
-    }
-  }
-  async #dispatchDecision(record, now) {
-    try {
-      const decision = validateFactoryRuleDecision(record.decision, record.causalChain.length);
-      if (decision.type === "reject") throw new Error("Deferred Factory decisions cannot reject.");
-      await this.#withLease(
-        async (leaseExpiresAt) => this.#storage.renewDeferredDecisionLease(leaseIdentity(record, this.#ownerId), leaseExpiresAt),
-        async () => this.#executeDecision(record, decision)
-      );
-      const completed = await this.#storage.completeDeferredDecision(leaseIdentity(record, this.#ownerId), /* @__PURE__ */ new Date());
-      if (!completed) throw new Error("Factory decision lease was lost before completion.");
-    } catch (error) {
-      const terminal = record.attempts >= MAX_ATTEMPTS;
-      await this.#storage.failDeferredDecision({
-        ...leaseIdentity(record, this.#ownerId),
-        now: /* @__PURE__ */ new Date(),
-        availableAt: retryAt(now, record.attempts),
-        lastError: sanitizeDispatchError(error),
-        terminal
-      });
-    }
-  }
-  async #executeDecision(record, decision) {
-    const nextChain = [
-      ...record.causalChain,
-      { ingressId: record.idempotencyKey, decisionType: decision.type }
-    ];
-    if (nextChain.length > MAX_FACTORY_RULE_CAUSAL_DEPTH) throw new Error("Factory rule causal depth exceeded.");
-    switch (decision.type) {
-      case "transition": {
-        const item = await this.#requireItem(record);
-        const result = await this.#transitionService.transition({
-          orgId: record.orgId,
-          factoryProjectId: record.factoryProjectId,
-          workItemId: item.id,
-          board: decision.board,
-          stage: decision.stage,
-          expectedRevision: item.revision,
-          actor: { type: "system", id: "factory-rule-dispatcher" },
-          ingress: { type: "rule", identity: `decision:${record.idempotencyKey}` },
-          cause: "rule_decision",
-          causalChain: nextChain
-        });
-        if (result.status === "rejected") throw new Error(`${result.code}: ${result.reason}`);
-        return;
-      }
-      case "upsertLinkedWorkItem": {
-        await this.#upsertLinkedItem(record, decision, nextChain);
-        return;
-      }
-      case "invokeSkill": {
-        const binding = await this.#requireOrPrepareBinding(record, decision.role);
-        const item = record.workItemId ? await this.#storage.get({ orgId: record.orgId, id: record.workItemId }) : null;
-        const startedBy = item?.sessions[binding.role]?.startedBy;
-        if (!startedBy) throw new Error(`Factory binding ${binding.id} has no authenticated session owner.`);
-        await this.#primeCredentials?.({ orgId: record.orgId, userId: startedBy });
-        const requestContext = new RequestContext();
-        requestContext.set("user", { workosId: startedBy, organizationId: record.orgId });
-        const resolved = await resolveSkillInvocation(this.#controller, {
-          resourceId: binding.resourceId,
-          name: decision.skillName,
-          arguments: decision.arguments
-        });
-        const session = resolved.session;
-        await this.#switchThread(session, binding);
-        const delivered = await session.thread.listActiveMessages();
-        if (delivered.some((message) => message.id === record.id)) return;
-        if (decision.precedingMessage) {
-          await awaitNotification(
-            await session.sendNotificationSignal(
-              {
-                source: "factory",
-                kind: "stage-transition",
-                summary: decision.precedingMessage,
-                priority: "medium",
-                payload: { message: decision.precedingMessage },
-                sourceId: `${record.id}:stage-transition`,
-                dedupeKey: `${record.idempotencyKey}:stage-transition`
-              },
-              {
-                ifActive: { behavior: "deliver" },
-                ifIdle: { behavior: "persist" },
-                requestContext
-              }
-            )
-          );
-        }
-        const result = session.sendSignal(
-          {
-            id: record.id,
-            type: "user",
-            tagName: "user",
-            contents: resolved.message
-          },
-          { requestContext }
-        );
-        await result.accepted;
-        return;
-      }
-      case "sendMessage": {
-        const binding = decision.prepareBinding ? await this.#requireOrPrepareBinding(record, decision.role) : await this.#requireBinding(record, decision.role);
-        const item = record.workItemId ? await this.#storage.get({ orgId: record.orgId, id: record.workItemId }) : null;
-        const startedBy = item?.sessions[binding.role]?.startedBy;
-        if (!startedBy) throw new Error(`Factory binding ${binding.id} has no authenticated session owner.`);
-        await this.#primeCredentials?.({ orgId: record.orgId, userId: startedBy });
-        const requestContext = new RequestContext();
-        requestContext.set("user", { workosId: startedBy, organizationId: record.orgId });
-        const session = await this.#requireSession(binding);
-        await awaitNotification(
-          await session.sendNotificationSignal(
-            {
-              source: "factory",
-              kind: "rule-message",
-              summary: decision.message,
-              priority: decision.priority ?? "high",
-              payload: { message: decision.message },
-              sourceId: record.id,
-              dedupeKey: record.idempotencyKey
-            },
-            {
-              ifActive: { behavior: "deliver" },
-              ifIdle: { behavior: decision.idleBehavior ?? "wake" },
-              requestContext
-            }
-          ),
-          true
-        );
-        return;
-      }
-      case "notify": {
-        const binding = await this.#requireBinding(record);
-        const session = await this.#requireSession(binding);
-        await awaitNotification(
-          await session.sendNotificationSignal({
-            source: "factory",
-            kind: "rule-notification",
-            summary: decision.title,
-            payload: { body: decision.body, level: decision.level },
-            sourceId: record.id,
-            dedupeKey: record.idempotencyKey
-          })
-        );
-      }
-    }
-  }
-  async #upsertLinkedItem(record, decision, causalChain) {
-    const result = await this.#storage.upsert({
-      orgId: record.orgId,
-      userId: "factory-rule-dispatcher",
-      factoryProjectId: record.factoryProjectId,
-      input: {
-        externalSource: externalSourceForDecision(decision),
-        parentWorkItemId: record.workItemId,
-        title: decision.title,
-        stages: ["intake"],
-        sessions: {},
-        metadata: { ...decision.metadata, factoryRuleMaterializationKey: record.idempotencyKey }
-      },
-      reuseMode: "preserve"
-    });
-    const materializedByDecision = result.item.metadata?.factoryRuleMaterializationKey === record.idempotencyKey;
-    if (!materializedByDecision && (decision.stage === "intake" || !result.item.stages.includes("intake"))) return;
-    const board = decision.board;
-    let expectedRevision = result.item.revision;
-    if (materializedByDecision) {
-      const initial = await this.#transitionService.transition({
-        orgId: record.orgId,
-        factoryProjectId: record.factoryProjectId,
-        workItemId: result.item.id,
-        board,
-        stage: "intake",
-        expectedRevision,
-        actor: deferredActor(record),
-        ingress: { type: "rule", identity: `decision:${record.idempotencyKey}:${result.item.id}:initial-entry` },
-        cause: "linked_item_materialized",
-        causalChain,
-        initialEntry: true
-      });
-      if (initial.status === "rejected") {
-        if (result.created) await this.#storage.delete({ orgId: record.orgId, id: result.item.id });
-        throw new Error(`${initial.code}: ${initial.reason}`);
-      }
-      expectedRevision = initial.revision;
-    }
-    if (decision.stage === "intake") return;
-    const moved = await this.#transitionService.transition({
-      orgId: record.orgId,
-      factoryProjectId: record.factoryProjectId,
-      workItemId: result.item.id,
-      board,
-      stage: decision.stage,
-      expectedRevision,
-      actor: { type: "system", id: "factory-rule-dispatcher" },
-      ingress: { type: "rule", identity: `decision:${record.idempotencyKey}:${result.item.id}:destination` },
-      cause: materializedByDecision ? "linked_item_materialized" : "linked_item_reconciled",
-      causalChain
-    });
-    if (moved.status === "rejected") throw new Error(`${moved.code}: ${moved.reason}`);
-  }
-  async #requireItem(record) {
-    if (!record.workItemId) throw new Error("Factory decision is not linked to a work item.");
-    const item = await this.#storage.get({ orgId: record.orgId, id: record.workItemId });
-    if (!item) throw new Error("Factory work item not found.");
-    return item;
-  }
-  async #findBinding(record, role) {
-    if (!record.workItemId) throw new Error("Factory decision is not linked to a work item.");
-    const bindings = await this.#storage.listRunBindings(record.orgId, record.factoryProjectId, record.workItemId);
-    return bindings.filter((candidate) => candidate.status === "active" && (role === void 0 || candidate.role === role)).sort((left, right) => {
-      if (role === void 0 && left.role === "work" && right.role !== "work") return -1;
-      if (role === void 0 && right.role === "work" && left.role !== "work") return 1;
-      return right.createdAt.getTime() - left.createdAt.getTime() || left.id.localeCompare(right.id);
-    })[0];
-  }
-  async #requireBinding(record, role) {
-    const binding = await this.#findBinding(record, role);
-    if (!binding) throw new Error(role ? `No active Factory binding for role ${role}.` : "No active Factory binding.");
-    return binding;
-  }
-  async #requireOrPrepareBinding(record, role) {
-    const binding = await this.#findBinding(record, role);
-    if (binding) {
-      const session = await this.#controller.getSessionByResource(binding.resourceId);
-      if (session) return binding;
-    }
-    if (!this.#prepareBinding) {
-      throw new Error(binding ? "Bound Factory session not found." : `No active Factory binding for role ${role}.`);
-    }
-    const item = await this.#requireItem(record);
-    await this.#prepareBinding({ record, item, role });
-    return this.#requireBinding(record, role);
-  }
-  async #requireSession(binding) {
-    const session = await this.#controller.getSessionByResource(binding.resourceId);
-    if (!session) throw new Error("Bound Factory session not found.");
-    await this.#switchThread(session, binding);
-    return session;
-  }
-  async #switchThread(session, binding) {
-    await session.thread.switch({ threadId: binding.threadId });
-  }
-  async #withLease(renew, effect) {
-    let renewalFailure;
-    let renewal = Promise.resolve();
-    const timer = setInterval(
-      () => {
-        renewal = renewal.then(async () => {
-          try {
-            const renewed = await renew(new Date(Date.now() + LEASE_MS));
-            if (!renewed) renewalFailure = new Error("Factory dispatch lease was lost during execution.");
-          } catch (error) {
-            renewalFailure = error;
-          }
-        });
-      },
-      Math.floor(LEASE_MS / 3)
-    );
-    timer.unref?.();
-    try {
-      await effect();
-      await renewal;
-      if (renewalFailure) throw renewalFailure;
-    } finally {
-      clearInterval(timer);
-      await renewal;
-    }
-  }
-  async #dispatchPendingStart(record, now) {
-    try {
-      await this.#withLease(
-        async (leaseExpiresAt) => this.#storage.renewPendingStartLease(leaseIdentity(record, this.#ownerId), leaseExpiresAt),
-        async () => {
-          if (record.message === null) return;
-          const bindings = await this.#storage.listRunBindings(record.orgId, record.factoryProjectId);
-          const binding = bindings.find(
-            (candidate) => candidate.id === record.bindingId && candidate.status === "active"
-          );
-          if (!binding) throw new Error("Prepared Factory binding is unavailable or revoked.");
-          const item = await this.#storage.get({ orgId: record.orgId, id: binding.workItemId });
-          const startedBy = item?.sessions[binding.role]?.startedBy;
-          if (!startedBy) throw new Error(`Factory binding ${binding.id} has no authenticated session owner.`);
-          await this.#primeCredentials?.({ orgId: record.orgId, userId: startedBy });
-          const requestContext = new RequestContext();
-          requestContext.set("user", { workosId: startedBy, organizationId: record.orgId });
-          const session = await this.#requireSession(binding);
-          await awaitNotification(
-            await session.sendNotificationSignal(
-              {
-                source: "factory",
-                kind: "run-kickoff",
-                summary: record.message,
-                priority: "high",
-                payload: { message: record.message },
-                sourceId: record.id,
-                dedupeKey: `factory-kickoff:${record.kickoffKey}`
-              },
-              { ifActive: { behavior: "deliver" }, ifIdle: { behavior: "wake" }, requestContext }
-            ),
-            true
-          );
-        }
-      );
-      const completed = await this.#storage.completePendingStart(leaseIdentity(record, this.#ownerId), /* @__PURE__ */ new Date());
-      if (!completed) throw new Error("Factory kickoff lease was lost before completion.");
-    } catch (error) {
-      await this.#storage.failPendingStart({
-        ...leaseIdentity(record, this.#ownerId),
-        now: /* @__PURE__ */ new Date(),
-        availableAt: retryAt(now, record.attempts),
-        lastError: sanitizeDispatchError(error),
-        terminal: record.attempts >= MAX_ATTEMPTS
-      });
-    }
-  }
+	#controller;
+	#transitionService;
+	#storage;
+	#ownerId;
+	#reconcileToolResults;
+	#prepareBinding;
+	#primeCredentials;
+	#timer;
+	#activeRun;
+	constructor(options) {
+		this.#controller = options.controller;
+		this.#transitionService = options.transitionService;
+		this.#storage = options.storage;
+		this.#ownerId = options.ownerId ?? `factory-dispatcher:${randomUUID()}`;
+		this.#reconcileToolResults = options.reconcileToolResults;
+		this.#prepareBinding = options.prepareBinding;
+		this.#primeCredentials = options.primeCredentials;
+	}
+	start() {
+		if (this.#timer) return;
+		this.#tick();
+		this.#timer = setInterval(() => void this.#tick(), POLL_MS);
+		this.#timer.unref?.();
+	}
+	async stop() {
+		if (this.#timer) clearInterval(this.#timer);
+		this.#timer = void 0;
+		await this.#activeRun;
+	}
+	async runOnce(now = /* @__PURE__ */ new Date()) {
+		await this.#reconcileToolResults?.();
+		const leaseExpiresAt = new Date(now.getTime() + LEASE_MS);
+		const [decisions, starts] = await Promise.all([this.#storage.claimDeferredDecisions({
+			ownerId: this.#ownerId,
+			now,
+			leaseExpiresAt,
+			limit: BATCH_SIZE
+		}), this.#storage.claimPendingStarts({
+			ownerId: this.#ownerId,
+			now,
+			leaseExpiresAt,
+			limit: BATCH_SIZE
+		})]);
+		await Promise.all([...decisions.map((decision) => this.#dispatchDecision(decision, now)), ...starts.map((start) => this.#dispatchPendingStart(start, now))]);
+	}
+	async #tick() {
+		if (this.#activeRun) return;
+		this.#activeRun = this.runOnce().catch((error) => {
+			console.error("Factory decision dispatch cycle failed", sanitizeDispatchError(error));
+		});
+		try {
+			await this.#activeRun;
+		} finally {
+			this.#activeRun = void 0;
+		}
+	}
+	async #dispatchDecision(record, now) {
+		try {
+			const decision = validateFactoryRuleDecision(record.decision, record.causalChain.length);
+			if (decision.type === "reject") throw new Error("Deferred Factory decisions cannot reject.");
+			await this.#withLease(async (leaseExpiresAt) => this.#storage.renewDeferredDecisionLease(leaseIdentity(record, this.#ownerId), leaseExpiresAt), async () => this.#executeDecision(record, decision));
+			if (!await this.#storage.completeDeferredDecision(leaseIdentity(record, this.#ownerId), /* @__PURE__ */ new Date())) throw new Error("Factory decision lease was lost before completion.");
+		} catch (error) {
+			const terminal = record.attempts >= MAX_ATTEMPTS;
+			await this.#storage.failDeferredDecision({
+				...leaseIdentity(record, this.#ownerId),
+				now: /* @__PURE__ */ new Date(),
+				availableAt: retryAt(now, record.attempts),
+				lastError: sanitizeDispatchError(error),
+				terminal
+			});
+		}
+	}
+	async #executeDecision(record, decision) {
+		const nextChain = [...record.causalChain, {
+			ingressId: record.idempotencyKey,
+			decisionType: decision.type
+		}];
+		if (nextChain.length > 8) throw new Error("Factory rule causal depth exceeded.");
+		switch (decision.type) {
+			case "transition": {
+				const item = await this.#requireItem(record);
+				const result = await this.#transitionService.transition({
+					orgId: record.orgId,
+					factoryProjectId: record.factoryProjectId,
+					workItemId: item.id,
+					board: decision.board,
+					stage: decision.stage,
+					expectedRevision: item.revision,
+					actor: {
+						type: "system",
+						id: "factory-rule-dispatcher"
+					},
+					ingress: {
+						type: "rule",
+						identity: `decision:${record.idempotencyKey}`
+					},
+					cause: "rule_decision",
+					causalChain: nextChain
+				});
+				if (result.status === "rejected") throw new Error(`${result.code}: ${result.reason}`);
+				return;
+			}
+			case "upsertLinkedWorkItem":
+				await this.#upsertLinkedItem(record, decision, nextChain);
+				return;
+			case "invokeSkill": {
+				const binding = await this.#requireOrPrepareBinding(record, decision.role);
+				const startedBy = (record.workItemId ? await this.#storage.get({
+					orgId: record.orgId,
+					id: record.workItemId
+				}) : null)?.sessions[binding.role]?.startedBy;
+				if (!startedBy) throw new Error(`Factory binding ${binding.id} has no authenticated session owner.`);
+				await this.#primeCredentials?.({
+					orgId: record.orgId,
+					userId: startedBy
+				});
+				const requestContext = new RequestContext();
+				requestContext.set("user", {
+					workosId: startedBy,
+					organizationId: record.orgId
+				});
+				const resolved = await resolveSkillInvocation(this.#controller, {
+					resourceId: binding.resourceId,
+					name: decision.skillName,
+					arguments: decision.arguments
+				});
+				const session = resolved.session;
+				await this.#switchThread(session, binding);
+				if ((await session.thread.listActiveMessages()).some((message) => message.id === record.id)) return;
+				if (decision.precedingMessage) await awaitNotification(await session.sendNotificationSignal({
+					source: "factory",
+					kind: "stage-transition",
+					summary: decision.precedingMessage,
+					priority: "medium",
+					payload: { message: decision.precedingMessage },
+					sourceId: `${record.id}:stage-transition`,
+					dedupeKey: `${record.idempotencyKey}:stage-transition`
+				}, {
+					ifActive: { behavior: "deliver" },
+					ifIdle: { behavior: "persist" },
+					requestContext
+				}));
+				await session.sendSignal({
+					id: record.id,
+					type: "user",
+					tagName: "user",
+					contents: resolved.message
+				}, { requestContext }).accepted;
+				return;
+			}
+			case "sendMessage": {
+				const binding = decision.prepareBinding ? await this.#requireOrPrepareBinding(record, decision.role) : await this.#requireBinding(record, decision.role);
+				const startedBy = (record.workItemId ? await this.#storage.get({
+					orgId: record.orgId,
+					id: record.workItemId
+				}) : null)?.sessions[binding.role]?.startedBy;
+				if (!startedBy) throw new Error(`Factory binding ${binding.id} has no authenticated session owner.`);
+				await this.#primeCredentials?.({
+					orgId: record.orgId,
+					userId: startedBy
+				});
+				const requestContext = new RequestContext();
+				requestContext.set("user", {
+					workosId: startedBy,
+					organizationId: record.orgId
+				});
+				await awaitNotification(await (await this.#requireSession(binding)).sendNotificationSignal({
+					source: "factory",
+					kind: "rule-message",
+					summary: decision.message,
+					priority: decision.priority ?? "high",
+					payload: { message: decision.message },
+					sourceId: record.id,
+					dedupeKey: record.idempotencyKey
+				}, {
+					ifActive: { behavior: "deliver" },
+					ifIdle: { behavior: decision.idleBehavior ?? "wake" },
+					requestContext
+				}), true);
+				return;
+			}
+			case "notify": {
+				const binding = await this.#requireBinding(record);
+				await awaitNotification(await (await this.#requireSession(binding)).sendNotificationSignal({
+					source: "factory",
+					kind: "rule-notification",
+					summary: decision.title,
+					payload: {
+						body: decision.body,
+						level: decision.level
+					},
+					sourceId: record.id,
+					dedupeKey: record.idempotencyKey
+				}));
+			}
+		}
+	}
+	async #upsertLinkedItem(record, decision, causalChain) {
+		const result = await this.#storage.upsert({
+			orgId: record.orgId,
+			userId: "factory-rule-dispatcher",
+			factoryProjectId: record.factoryProjectId,
+			input: {
+				externalSource: externalSourceForDecision(decision),
+				parentWorkItemId: record.workItemId,
+				title: decision.title,
+				stages: ["intake"],
+				sessions: {},
+				metadata: {
+					...decision.metadata,
+					factoryRuleMaterializationKey: record.idempotencyKey
+				}
+			},
+			reuseMode: "preserve"
+		});
+		const materializedByDecision = result.item.metadata?.factoryRuleMaterializationKey === record.idempotencyKey;
+		if (!materializedByDecision && (decision.stage === "intake" || !result.item.stages.includes("intake"))) return;
+		const board = decision.board;
+		let expectedRevision = result.item.revision;
+		if (materializedByDecision) {
+			const initial = await this.#transitionService.transition({
+				orgId: record.orgId,
+				factoryProjectId: record.factoryProjectId,
+				workItemId: result.item.id,
+				board,
+				stage: "intake",
+				expectedRevision,
+				actor: deferredActor(record),
+				ingress: {
+					type: "rule",
+					identity: `decision:${record.idempotencyKey}:${result.item.id}:initial-entry`
+				},
+				cause: "linked_item_materialized",
+				causalChain,
+				initialEntry: true
+			});
+			if (initial.status === "rejected") {
+				if (result.created) await this.#storage.delete({
+					orgId: record.orgId,
+					id: result.item.id
+				});
+				throw new Error(`${initial.code}: ${initial.reason}`);
+			}
+			expectedRevision = initial.revision;
+		}
+		if (decision.stage === "intake") return;
+		const moved = await this.#transitionService.transition({
+			orgId: record.orgId,
+			factoryProjectId: record.factoryProjectId,
+			workItemId: result.item.id,
+			board,
+			stage: decision.stage,
+			expectedRevision,
+			actor: {
+				type: "system",
+				id: "factory-rule-dispatcher"
+			},
+			ingress: {
+				type: "rule",
+				identity: `decision:${record.idempotencyKey}:${result.item.id}:destination`
+			},
+			cause: materializedByDecision ? "linked_item_materialized" : "linked_item_reconciled",
+			causalChain
+		});
+		if (moved.status === "rejected") throw new Error(`${moved.code}: ${moved.reason}`);
+	}
+	async #requireItem(record) {
+		if (!record.workItemId) throw new Error("Factory decision is not linked to a work item.");
+		const item = await this.#storage.get({
+			orgId: record.orgId,
+			id: record.workItemId
+		});
+		if (!item) throw new Error("Factory work item not found.");
+		return item;
+	}
+	async #findBinding(record, role) {
+		if (!record.workItemId) throw new Error("Factory decision is not linked to a work item.");
+		return (await this.#storage.listRunBindings(record.orgId, record.factoryProjectId, record.workItemId)).filter((candidate) => candidate.status === "active" && (role === void 0 || candidate.role === role)).sort((left, right) => {
+			if (role === void 0 && left.role === "work" && right.role !== "work") return -1;
+			if (role === void 0 && right.role === "work" && left.role !== "work") return 1;
+			return right.createdAt.getTime() - left.createdAt.getTime() || left.id.localeCompare(right.id);
+		})[0];
+	}
+	async #requireBinding(record, role) {
+		const binding = await this.#findBinding(record, role);
+		if (!binding) throw new Error(role ? `No active Factory binding for role ${role}.` : "No active Factory binding.");
+		return binding;
+	}
+	async #requireOrPrepareBinding(record, role) {
+		const binding = await this.#findBinding(record, role);
+		if (binding) {
+			if (await this.#controller.getSessionByResource(binding.resourceId)) return binding;
+		}
+		if (!this.#prepareBinding) throw new Error(binding ? "Bound Factory session not found." : `No active Factory binding for role ${role}.`);
+		const item = await this.#requireItem(record);
+		await this.#prepareBinding({
+			record,
+			item,
+			role
+		});
+		return this.#requireBinding(record, role);
+	}
+	async #requireSession(binding) {
+		const session = await this.#controller.getSessionByResource(binding.resourceId);
+		if (!session) throw new Error("Bound Factory session not found.");
+		await this.#switchThread(session, binding);
+		return session;
+	}
+	async #switchThread(session, binding) {
+		await session.thread.switch({ threadId: binding.threadId });
+	}
+	async #withLease(renew, effect) {
+		let renewalFailure;
+		let renewal = Promise.resolve();
+		const timer = setInterval(() => {
+			renewal = renewal.then(async () => {
+				try {
+					if (!await renew(new Date(Date.now() + LEASE_MS))) renewalFailure = /* @__PURE__ */ new Error("Factory dispatch lease was lost during execution.");
+				} catch (error) {
+					renewalFailure = error;
+				}
+			});
+		}, Math.floor(LEASE_MS / 3));
+		timer.unref?.();
+		try {
+			await effect();
+			await renewal;
+			if (renewalFailure) throw renewalFailure;
+		} finally {
+			clearInterval(timer);
+			await renewal;
+		}
+	}
+	async #dispatchPendingStart(record, now) {
+		try {
+			await this.#withLease(async (leaseExpiresAt) => this.#storage.renewPendingStartLease(leaseIdentity(record, this.#ownerId), leaseExpiresAt), async () => {
+				if (record.message === null) return;
+				const binding = (await this.#storage.listRunBindings(record.orgId, record.factoryProjectId)).find((candidate) => candidate.id === record.bindingId && candidate.status === "active");
+				if (!binding) throw new Error("Prepared Factory binding is unavailable or revoked.");
+				const startedBy = (await this.#storage.get({
+					orgId: record.orgId,
+					id: binding.workItemId
+				}))?.sessions[binding.role]?.startedBy;
+				if (!startedBy) throw new Error(`Factory binding ${binding.id} has no authenticated session owner.`);
+				await this.#primeCredentials?.({
+					orgId: record.orgId,
+					userId: startedBy
+				});
+				const requestContext = new RequestContext();
+				requestContext.set("user", {
+					workosId: startedBy,
+					organizationId: record.orgId
+				});
+				await awaitNotification(await (await this.#requireSession(binding)).sendNotificationSignal({
+					source: "factory",
+					kind: "run-kickoff",
+					summary: record.message,
+					priority: "high",
+					payload: { message: record.message },
+					sourceId: record.id,
+					dedupeKey: `factory-kickoff:${record.kickoffKey}`
+				}, {
+					ifActive: { behavior: "deliver" },
+					ifIdle: { behavior: "wake" },
+					requestContext
+				}), true);
+			});
+			if (!await this.#storage.completePendingStart(leaseIdentity(record, this.#ownerId), /* @__PURE__ */ new Date())) throw new Error("Factory kickoff lease was lost before completion.");
+		} catch (error) {
+			await this.#storage.failPendingStart({
+				...leaseIdentity(record, this.#ownerId),
+				now: /* @__PURE__ */ new Date(),
+				availableAt: retryAt(now, record.attempts),
+				lastError: sanitizeDispatchError(error),
+				terminal: record.attempts >= MAX_ATTEMPTS
+			});
+		}
+	}
 };
-var FACTORY_DISPATCH_CONSTANTS = {
-  leaseMs: LEASE_MS,
-  pollMs: POLL_MS,
-  batchSize: BATCH_SIZE,
-  maxAttempts: MAX_ATTEMPTS,
-  maxErrorLength: MAX_ERROR_LENGTH,
-  maxBackoffMs: MAX_BACKOFF_MS,
-  stages: FACTORY_RULE_STAGES
-};
-export {
-  FACTORY_DISPATCH_CONSTANTS,
-  FactoryDecisionDispatcher
+const FACTORY_DISPATCH_CONSTANTS = {
+	leaseMs: LEASE_MS,
+	pollMs: POLL_MS,
+	batchSize: BATCH_SIZE,
+	maxAttempts: MAX_ATTEMPTS,
+	maxErrorLength: MAX_ERROR_LENGTH,
+	maxBackoffMs: MAX_BACKOFF_MS,
+	stages: FACTORY_RULE_STAGES
 };
+//#endregion
+export { FACTORY_DISPATCH_CONSTANTS, FactoryDecisionDispatcher };
+
 //# sourceMappingURL=dispatcher.js.map