@mastra/factory 0.0.0 → 0.1.0-alpha.3

package/dist/rules/dispatcher.js

@@ -0,0 +1,695 @@
+// src/rules/dispatcher.ts
+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;
+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);
+}
+function retryAt(now, attempts) {
+  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 };
+}
+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" };
+}
+function leaseIdentity(record, 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)}).`);
+  }
+}
+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 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" } }
+            ),
+            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
+      });
+    }
+  }
+};
+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
+};
+//# sourceMappingURL=dispatcher.js.map