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

package/dist/rules/processor.js

@@ -1,629 +1,377 @@
-// src/rules/processor.ts
+import { resolveFactoryToolRule } from "./resolve.js";
+import { FACTORY_RULE_STAGES } from "./types.js";
+import { normalizeFactoryRuleJsonValue, validateFactoryRuleDecisions } from "./validation.js";
+import { getFactorySessionCoordinates } from "./binding-context.js";
 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"
+//#region src/rules/processor.ts
+const STATE_ID = "factory-phase";
+const RULE_TIMEOUT_MS = 5e3;
+const TRANSCRIPT_PAGE_SIZE = 50;
+const MAX_LINKED_ITEMS = 5;
+const 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";
+	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;
+	const source = item.externalSource;
+	return source ? `${source.integrationId}:${source.type}:${source.externalId}` : null;
 }
 function boardForItem(item) {
-  return item.externalSource?.type === "pull-request" ? "review" : "work";
+	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) };
+	return { message: (value instanceof Error ? value.message : typeof value === "string" ? value : "Tool execution failed.").slice(0, 2e3) };
 }
 function boundedResult(value) {
-  try {
-    return normalizeFactoryRuleJsonValue(value);
-  } catch {
-    return { message: "Tool result was not serializable." };
-  }
+	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 : [];
+	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;
+	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;
+	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;
+	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;
+	}
 }
 function phaseCacheKey(value, linked) {
-  return createHash("sha256").update(
-    JSON.stringify({
-      ...value,
-      linked: linked.map((item) => [item.id, item.revision, item.stages[0]])
-    })
-  ).digest("hex");
+	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;");
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 function phaseFromSignal(signal) {
-  return signal?.metadata?.value?.phase;
+	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);
+	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);
-  }
+	let timer;
+	try {
+		return await Promise.race([operation, new Promise((_, reject) => {
+			timer = setTimeout(() => reject(/* @__PURE__ */ 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
+	options;
+	id = STATE_ID;
+	stateId = STATE_ID;
+	constructor(options) {
+		this.options = options;
+	}
+	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 linked = (await this.options.storage.list({
+			orgId: binding.orgId,
+			factoryProjectId: binding.factoryProjectId
+		})).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 ? `\nLinked items: ${linked.map((candidate) => `${workItemSource(candidate)} ${candidate.title}`).join("; ")}` : "";
+		const snapshotContents = `Factory ${board} phase: ${PHASE_LABELS[stage]} (${escapeText(stage)})\nWork item: ${escapeText(item.title)} (${item.id})\nRole: ${escapeText(binding.role)}\nRevision: ${item.revision}\nRules: ${escapeText(this.options.rules.version)}\nUse 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:\n${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
+		]);
+		if (await this.options.storage.getTransitionResultByIngress(binding.orgId, binding.factoryProjectId, ingressId)) 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."
+			};
+		}
+		if ((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()
+		})).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
+				}]
+			});
+		}
+	}
 };
+//#endregion
+export { FactoryPhaseStateProcessor };
+
 //# sourceMappingURL=processor.js.map