@mastra/factory 0.0.0 → 0.1.0-alpha.3

package/dist/rules/processor.d.ts

@@ -0,0 +1,54 @@
+import type { MastraDBMessage, MessageList } from '@mastra/core/agent/message-list';
+import type { ComputeStateSignalArgs, ComputeStateSignalResult, ProcessInputStepArgs, Processor } from '@mastra/core/processors';
+import type { FactoryRunBindingRecord, WorkItemsStorage, WorkItemRow } from '../storage/domains/work-items/base.js';
+import type { FactoryTransitionService } from './transition-service.js';
+import type { FactoryRuleJsonValue, FactoryRules } from './types.js';
+type PersistedMessageReader = {
+    listMessages(input: {
+        threadId: string;
+        resourceId?: string;
+        page: number;
+        perPage: number;
+        filter?: {
+            dateRange?: {
+                start?: Date;
+            };
+        };
+        orderBy: {
+            field: 'createdAt';
+            direction: 'ASC';
+        };
+    }): Promise<{
+        messages: MastraDBMessage[];
+        hasMore: boolean;
+    }>;
+};
+export declare class FactoryPhaseStateProcessor implements Processor<'factory-phase'> {
+    private readonly options;
+    readonly id = "factory-phase";
+    readonly stateId = "factory-phase";
+    constructor(options: {
+        rules: FactoryRules;
+        storage: WorkItemsStorage;
+        transitionService?: Pick<FactoryTransitionService, 'transition'>;
+        messageReader?: PersistedMessageReader;
+        recordPullRequestProvenance?: (input: {
+            binding: FactoryRunBindingRecord;
+            item: WorkItemRow;
+            assistantMessageId: string;
+            toolCallId: string;
+            toolName: string;
+            toolInput: FactoryRuleJsonValue;
+            toolResult: FactoryRuleJsonValue;
+            status: 'success' | 'error';
+        }) => Promise<void>;
+    });
+    processInputStep(args: ProcessInputStepArgs): Promise<MessageList | undefined>;
+    computeStateSignal(args: ComputeStateSignalArgs): Promise<ComputeStateSignalResult>;
+    reconcileAllBoundThreads(): Promise<void>;
+    reconcileBinding(binding: FactoryRunBindingRecord): Promise<void>;
+    private ingestMessages;
+    private ingestToolResult;
+}
+export {};
+//# sourceMappingURL=processor.d.ts.map

package/dist/rules/processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processor.d.ts","sourceRoot":"","sources":["../../src/rules/processor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACpF,OAAO,KAAK,EACV,sBAAsB,EACtB,wBAAwB,EACxB,oBAAoB,EACpB,SAAS,EACV,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AAGpH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAExE,OAAO,KAAK,EAIV,oBAAoB,EACpB,YAAY,EAEb,MAAM,YAAY,CAAC;AAiBpB,KAAK,sBAAsB,GAAG;IAC5B,YAAY,CAAC,KAAK,EAAE;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE;YAAE,SAAS,CAAC,EAAE;gBAAE,KAAK,CAAC,EAAE,IAAI,CAAA;aAAE,CAAA;SAAE,CAAC;QAC1C,OAAO,EAAE;YAAE,KAAK,EAAE,WAAW,CAAC;YAAC,SAAS,EAAE,KAAK,CAAA;SAAE,CAAC;KACnD,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,eAAe,EAAE,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAChE,CAAC;AA0JF,qBAAa,0BAA2B,YAAW,SAAS,CAAC,eAAe,CAAC;IAKzE,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,QAAQ,CAAC,EAAE,mBAAY;IACvB,QAAQ,CAAC,OAAO,mBAAY;gBAGT,OAAO,EAAE;QACxB,KAAK,EAAE,YAAY,CAAC;QACpB,OAAO,EAAE,gBAAgB,CAAC;QAC1B,iBAAiB,CAAC,EAAE,IAAI,CAAC,wBAAwB,EAAE,YAAY,CAAC,CAAC;QACjE,aAAa,CAAC,EAAE,sBAAsB,CAAC;QACvC,2BAA2B,CAAC,EAAE,CAAC,KAAK,EAAE;YACpC,OAAO,EAAE,uBAAuB,CAAC;YACjC,IAAI,EAAE,WAAW,CAAC;YAClB,kBAAkB,EAAE,MAAM,CAAC;YAC3B,UAAU,EAAE,MAAM,CAAC;YACnB,QAAQ,EAAE,MAAM,CAAC;YACjB,SAAS,EAAE,oBAAoB,CAAC;YAChC,UAAU,EAAE,oBAAoB,CAAC;YACjC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC;SAC7B,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;KACrB;IAGG,gBAAgB,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC;IAY9E,kBAAkB,CAAC,IAAI,EAAE,sBAAsB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAqEnF,wBAAwB,IAAI,OAAO,CAAC,IAAI,CAAC;IAMzC,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;YA+BzD,cAAc;YA6Bd,gBAAgB;CAiG/B"}

package/dist/rules/processor.js

@@ -0,0 +1,629 @@
+// src/rules/processor.ts
+import { createHash } from "crypto";
+
+// src/auth.ts
+import { MastraAuthWorkos } from "@mastra/auth-workos";
+import {
+  registerApiRoute,
+  isAuthHttpHandler,
+  isCredentialsProvider,
+  isOrganizationsProvider,
+  isSessionProvider,
+  isSSOProvider
+} from "@mastra/core/server";
+
+// src/rules/binding-context.ts
+function getFactorySessionCoordinates(requestContext) {
+  if (!requestContext || typeof requestContext.get !== "function") return null;
+  const context = requestContext.get("controller");
+  const factoryProjectId = context?.getState().factoryProjectId;
+  if (!context?.threadId || !context.resourceId || !factoryProjectId) return null;
+  return {
+    factoryProjectId,
+    threadId: context.threadId,
+    resourceId: context.resourceId,
+    sessionId: context.resourceId
+  };
+}
+
+// src/rules/resolve.ts
+function resolveFactoryToolRule(rules, toolName) {
+  return rules.tools[toolName]?.onResult;
+}
+
+// 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.");
+  }
+}
+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/processor.ts
+var STATE_ID = "factory-phase";
+var RULE_TIMEOUT_MS = 5e3;
+var TRANSCRIPT_PAGE_SIZE = 50;
+var MAX_LINKED_ITEMS = 5;
+var PHASE_LABELS = {
+  intake: "Intake",
+  triage: "Investigating",
+  planning: "Planning",
+  execute: "Building",
+  review: "Reviewing",
+  done: "Done",
+  canceled: "Canceled"
+};
+function workItemSource(item) {
+  if (!item.externalSource) return "manual";
+  if (item.externalSource.integrationId === "linear") return "linear-issue";
+  return item.externalSource.type === "pull-request" ? "github-pr" : "github-issue";
+}
+function workItemSourceKey(item) {
+  const source = item.externalSource;
+  return source ? `${source.integrationId}:${source.type}:${source.externalId}` : null;
+}
+function boardForItem(item) {
+  return item.externalSource?.type === "pull-request" ? "review" : "work";
+}
+function boundedError(value) {
+  const message = value instanceof Error ? value.message : typeof value === "string" ? value : "Tool execution failed.";
+  return { message: message.slice(0, 2e3) };
+}
+function boundedResult(value) {
+  try {
+    return normalizeFactoryRuleJsonValue(value);
+  } catch {
+    return { message: "Tool result was not serializable." };
+  }
+}
+function messageParts(message) {
+  const content = message.content;
+  if (Array.isArray(content)) return content;
+  if (Array.isArray(content?.parts)) return content.parts;
+  return Array.isArray(content?.toolInvocations) ? content.toolInvocations : [];
+}
+function completedStepToolCallIds(steps) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const rawStep of steps) {
+    if (!rawStep || typeof rawStep !== "object") continue;
+    const toolResults = rawStep.toolResults;
+    if (!Array.isArray(toolResults)) continue;
+    for (const rawResult of toolResults) {
+      if (!rawResult || typeof rawResult !== "object") continue;
+      const toolCallId = rawResult.toolCallId;
+      if (typeof toolCallId === "string") ids.add(toolCallId);
+    }
+  }
+  return ids;
+}
+function completedToolResults(message) {
+  if (message.role !== "assistant") return [];
+  const createdAt = message.createdAt instanceof Date ? message.createdAt : new Date(message.createdAt);
+  const completed = [];
+  for (const rawPart of messageParts(message)) {
+    if (!rawPart || typeof rawPart !== "object") continue;
+    const part = rawPart;
+    const invocation = part.type === "tool-invocation" && part.toolInvocation && typeof part.toolInvocation === "object" ? part.toolInvocation : part;
+    const state = invocation.state;
+    if (state !== "result" && state !== "error") continue;
+    const toolCallId = invocation.toolCallId;
+    const toolName = invocation.toolName ?? invocation.name;
+    if (typeof toolCallId !== "string" || typeof toolName !== "string") continue;
+    completed.push({
+      assistantMessageId: message.id,
+      messageCreatedAt: createdAt,
+      toolCallId,
+      toolName: toolName.slice(0, 256),
+      input: boundedResult(invocation.args ?? {}),
+      status: state === "error" ? "error" : "success",
+      value: state === "error" ? boundedError(invocation.result ?? invocation.error) : boundedResult(invocation.result)
+    });
+  }
+  return completed;
+}
+function currentCompletedToolMessage(messages, toolCallIds) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (completedToolResults(message).some((result) => toolCallIds.has(result.toolCallId))) return message;
+  }
+  return void 0;
+}
+function phaseCacheKey(value, linked) {
+  return createHash("sha256").update(
+    JSON.stringify({
+      ...value,
+      linked: linked.map((item) => [item.id, item.revision, item.stages[0]])
+    })
+  ).digest("hex");
+}
+function escapeText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function phaseFromSignal(signal) {
+  return signal?.metadata?.value?.phase;
+}
+function latestPhase(args) {
+  for (const signal of [...args.activeStateSignals].reverse()) {
+    const phase = phaseFromSignal(signal);
+    if (phase) return phase;
+  }
+  return phaseFromSignal(args.lastSnapshot);
+}
+async function withRuleTimeout(operation) {
+  let timer;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("FACTORY_RULE_TIMEOUT")), RULE_TIMEOUT_MS);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+var FactoryPhaseStateProcessor = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  id = STATE_ID;
+  stateId = STATE_ID;
+  async processInputStep(args) {
+    const address = getFactorySessionCoordinates(args.requestContext);
+    if (!address) return;
+    const binding = await this.options.storage.findRunBindingBySession(address);
+    if (!binding || binding.status !== "active") return;
+    const completedToolCallIds = completedStepToolCallIds(args.steps);
+    const completedMessage = currentCompletedToolMessage(args.messages, completedToolCallIds);
+    if (completedMessage) {
+      await this.ingestMessages(binding, [completedMessage], completedToolCallIds);
+    }
+  }
+  async computeStateSignal(args) {
+    const address = getFactorySessionCoordinates(args.requestContext);
+    if (!address) return;
+    const binding = await this.options.storage.findRunBindingBySession(address);
+    const prior = latestPhase(args);
+    const hasBase = Boolean(args.lastSnapshot) && args.contextWindow.hasSnapshot;
+    if (!binding) return;
+    if (binding.status !== "active") {
+      if (!hasBase || prior?.status !== "active") return;
+      return {
+        id: STATE_ID,
+        cacheKey: `factory:none:${prior.bindingId ?? "revoked"}`,
+        mode: "snapshot",
+        tagName: "factory-phase",
+        contents: "\n",
+        value: { phase: { status: "none" } },
+        attributes: { status: "none" },
+        metadata: { value: { phase: { status: "none" } } }
+      };
+    }
+    const item = await this.options.storage.get({ orgId: binding.orgId, id: binding.workItemId });
+    if (!item || item.stages.length !== 1 || !FACTORY_RULE_STAGES.includes(item.stages[0])) return;
+    const allItems = await this.options.storage.list({
+      orgId: binding.orgId,
+      factoryProjectId: binding.factoryProjectId
+    });
+    const linked = allItems.filter((candidate) => candidate.parentWorkItemId === item.id || item.parentWorkItemId === candidate.id).slice(0, MAX_LINKED_ITEMS);
+    const board = boardForItem(item);
+    const stage = item.stages[0];
+    const value = {
+      status: "active",
+      bindingId: binding.id,
+      itemId: item.id,
+      revision: item.revision,
+      stage,
+      role: binding.role,
+      board,
+      ruleSetVersion: this.options.rules.version
+    };
+    const cacheKey = phaseCacheKey(value, linked);
+    if (hasBase && (args.tracking?.currentCacheKey ?? args.lastSnapshot?.metadata?.state?.cacheKey) === cacheKey)
+      return;
+    const linkedText = linked.length ? `
+Linked items: ${linked.map((candidate) => `${workItemSource(candidate)} ${candidate.title}`).join("; ")}` : "";
+    const snapshotContents = `Factory ${board} phase: ${PHASE_LABELS[stage]} (${escapeText(stage)})
+Work item: ${escapeText(item.title)} (${item.id})
+Role: ${escapeText(binding.role)}
+Revision: ${item.revision}
+Rules: ${escapeText(this.options.rules.version)}
+Use factory_transition_work_item with expectedRevision ${item.revision} to request a phase change.${escapeText(linkedText)}`;
+    const isDelta = hasBase && prior?.status === "active";
+    return {
+      id: STATE_ID,
+      cacheKey,
+      mode: isDelta ? "delta" : "snapshot",
+      tagName: "factory-phase",
+      contents: isDelta ? `Factory phase update:
+${snapshotContents}` : snapshotContents,
+      value: { phase: value },
+      ...isDelta ? { delta: { phase: value } } : {},
+      attributes: { status: "active", board, stage, role: binding.role, revision: item.revision },
+      metadata: { value: { phase: value } }
+    };
+  }
+  async reconcileAllBoundThreads() {
+    if (!this.options.messageReader) return;
+    const bindings = await this.options.storage.listActiveRunBindings();
+    for (const binding of bindings) await this.reconcileBinding(binding);
+  }
+  async reconcileBinding(binding) {
+    const reader = this.options.messageReader;
+    if (!reader || binding.status !== "active") return;
+    const cursor = await this.options.storage.getToolResultCursor(binding.orgId, binding.factoryProjectId, binding.id);
+    let page = 0;
+    while (true) {
+      const result = await reader.listMessages({
+        threadId: binding.threadId,
+        resourceId: binding.resourceId,
+        page,
+        perPage: TRANSCRIPT_PAGE_SIZE,
+        ...cursor ? { filter: { dateRange: { start: cursor.lastMessageCreatedAt } } } : {},
+        orderBy: { field: "createdAt", direction: "ASC" }
+      });
+      await this.ingestMessages(binding, result.messages);
+      const last = result.messages.at(-1);
+      if (last) {
+        await this.options.storage.advanceToolResultCursor({
+          bindingId: binding.id,
+          orgId: binding.orgId,
+          factoryProjectId: binding.factoryProjectId,
+          lastMessageId: last.id,
+          lastMessageCreatedAt: last.createdAt instanceof Date ? last.createdAt : new Date(last.createdAt),
+          updatedAt: /* @__PURE__ */ new Date()
+        });
+      }
+      if (!result.hasMore) break;
+      page += 1;
+    }
+  }
+  async ingestMessages(binding, messages, toolCallIds) {
+    const item = await this.options.storage.get({ orgId: binding.orgId, id: binding.workItemId });
+    if (!item || item.stages.length !== 1 || !FACTORY_RULE_STAGES.includes(item.stages[0])) return;
+    for (const message of messages) {
+      for (const toolResult of completedToolResults(message)) {
+        if (toolCallIds && !toolCallIds.has(toolResult.toolCallId)) continue;
+        try {
+          await this.options.recordPullRequestProvenance?.({
+            binding,
+            item,
+            assistantMessageId: toolResult.assistantMessageId,
+            toolCallId: toolResult.toolCallId,
+            toolName: toolResult.toolName,
+            toolInput: toolResult.input,
+            toolResult: toolResult.value,
+            status: toolResult.status
+          });
+        } catch {
+        }
+        await this.ingestToolResult(binding, item, toolResult);
+      }
+    }
+  }
+  async ingestToolResult(binding, item, toolResult) {
+    const rule = resolveFactoryToolRule(this.options.rules, toolResult.toolName);
+    if (!rule) return;
+    const ingressId = JSON.stringify([
+      binding.id,
+      binding.threadId,
+      toolResult.assistantMessageId,
+      toolResult.toolCallId
+    ]);
+    const prior = await this.options.storage.getTransitionResultByIngress(
+      binding.orgId,
+      binding.factoryProjectId,
+      ingressId
+    );
+    if (prior) return;
+    const board = boardForItem(item);
+    const context = {
+      tenant: { orgId: binding.orgId, projectId: binding.factoryProjectId },
+      actor: { type: "agent", bindingId: binding.id, role: binding.role },
+      ingress: { type: "toolResult", id: ingressId },
+      cause: `Completed ${toolResult.toolName}`,
+      causalChain: [],
+      ruleSetVersion: this.options.rules.version,
+      item: {
+        id: item.id,
+        source: workItemSource(item),
+        sourceKey: workItemSourceKey(item),
+        parentWorkItemId: item.parentWorkItemId,
+        title: item.title,
+        url: item.externalSource?.url ?? null,
+        stages: item.stages
+      },
+      board,
+      itemRevision: item.revision,
+      toolName: toolResult.toolName,
+      threadId: binding.threadId,
+      assistantMessageId: toolResult.assistantMessageId,
+      toolCallId: toolResult.toolCallId,
+      result: { status: toolResult.status, value: toolResult.value }
+    };
+    let decision = void 0;
+    let decisions = [];
+    let outcome = { status: "accepted" };
+    try {
+      decision = await withRuleTimeout(Promise.resolve(rule(Object.freeze(context))));
+      if (decision?.type === "reject") {
+        outcome = { status: "rejected", code: decision.code, reason: decision.reason };
+      } else if (decision) {
+        decisions = validateFactoryRuleDecisions([decision]);
+      }
+    } catch (error) {
+      const timedOut = error instanceof Error && error.message === "FACTORY_RULE_TIMEOUT";
+      outcome = {
+        status: "rejected",
+        code: timedOut ? "timeout" : "rule_error",
+        reason: timedOut ? "Factory rule evaluation timed out." : error instanceof Error ? error.message.slice(0, 2e3) : "Factory tool-result rule failed."
+      };
+    }
+    const committed = await this.options.storage.commitRuleEvaluation({
+      orgId: binding.orgId,
+      factoryProjectId: binding.factoryProjectId,
+      workItemId: item.id,
+      ingress: { identity: ingressId, triggerType: "tool.result" },
+      ruleSetVersion: this.options.rules.version,
+      expectedRevision: item.revision,
+      actor: { ...context.actor },
+      outcome,
+      decisions: decisions.map((entry) => ({ ...entry })),
+      causalChain: [],
+      now: /* @__PURE__ */ new Date()
+    });
+    if (committed.status !== "committed" || !this.options.transitionService) return;
+    for (const entry of decisions) {
+      if (entry.type !== "transition") continue;
+      await this.options.transitionService.transition({
+        orgId: binding.orgId,
+        factoryProjectId: binding.factoryProjectId,
+        workItemId: item.id,
+        board: entry.board,
+        stage: entry.stage,
+        expectedRevision: item.revision,
+        actor: { type: "system", id: "factory-tool-result-rule" },
+        ingress: { type: "rule", identity: `decision:${entry.idempotencyKey}` },
+        cause: "tool_result_rule",
+        causalChain: [{ ingressId, decisionType: entry.type }]
+      });
+    }
+  }
+};
+export {
+  FactoryPhaseStateProcessor
+};
+//# sourceMappingURL=processor.js.map