@mastra/factory 0.0.0 → 0.1.0-alpha.3

package/dist/storage/domains/work-items/base.js

@@ -0,0 +1,1174 @@
+// src/storage/domains/work-items/base.ts
+import { createHash } from "crypto";
+import { FactoryStorageDomain, UniqueViolationError } from "@mastra/core/storage";
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function factoryDecisionHash(decision) {
+  return createHash("sha256").update(stableJson(decision)).digest("hex");
+}
+var AUTOMATION_ACTORS = /* @__PURE__ */ new Set([
+  "factory",
+  "system",
+  "automation",
+  "factory-rule-dispatcher",
+  "factory-tool-result-rule"
+]);
+function isAutomationActor(by) {
+  if (by === void 0) return false;
+  return AUTOMATION_ACTORS.has(by) || by.startsWith("agent:") || by.startsWith("github:");
+}
+var WORK_ITEMS_SCHEMA = {
+  name: "work_items",
+  columns: {
+    id: { type: "uuid-pk" },
+    org_id: { type: "text" },
+    factory_project_id: { type: "text" },
+    external_source: { type: "json", nullable: true },
+    source_key: { type: "text", nullable: true },
+    parent_work_item_id: { type: "text", nullable: true },
+    title: { type: "text" },
+    stages: { type: "json" },
+    stage_history: { type: "json" },
+    sessions: { type: "json" },
+    metadata: { type: "json", nullable: true },
+    revision: { type: "integer", default: 1 },
+    created_by: { type: "text" },
+    created_at: { type: "timestamp" },
+    updated_at: { type: "timestamp" }
+  },
+  uniqueIndexes: [
+    {
+      name: "work_items_project_source_key_unique",
+      columns: ["factory_project_id", "source_key"]
+    }
+  ],
+  indexes: [
+    {
+      name: "work_items_org_project_updated_at_idx",
+      columns: ["org_id", "factory_project_id", "updated_at"]
+    },
+    {
+      name: "work_items_project_parent_idx",
+      columns: ["org_id", "factory_project_id", "parent_work_item_id"]
+    }
+  ]
+};
+function sourceKey(source) {
+  return source ? `${source.integrationId}:${source.type}:${source.externalId}` : null;
+}
+function toWorkItem(row) {
+  return {
+    id: row.id,
+    orgId: row.org_id,
+    factoryProjectId: String(row.factory_project_id),
+    externalSource: row.external_source,
+    parentWorkItemId: row.parent_work_item_id,
+    title: row.title,
+    stages: row.stages,
+    stageHistory: row.stage_history,
+    sessions: row.sessions,
+    metadata: row.metadata,
+    revision: row.revision,
+    createdBy: row.created_by,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+var toRow = toWorkItem;
+function patchColumns(changes) {
+  return {
+    ...changes.parentWorkItemId !== void 0 ? { parent_work_item_id: changes.parentWorkItemId } : {},
+    ...changes.title !== void 0 ? { title: changes.title } : {},
+    ...changes.stages !== void 0 ? { stages: changes.stages } : {},
+    ...changes.stageHistory !== void 0 ? { stage_history: changes.stageHistory } : {},
+    ...changes.sessions !== void 0 ? { sessions: changes.sessions } : {},
+    ...changes.metadata !== void 0 ? { metadata: changes.metadata } : {},
+    ...changes.revision !== void 0 ? { revision: changes.revision } : {},
+    ...changes.updatedAt !== void 0 ? { updated_at: changes.updatedAt } : {}
+  };
+}
+function emptyPrior() {
+  return { stages: [], sessionRoles: [] };
+}
+function priorState(row) {
+  return { stages: row.stages, sessionRoles: Object.keys(row.sessions) };
+}
+var WorkItemRelationError = class extends Error {
+  code = "invalid_work_item_relation";
+};
+function validateParentRelation(projectItems, itemId, parentWorkItemId) {
+  if (parentWorkItemId === null) return;
+  const byId = new Map(projectItems.map((item) => [item.id, item]));
+  const parent = byId.get(parentWorkItemId);
+  if (!parent) throw new WorkItemRelationError("Related work item not found in this project.");
+  if (itemId === parentWorkItemId) throw new WorkItemRelationError("A work item cannot relate to itself.");
+  const visited = /* @__PURE__ */ new Set();
+  let cursor = parent;
+  while (cursor?.parentWorkItemId) {
+    if (cursor.parentWorkItemId === itemId) {
+      throw new WorkItemRelationError("This relationship would create a cycle.");
+    }
+    if (visited.has(cursor.id)) throw new WorkItemRelationError("The related work item chain contains a cycle.");
+    visited.add(cursor.id);
+    cursor = byId.get(cursor.parentWorkItemId);
+  }
+}
+function applyStageTransition(history, oldStages, newStages, by, now) {
+  const timestamp = now.toISOString();
+  const next = history.map((entry) => ({ ...entry }));
+  for (const stage of oldStages) {
+    if (newStages.includes(stage)) continue;
+    for (let i = next.length - 1; i >= 0; i--) {
+      const entry = next[i];
+      if (entry.stage === stage && entry.exitedAt === void 0) {
+        entry.exitedAt = timestamp;
+        entry.exitedBy = by;
+        break;
+      }
+    }
+  }
+  for (const stage of newStages) {
+    if (!oldStages.includes(stage)) next.push({ stage, enteredAt: timestamp, by });
+  }
+  return next;
+}
+function stampSessions(sessions, by) {
+  return Object.fromEntries(Object.entries(sessions).map(([role, session]) => [role, { ...session, startedBy: by }]));
+}
+function applyUpdate({
+  current,
+  userId,
+  input
+}) {
+  const now = /* @__PURE__ */ new Date();
+  return {
+    ...input.parentWorkItemId !== void 0 ? { parent_work_item_id: input.parentWorkItemId } : {},
+    ...input.title !== void 0 ? { title: input.title } : {},
+    ...input.stages !== void 0 ? {
+      stages: input.stages,
+      stage_history: applyStageTransition(current.stage_history, current.stages, input.stages, userId, now)
+    } : {},
+    ...input.sessions !== void 0 ? { sessions: { ...current.sessions, ...stampSessions(input.sessions, userId) } } : {},
+    ...input.metadata !== void 0 ? { metadata: input.metadata === null ? null : { ...current.metadata ?? {}, ...input.metadata } } : {},
+    revision: current.revision + 1,
+    updated_at: now
+  };
+}
+var projectRelationLocks = /* @__PURE__ */ new Map();
+function withInProcessProjectLock(key, fn) {
+  const previous = projectRelationLocks.get(key) ?? Promise.resolve();
+  const result = previous.then(fn, fn);
+  const tail = result.then(
+    () => void 0,
+    () => void 0
+  );
+  projectRelationLocks.set(key, tail);
+  void tail.then(() => {
+    if (projectRelationLocks.get(key) === tail) projectRelationLocks.delete(key);
+  });
+  return result;
+}
+var FACTORY_GOVERNANCE_SCHEMAS = [
+  {
+    name: "factory_rule_ingress",
+    columns: {
+      id: { type: "uuid-pk" },
+      org_id: { type: "text" },
+      factory_project_id: { type: "text" },
+      identity: { type: "text" },
+      trigger_type: { type: "text" },
+      transition_id: { type: "text" },
+      result: { type: "json" },
+      created_at: { type: "timestamp" }
+    },
+    uniqueIndexes: [
+      { name: "factory_rule_ingress_tenant_identity_unique", columns: ["org_id", "factory_project_id", "identity"] }
+    ]
+  },
+  {
+    name: "factory_rule_evaluations",
+    columns: {
+      id: { type: "uuid-pk" },
+      ingress_id: { type: "text" },
+      work_item_id: { type: "text", nullable: true },
+      rule_set_version: { type: "text" },
+      expected_revision: { type: "integer", nullable: true },
+      outcome: { type: "text" },
+      code: { type: "text", nullable: true },
+      reason: { type: "text", nullable: true },
+      causal_chain: { type: "json" },
+      created_at: { type: "timestamp" }
+    }
+  },
+  {
+    name: "factory_deferred_decisions",
+    columns: {
+      id: { type: "uuid-pk" },
+      org_id: { type: "text" },
+      factory_project_id: { type: "text" },
+      evaluation_id: { type: "text" },
+      work_item_id: { type: "text", nullable: true },
+      idempotency_key: { type: "text" },
+      effect_ordinal: { type: "integer" },
+      effect_hash: { type: "text" },
+      causal_chain: { type: "json" },
+      actor: { type: "json", nullable: true },
+      decision: { type: "json" },
+      status: { type: "text" },
+      attempts: { type: "integer" },
+      available_at: { type: "timestamp" },
+      lease_owner: { type: "text", nullable: true },
+      lease_expires_at: { type: "timestamp", nullable: true },
+      last_error: { type: "text", nullable: true },
+      completed_at: { type: "timestamp", nullable: true },
+      created_at: { type: "timestamp" },
+      updated_at: { type: "timestamp" }
+    },
+    uniqueIndexes: [
+      {
+        name: "factory_deferred_decisions_tenant_key_unique",
+        columns: ["org_id", "factory_project_id", "idempotency_key"]
+      }
+    ]
+  },
+  {
+    name: "factory_run_bindings",
+    columns: {
+      id: { type: "uuid-pk" },
+      org_id: { type: "text" },
+      factory_project_id: { type: "text" },
+      work_item_id: { type: "text" },
+      role: { type: "text" },
+      thread_id: { type: "text" },
+      resource_id: { type: "text" },
+      session_id: { type: "text" },
+      branch: { type: "text" },
+      status: { type: "text" },
+      created_at: { type: "timestamp" },
+      revoked_at: { type: "timestamp", nullable: true }
+    }
+  },
+  {
+    name: "factory_tool_result_cursors",
+    columns: {
+      binding_id: { type: "text", primaryKey: true },
+      org_id: { type: "text" },
+      factory_project_id: { type: "text" },
+      last_message_id: { type: "text" },
+      last_message_created_at: { type: "timestamp" },
+      updated_at: { type: "timestamp" }
+    }
+  },
+  {
+    name: "factory_pending_starts",
+    columns: {
+      id: { type: "uuid-pk" },
+      org_id: { type: "text" },
+      factory_project_id: { type: "text" },
+      binding_id: { type: "text" },
+      kickoff_key: { type: "text" },
+      message: { type: "text", nullable: true },
+      status: { type: "text" },
+      attempts: { type: "integer" },
+      available_at: { type: "timestamp" },
+      lease_owner: { type: "text", nullable: true },
+      lease_expires_at: { type: "timestamp", nullable: true },
+      last_error: { type: "text", nullable: true },
+      completed_at: { type: "timestamp", nullable: true },
+      created_at: { type: "timestamp" },
+      updated_at: { type: "timestamp" }
+    },
+    uniqueIndexes: [
+      {
+        name: "factory_pending_starts_tenant_kickoff_unique",
+        columns: ["org_id", "factory_project_id", "kickoff_key"]
+      }
+    ]
+  }
+];
+function toBinding(row) {
+  return {
+    id: row.id,
+    orgId: row.org_id,
+    factoryProjectId: String(row.factory_project_id),
+    workItemId: String(row.work_item_id),
+    role: String(row.role),
+    threadId: String(row.thread_id),
+    resourceId: String(row.resource_id),
+    sessionId: String(row.session_id),
+    branch: String(row.branch),
+    status: row.status,
+    createdAt: row.created_at,
+    revokedAt: row.revoked_at ?? null
+  };
+}
+function toDeferredDecision(row) {
+  return {
+    id: row.id,
+    orgId: row.org_id,
+    factoryProjectId: String(row.factory_project_id),
+    evaluationId: String(row.evaluation_id),
+    workItemId: row.work_item_id === null || row.work_item_id === void 0 ? null : String(row.work_item_id),
+    idempotencyKey: String(row.idempotency_key),
+    effectOrdinal: Number(row.effect_ordinal),
+    effectHash: String(row.effect_hash),
+    causalChain: row.causal_chain ?? [],
+    actor: row.actor ?? null,
+    decision: row.decision,
+    status: row.status,
+    attempts: Number(row.attempts),
+    availableAt: row.available_at,
+    leaseOwner: row.lease_owner ?? null,
+    leaseExpiresAt: row.lease_expires_at ?? null,
+    lastError: row.last_error ?? null,
+    completedAt: row.completed_at ?? null,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function toPendingStart(row) {
+  return {
+    id: row.id,
+    orgId: row.org_id,
+    factoryProjectId: String(row.factory_project_id),
+    bindingId: String(row.binding_id),
+    kickoffKey: String(row.kickoff_key),
+    message: row.message ?? null,
+    status: row.status,
+    attempts: Number(row.attempts),
+    availableAt: row.available_at,
+    leaseOwner: row.lease_owner ?? null,
+    leaseExpiresAt: row.lease_expires_at ?? null,
+    lastError: row.last_error ?? null,
+    completedAt: row.completed_at ?? null,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+var WorkItemsStorage = class extends FactoryStorageDomain {
+  constructor() {
+    super("work-items");
+  }
+  async init() {
+    await this.ensureCollections([WORK_ITEMS_SCHEMA, ...FACTORY_GOVERNANCE_SCHEMAS]);
+  }
+  async dangerouslyClearAll() {
+    await this.ops.deleteMany("work_items", {});
+  }
+  #leaseQueue = Promise.resolve();
+  get #db() {
+    return this.ops;
+  }
+  async #withLocalLeaseLock(fn) {
+    const prior = this.#leaseQueue;
+    let release;
+    this.#leaseQueue = new Promise((resolve) => {
+      release = resolve;
+    });
+    await prior;
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+  async #withProjectRelationLock(orgId, factoryProjectId, fn) {
+    const key = `work-items:${orgId}:${factoryProjectId}`;
+    return withInProcessProjectLock(
+      key,
+      () => this.storage.withDistributedLock ? this.storage.withDistributedLock(key, fn) : fn()
+    );
+  }
+  async #claimLeases(table, input, map) {
+    const claim = () => this.storage.withTransaction(async (ops) => {
+      const candidates = await ops.findMany(table, {}, { orderBy: [["created_at", "asc"]] });
+      const claimed = [];
+      for (const candidate of candidates) {
+        if (claimed.length >= input.limit) break;
+        const availableAt = new Date(candidate.available_at).getTime();
+        const leaseExpiresAt = candidate.lease_expires_at ? new Date(candidate.lease_expires_at).getTime() : 0;
+        const claimable = (candidate.status === "pending" || candidate.status === "retry") && availableAt <= input.now.getTime();
+        const expired = candidate.status === "leased" && leaseExpiresAt <= input.now.getTime();
+        if (!claimable && !expired) continue;
+        let didClaim = false;
+        const row = await ops.updateAtomic(table, { id: candidate.id }, (current) => {
+          const currentAvailable = new Date(current.available_at).getTime();
+          const currentExpiry = current.lease_expires_at ? new Date(current.lease_expires_at).getTime() : 0;
+          const currentClaimable = (current.status === "pending" || current.status === "retry") && currentAvailable <= input.now.getTime();
+          const currentExpired = current.status === "leased" && currentExpiry <= input.now.getTime();
+          if (!currentClaimable && !currentExpired) return null;
+          didClaim = true;
+          return {
+            status: "leased",
+            attempts: Number(current.attempts) + 1,
+            lease_owner: input.ownerId,
+            lease_expires_at: input.leaseExpiresAt,
+            updated_at: input.now
+          };
+        });
+        if (didClaim && row) claimed.push(map(row));
+      }
+      return claimed;
+    });
+    return this.storage.withDistributedLock ? this.storage.withDistributedLock(`factory-lease:${table}`, claim) : this.#withLocalLeaseLock(claim);
+  }
+  async #renewLease(table, identity, leaseExpiresAt) {
+    let renewed = false;
+    await this.#db.updateAtomic(
+      table,
+      { id: identity.id, org_id: identity.orgId, factory_project_id: identity.factoryProjectId },
+      (current) => {
+        if (current.status !== "leased" || current.lease_owner !== identity.ownerId) return null;
+        renewed = true;
+        return { lease_expires_at: leaseExpiresAt, updated_at: /* @__PURE__ */ new Date() };
+      }
+    );
+    return renewed;
+  }
+  async #completeLease(table, identity, now) {
+    let completed = false;
+    const row = await this.#db.updateAtomic(
+      table,
+      { id: identity.id, org_id: identity.orgId, factory_project_id: identity.factoryProjectId },
+      (current) => {
+        if (current.status !== "leased" || current.lease_owner !== identity.ownerId) return null;
+        completed = true;
+        return {
+          status: table === "factory_pending_starts" ? "sent" : "succeeded",
+          lease_owner: null,
+          lease_expires_at: null,
+          completed_at: now,
+          updated_at: now
+        };
+      }
+    );
+    return completed ? row : null;
+  }
+  async #failLease(table, input) {
+    let failed = false;
+    const row = await this.#db.updateAtomic(
+      table,
+      { id: input.id, org_id: input.orgId, factory_project_id: input.factoryProjectId },
+      (current) => {
+        if (current.status !== "leased" || current.lease_owner !== input.ownerId) return null;
+        failed = true;
+        return {
+          status: input.terminal ? "failed" : "retry",
+          available_at: input.availableAt,
+          lease_owner: null,
+          lease_expires_at: null,
+          last_error: input.lastError,
+          completed_at: input.terminal ? input.now : null,
+          updated_at: input.now
+        };
+      }
+    );
+    return failed ? row : null;
+  }
+  /** List the org's work items for a project, newest first. */
+  async list({ orgId, factoryProjectId }) {
+    const rows = await this.#db.findMany(
+      "work_items",
+      { org_id: orgId, factory_project_id: factoryProjectId },
+      { orderBy: [["updated_at", "desc"]] }
+    );
+    return rows.map(toWorkItem);
+  }
+  async get({ orgId, id }) {
+    const row = await this.#db.findOne("work_items", { org_id: orgId, id });
+    return row ? toWorkItem(row) : null;
+  }
+  async getForProject(orgId, factoryProjectId, id) {
+    const row = await this.#db.findOne("work_items", {
+      id,
+      org_id: orgId,
+      factory_project_id: factoryProjectId
+    });
+    return row ? toRow(row) : null;
+  }
+  async getTransitionResultByIngress(orgId, factoryProjectId, identity) {
+    const row = await this.#db.findOne("factory_rule_ingress", {
+      org_id: orgId,
+      factory_project_id: factoryProjectId,
+      identity
+    });
+    return row?.result ?? null;
+  }
+  async commitTransition(input) {
+    const commit = () => this.storage.withTransaction(async (ops) => {
+      const prior = await ops.findOne("factory_rule_ingress", {
+        org_id: input.orgId,
+        factory_project_id: input.factoryProjectId,
+        identity: input.ingress.identity
+      });
+      if (prior)
+        return {
+          status: "replayed",
+          item: await this.getForProject(input.orgId, input.factoryProjectId, input.workItemId),
+          result: prior.result
+        };
+      const now = /* @__PURE__ */ new Date();
+      let item = null;
+      let code = null;
+      let reason = null;
+      let result;
+      const updated = await ops.updateAtomic(
+        "work_items",
+        {
+          id: input.workItemId,
+          org_id: input.orgId,
+          factory_project_id: input.factoryProjectId
+        },
+        (row) => {
+          const existing = toRow(row);
+          item = existing;
+          if (existing.revision !== input.expectedRevision) {
+            code = "stale";
+            reason = "The work item changed before this transition committed.";
+            return null;
+          }
+          if (input.evaluation.outcome === "rejected") {
+            code = input.evaluation.code;
+            reason = input.evaluation.reason;
+            return null;
+          }
+          if (existing.stages.length === 1 && existing.stages[0] === input.destinationStage) return null;
+          return patchColumns({
+            stages: [input.destinationStage],
+            stageHistory: applyStageTransition(
+              existing.stageHistory,
+              existing.stages,
+              [input.destinationStage],
+              input.actorId,
+              now
+            ),
+            revision: existing.revision + 1,
+            updatedAt: now
+          });
+        }
+      );
+      if (updated) item = toRow(updated);
+      if (!item) {
+        code = input.evaluation.outcome === "rejected" ? input.evaluation.code : "invalid_transition";
+        reason = input.evaluation.outcome === "rejected" ? input.evaluation.reason : "Work item not found.";
+      }
+      const outcome = item && code === null && input.evaluation.outcome === "accepted" ? "accepted" : "rejected";
+      result = outcome === "accepted" ? {
+        status: "accepted",
+        transitionId: input.ingress.transitionId,
+        itemId: item.id,
+        revision: item.revision,
+        stage: input.destinationStage,
+        decisions: input.evaluation.outcome === "accepted" ? input.evaluation.decisions : []
+      } : { status: "rejected", transitionId: input.ingress.transitionId, itemId: input.workItemId, code, reason };
+      const ingress = await ops.insertOne("factory_rule_ingress", {
+        org_id: input.orgId,
+        factory_project_id: input.factoryProjectId,
+        identity: input.ingress.identity,
+        trigger_type: input.ingress.triggerType,
+        transition_id: input.ingress.transitionId,
+        result,
+        created_at: now
+      });
+      if (item) {
+        const evaluation = await ops.insertOne("factory_rule_evaluations", {
+          ingress_id: ingress.id,
+          work_item_id: item.id,
+          rule_set_version: input.ruleSetVersion,
+          expected_revision: input.expectedRevision,
+          outcome,
+          code,
+          reason,
+          causal_chain: input.causalChain,
+          created_at: now
+        });
+        if (outcome === "accepted" && input.evaluation.outcome === "accepted") {
+          for (const [index, decision] of input.evaluation.decisions.entries()) {
+            await ops.insertOne("factory_deferred_decisions", {
+              org_id: input.orgId,
+              factory_project_id: input.factoryProjectId,
+              evaluation_id: evaluation.id,
+              work_item_id: item.id,
+              idempotency_key: String(decision.idempotencyKey),
+              effect_ordinal: index,
+              effect_hash: factoryDecisionHash(decision),
+              causal_chain: input.causalChain,
+              actor: null,
+              decision,
+              status: "pending",
+              attempts: 0,
+              available_at: now,
+              lease_owner: null,
+              lease_expires_at: null,
+              last_error: null,
+              completed_at: null,
+              created_at: new Date(now.getTime() + index),
+              updated_at: now
+            });
+          }
+        }
+      }
+      return { status: "committed", item, result };
+    });
+    return this.storage.withDistributedLock ? this.storage.withDistributedLock(
+      `factory-ingress:${input.orgId}:${input.factoryProjectId}:${input.ingress.identity}`,
+      commit
+    ) : commit();
+  }
+  async commitRuleEvaluation(input) {
+    const commit = () => this.storage.withTransaction(async (ops) => {
+      const prior = await ops.findOne("factory_rule_ingress", {
+        org_id: input.orgId,
+        factory_project_id: input.factoryProjectId,
+        identity: input.ingress.identity
+      });
+      if (prior) {
+        const result2 = prior.result;
+        const decisions2 = Array.isArray(result2.decisions) ? result2.decisions : [];
+        const evaluation2 = await ops.findOne("factory_rule_evaluations", { ingress_id: prior.id });
+        for (const decision of decisions2) {
+          if (!evaluation2 || !decision || typeof decision !== "object" || decision.type !== "upsertLinkedWorkItem" || typeof decision.sourceKey !== "string" || typeof decision.idempotencyKey !== "string") {
+            continue;
+          }
+          const materialization = decision;
+          const item2 = await ops.findOne("work_items", {
+            org_id: input.orgId,
+            factory_project_id: input.factoryProjectId,
+            source_key: materialization.sourceKey
+          });
+          if (item2) continue;
+          await ops.updateAtomic(
+            "factory_deferred_decisions",
+            {
+              org_id: input.orgId,
+              factory_project_id: input.factoryProjectId,
+              evaluation_id: evaluation2.id,
+              idempotency_key: materialization.idempotencyKey
+            },
+            (current) => current.status === "succeeded" ? {
+              status: "retry",
+              attempts: 0,
+              available_at: input.now,
+              lease_owner: null,
+              lease_expires_at: null,
+              last_error: null,
+              completed_at: null,
+              updated_at: input.now
+            } : null
+          );
+        }
+        return { status: "replayed", result: result2 };
+      }
+      const itemRow = input.workItemId ? await ops.findOne("work_items", {
+        id: input.workItemId,
+        org_id: input.orgId,
+        factory_project_id: input.factoryProjectId
+      }) : null;
+      if (input.workItemId !== null && !itemRow) return { status: "missing" };
+      const item = itemRow ? toRow(itemRow) : null;
+      const stale = item !== null && item.revision !== input.expectedRevision;
+      const outcome = stale ? "rejected" : input.outcome.status;
+      const code = stale ? "stale" : input.outcome.code ?? null;
+      const reason = stale ? "The work item changed before this rule evaluation committed." : input.outcome.reason ?? null;
+      const decisions = outcome === "accepted" ? input.decisions : [];
+      const result = {
+        status: outcome,
+        itemId: item?.id ?? null,
+        revision: item?.revision ?? null,
+        code,
+        reason,
+        decisions
+      };
+      const ingress = await ops.insertOne("factory_rule_ingress", {
+        org_id: input.orgId,
+        factory_project_id: input.factoryProjectId,
+        identity: input.ingress.identity,
+        trigger_type: input.ingress.triggerType,
+        transition_id: input.ingress.identity,
+        result,
+        created_at: input.now
+      });
+      const evaluation = await ops.insertOne("factory_rule_evaluations", {
+        ingress_id: ingress.id,
+        work_item_id: item?.id ?? null,
+        rule_set_version: input.ruleSetVersion,
+        expected_revision: input.expectedRevision,
+        outcome,
+        code,
+        reason,
+        causal_chain: input.causalChain,
+        created_at: input.now
+      });
+      for (const [effectOrdinal, decision] of decisions.entries()) {
+        await ops.insertOne("factory_deferred_decisions", {
+          org_id: input.orgId,
+          factory_project_id: input.factoryProjectId,
+          evaluation_id: evaluation.id,
+          work_item_id: item?.id ?? null,
+          idempotency_key: String(decision.idempotencyKey),
+          effect_ordinal: effectOrdinal,
+          effect_hash: factoryDecisionHash(decision),
+          causal_chain: input.causalChain,
+          actor: input.actor,
+          decision,
+          status: "pending",
+          attempts: 0,
+          available_at: input.now,
+          lease_owner: null,
+          lease_expires_at: null,
+          last_error: null,
+          completed_at: null,
+          created_at: new Date(input.now.getTime() + effectOrdinal),
+          updated_at: input.now
+        });
+      }
+      return { status: "committed", result };
+    });
+    return this.storage.withDistributedLock ? this.storage.withDistributedLock(
+      `factory-ingress:${input.orgId}:${input.factoryProjectId}:${input.ingress.identity}`,
+      commit
+    ) : commit();
+  }
+  async getToolResultCursor(orgId, factoryProjectId, bindingId) {
+    const row = await this.#db.findOne("factory_tool_result_cursors", {
+      org_id: orgId,
+      factory_project_id: factoryProjectId,
+      binding_id: bindingId
+    });
+    return row ? {
+      bindingId: String(row.binding_id),
+      orgId: row.org_id,
+      factoryProjectId: String(row.factory_project_id),
+      lastMessageId: String(row.last_message_id),
+      lastMessageCreatedAt: row.last_message_created_at,
+      updatedAt: row.updated_at
+    } : null;
+  }
+  async advanceToolResultCursor(cursor) {
+    const current = await this.getToolResultCursor(cursor.orgId, cursor.factoryProjectId, cursor.bindingId);
+    if (current && current.lastMessageCreatedAt > cursor.lastMessageCreatedAt) return;
+    await this.#db.upsertOne("factory_tool_result_cursors", ["binding_id"], {
+      binding_id: cursor.bindingId,
+      org_id: cursor.orgId,
+      factory_project_id: cursor.factoryProjectId,
+      last_message_id: cursor.lastMessageId,
+      last_message_created_at: cursor.lastMessageCreatedAt,
+      updated_at: cursor.updatedAt
+    });
+  }
+  async listDeferredDecisions(orgId, factoryProjectId) {
+    return (await this.#db.findMany(
+      "factory_deferred_decisions",
+      { org_id: orgId, factory_project_id: factoryProjectId },
+      { orderBy: [["created_at", "asc"]] }
+    )).map(toDeferredDecision);
+  }
+  /** Read a bounded newest-first status page without exposing another tenant. */
+  async listDeferredDecisionPage(input) {
+    const rows = await this.#db.findMany(
+      "factory_deferred_decisions",
+      {
+        org_id: input.orgId,
+        factory_project_id: input.factoryProjectId,
+        ...input.statuses ? { status: { in: input.statuses } } : {}
+      },
+      {
+        orderBy: [
+          ["created_at", "desc"],
+          ["id", "desc"]
+        ],
+        limit: input.limit + 1,
+        ...input.before ? { cursor: { values: [input.before.createdAt, input.before.id] } } : {}
+      }
+    );
+    return { decisions: rows.slice(0, input.limit).map(toDeferredDecision), hasMore: rows.length > input.limit };
+  }
+  async claimDeferredDecisions(input) {
+    return this.#claimLeases("factory_deferred_decisions", input, toDeferredDecision);
+  }
+  async renewDeferredDecisionLease(identity, leaseExpiresAt) {
+    return this.#renewLease("factory_deferred_decisions", identity, leaseExpiresAt);
+  }
+  async completeDeferredDecision(identity, now) {
+    const row = await this.#completeLease("factory_deferred_decisions", identity, now);
+    return row ? toDeferredDecision(row) : null;
+  }
+  async failDeferredDecision(input) {
+    const row = await this.#failLease("factory_deferred_decisions", input);
+    return row ? toDeferredDecision(row) : null;
+  }
+  /** Requeue the same idempotent terminal effect; non-failed decisions are never rerun. */
+  async retryDeferredDecision(orgId, factoryProjectId, decisionId, now) {
+    let retried = false;
+    const row = await this.#db.updateAtomic(
+      "factory_deferred_decisions",
+      { id: decisionId, org_id: orgId, factory_project_id: factoryProjectId },
+      (current) => {
+        if (current.status !== "failed") return null;
+        retried = true;
+        return {
+          status: "retry",
+          attempts: 0,
+          available_at: now,
+          lease_owner: null,
+          lease_expires_at: null,
+          last_error: null,
+          completed_at: null,
+          updated_at: now
+        };
+      }
+    );
+    return retried && row ? toDeferredDecision(row) : null;
+  }
+  /** Resolve exact active agent authority; partial session matches never authorize. */
+  async findActiveRunBinding(address) {
+    const row = await this.#db.findOne("factory_run_bindings", {
+      org_id: address.orgId,
+      factory_project_id: address.factoryProjectId,
+      thread_id: address.threadId,
+      resource_id: address.resourceId,
+      session_id: address.sessionId,
+      status: "active"
+    });
+    return row ? toBinding(row) : null;
+  }
+  /** Resolve exact bound-session state for processor awareness; ambiguous cross-tenant matches return null. */
+  async findRunBindingBySession(address) {
+    const rows = await this.#db.findMany("factory_run_bindings", {
+      factory_project_id: address.factoryProjectId,
+      thread_id: address.threadId,
+      resource_id: address.resourceId,
+      session_id: address.sessionId
+    });
+    if (new Set(rows.map((row2) => row2.org_id)).size !== 1) return null;
+    const row = rows.sort((left, right) => {
+      if (left.status === "active" && right.status !== "active") return -1;
+      if (right.status === "active" && left.status !== "active") return 1;
+      return right.created_at.getTime() - left.created_at.getTime();
+    })[0];
+    return row ? toBinding(row) : null;
+  }
+  /** Revoke one exact tenant-scoped binding. */
+  async revokeRunBinding(input) {
+    let revoked = false;
+    const row = await this.#db.updateAtomic(
+      "factory_run_bindings",
+      { id: input.bindingId, org_id: input.orgId, factory_project_id: input.factoryProjectId },
+      (current) => {
+        if (current.status !== "active") return null;
+        revoked = true;
+        return { status: "revoked", revoked_at: input.revokedAt };
+      }
+    );
+    return revoked && row ? toBinding(row) : null;
+  }
+  /** Enumerate active bindings for the server-owned restart reconciler. */
+  async listActiveRunBindings() {
+    return (await this.#db.findMany("factory_run_bindings", { status: "active" })).map(toBinding);
+  }
+  /** List binding history, optionally narrowed to one work item. */
+  async listRunBindings(orgId, factoryProjectId, workItemId) {
+    return (await this.#db.findMany(
+      "factory_run_bindings",
+      {
+        org_id: orgId,
+        factory_project_id: factoryProjectId,
+        ...workItemId ? { work_item_id: workItemId } : {}
+      },
+      { orderBy: [["created_at", "asc"]] }
+    )).map(toBinding);
+  }
+  async listPendingStarts(orgId, factoryProjectId) {
+    return (await this.#db.findMany(
+      "factory_pending_starts",
+      { org_id: orgId, factory_project_id: factoryProjectId },
+      { orderBy: [["created_at", "asc"]] }
+    )).map(toPendingStart);
+  }
+  async claimPendingStarts(input) {
+    return this.#claimLeases("factory_pending_starts", input, toPendingStart);
+  }
+  async renewPendingStartLease(identity, leaseExpiresAt) {
+    return this.#renewLease("factory_pending_starts", identity, leaseExpiresAt);
+  }
+  async completePendingStart(identity, now) {
+    const row = await this.#completeLease("factory_pending_starts", identity, now);
+    return row ? toPendingStart(row) : null;
+  }
+  async failPendingStart(input) {
+    const row = await this.#failLease("factory_pending_starts", input);
+    return row ? toPendingStart(row) : null;
+  }
+  async prepareRunStart(input) {
+    const prepare = () => this.storage.withTransaction(async (ops) => {
+      const prior = await ops.findOne("factory_pending_starts", {
+        org_id: input.orgId,
+        factory_project_id: input.factoryProjectId,
+        kickoff_key: input.kickoffKey
+      });
+      if (prior) {
+        const bindingRow2 = await ops.findOne("factory_run_bindings", {
+          id: String(prior.binding_id),
+          org_id: input.orgId,
+          factory_project_id: input.factoryProjectId
+        });
+        const itemRow = bindingRow2 && await ops.findOne("work_items", {
+          id: String(bindingRow2.work_item_id),
+          org_id: input.orgId,
+          factory_project_id: input.factoryProjectId
+        });
+        if (!bindingRow2 || !itemRow) throw new Error("Factory start replay references missing state.");
+        return {
+          item: toRow(itemRow),
+          binding: toBinding(bindingRow2),
+          pendingStart: toPendingStart(prior),
+          replayed: true
+        };
+      }
+      const now = /* @__PURE__ */ new Date();
+      const create = input.workItem.input;
+      let row = input.workItem.id ? await ops.findOne("work_items", {
+        id: input.workItem.id,
+        org_id: input.orgId,
+        factory_project_id: input.factoryProjectId
+      }) : sourceKey(create.externalSource) ? await ops.findOne("work_items", {
+        org_id: input.orgId,
+        factory_project_id: input.factoryProjectId,
+        source_key: sourceKey(create.externalSource)
+      }) : null;
+      let item;
+      if (row) {
+        row = await ops.updateAtomic("work_items", { id: row.id }, (current) => {
+          const roles = /* @__PURE__ */ new Set([...Object.keys(current.sessions), input.role]);
+          const sessions = Object.fromEntries([...roles].map((role) => [role, input.session]));
+          return applyUpdate({ current, userId: input.userId, input: { sessions } });
+        });
+        item = toRow(row);
+      } else {
+        if (create.parentWorkItemId)
+          validateParentRelation(
+            (await ops.findMany("work_items", {
+              org_id: input.orgId,
+              factory_project_id: input.factoryProjectId
+            })).map(toRow),
+            void 0,
+            create.parentWorkItemId
+          );
+        row = await ops.insertOne("work_items", {
+          org_id: input.orgId,
+          created_by: input.userId,
+          factory_project_id: input.factoryProjectId,
+          external_source: create.externalSource ?? null,
+          source_key: sourceKey(create.externalSource),
+          parent_work_item_id: create.parentWorkItemId ?? null,
+          title: create.title,
+          stages: create.stages ?? [],
+          stage_history: applyStageTransition([], [], create.stages ?? [], input.userId, now),
+          sessions: stampSessions({ [input.role]: input.session }, input.userId),
+          metadata: create.metadata ?? null,
+          revision: 1,
+          created_at: now,
+          updated_at: now
+        });
+        item = toRow(row);
+      }
+      await ops.updateMany(
+        "factory_run_bindings",
+        {
+          org_id: input.orgId,
+          factory_project_id: input.factoryProjectId,
+          work_item_id: item.id,
+          role: input.role,
+          status: "active"
+        },
+        { status: "revoked", revoked_at: now }
+      );
+      const bindingRow = await ops.insertOne("factory_run_bindings", {
+        org_id: input.orgId,
+        factory_project_id: input.factoryProjectId,
+        work_item_id: item.id,
+        role: input.role,
+        thread_id: input.session.threadId,
+        resource_id: input.resourceId,
+        session_id: input.session.sessionId,
+        branch: input.session.branch,
+        status: "active",
+        created_at: now,
+        revoked_at: null
+      });
+      const pendingRow = await ops.insertOne("factory_pending_starts", {
+        org_id: input.orgId,
+        factory_project_id: input.factoryProjectId,
+        binding_id: bindingRow.id,
+        kickoff_key: input.kickoffKey,
+        message: input.kickoffMessage,
+        status: "pending",
+        attempts: 0,
+        available_at: now,
+        lease_owner: null,
+        lease_expires_at: null,
+        last_error: null,
+        completed_at: null,
+        created_at: now,
+        updated_at: now
+      });
+      return { item, binding: toBinding(bindingRow), pendingStart: toPendingStart(pendingRow), replayed: false };
+    });
+    return this.storage.withDistributedLock ? this.storage.withDistributedLock(
+      `factory-start:${input.orgId}:${input.factoryProjectId}:${input.kickoffKey}`,
+      prepare
+    ) : prepare();
+  }
+  async markPendingStart(bindingId, status, lastError) {
+    const row = await this.#db.updateAtomic(
+      "factory_pending_starts",
+      { binding_id: bindingId },
+      () => ({ status, last_error: lastError ?? null, updated_at: /* @__PURE__ */ new Date() })
+    );
+    return row ? toPendingStart(row) : null;
+  }
+  /**
+   * Create a work item, reusing the existing record when `sourceKey` already
+   * has one for the project (acting twice on the same issue must not duplicate
+   * the card). On reuse the provided stages replace the current ones (with the
+   * transition recorded in history) and sessions/metadata are merged in. The
+   * result discriminates insert from reuse so callers can audit the actual
+   * outcome.
+   */
+  async upsert(params) {
+    const run = () => this.#upsert(params);
+    return params.input.parentWorkItemId ? this.#withProjectRelationLock(params.orgId, params.factoryProjectId, run) : run();
+  }
+  async #upsert({
+    orgId,
+    userId,
+    factoryProjectId,
+    input,
+    reuseMode = "update"
+  }) {
+    const key = sourceKey(input.externalSource);
+    const reuse = async () => {
+      if (!key) return null;
+      const existing = await this.#db.findOne("work_items", {
+        org_id: orgId,
+        factory_project_id: factoryProjectId,
+        source_key: key
+      });
+      if (!existing) return null;
+      if (reuseMode === "preserve") {
+        const item = toWorkItem(existing);
+        return { created: false, item, previous: priorState(existing) };
+      }
+      let previous = emptyPrior();
+      const updated = await this.#db.updateAtomic(
+        "work_items",
+        { org_id: orgId, factory_project_id: factoryProjectId, source_key: key },
+        async (current) => {
+          previous = priorState(current);
+          const fullPatch = input.parentWorkItemId === null ? { ...input, parentWorkItemId: void 0 } : input;
+          const patch = reuseMode === "non-stage" ? {
+            title: input.title,
+            parentWorkItemId: input.parentWorkItemId ?? void 0,
+            metadata: input.metadata
+          } : fullPatch;
+          if (patch.parentWorkItemId !== void 0) {
+            validateParentRelation(await this.list({ orgId, factoryProjectId }), current.id, patch.parentWorkItemId);
+          }
+          return {
+            external_source: input.externalSource ?? null,
+            ...applyUpdate({ current, userId, input: patch })
+          };
+        }
+      );
+      return updated ? { item: toWorkItem(updated), created: false, previous } : null;
+    };
+    const reused = await reuse();
+    if (reused) return reused;
+    const now = /* @__PURE__ */ new Date();
+    const stages = input.stages ?? ["intake"];
+    try {
+      validateParentRelation(await this.list({ orgId, factoryProjectId }), void 0, input.parentWorkItemId ?? null);
+      const row = await this.#db.insertOne("work_items", {
+        org_id: orgId,
+        factory_project_id: factoryProjectId,
+        external_source: input.externalSource ?? null,
+        source_key: key,
+        parent_work_item_id: input.parentWorkItemId ?? null,
+        title: input.title,
+        stages,
+        stage_history: stages.map((stage) => ({ stage, enteredAt: now.toISOString(), by: userId })),
+        sessions: stampSessions(input.sessions ?? {}, userId),
+        metadata: input.metadata ?? null,
+        revision: 1,
+        created_by: userId,
+        created_at: now,
+        updated_at: now
+      });
+      return { item: toWorkItem(row), created: true, previous: emptyPrior() };
+    } catch (error) {
+      if (!(error instanceof UniqueViolationError)) throw error;
+      const winner = await reuse();
+      if (winner) return winner;
+      throw error;
+    }
+  }
+  async update({
+    orgId,
+    id,
+    userId,
+    patch
+  }) {
+    const run = async () => {
+      let previous = emptyPrior();
+      const row = await this.#db.updateAtomic("work_items", { org_id: orgId, id }, async (current) => {
+        previous = priorState(current);
+        if (patch.parentWorkItemId !== void 0) {
+          validateParentRelation(
+            await this.list({ orgId, factoryProjectId: current.factory_project_id }),
+            current.id,
+            patch.parentWorkItemId
+          );
+        }
+        return applyUpdate({ current, userId, input: patch });
+      });
+      return row ? { item: toWorkItem(row), previous } : null;
+    };
+    if (patch.parentWorkItemId === void 0) return run();
+    const candidate = await this.#db.findOne("work_items", { org_id: orgId, id });
+    if (!candidate) return null;
+    return this.#withProjectRelationLock(orgId, candidate.factory_project_id, run);
+  }
+  async delete({ orgId, id }) {
+    const candidate = await this.#db.findOne("work_items", { org_id: orgId, id });
+    if (!candidate) return null;
+    return this.#withProjectRelationLock(orgId, candidate.factory_project_id, async () => {
+      const existing = await this.#db.findOne("work_items", { org_id: orgId, id });
+      if (!existing) return null;
+      const deleted = await this.#db.deleteMany("work_items", { org_id: orgId, id });
+      if (deleted === 0) return null;
+      await this.#db.updateMany(
+        "work_items",
+        { org_id: orgId, parent_work_item_id: id },
+        { parent_work_item_id: null, updated_at: /* @__PURE__ */ new Date() }
+      );
+      return toWorkItem(existing);
+    });
+  }
+};
+export {
+  AUTOMATION_ACTORS,
+  WORK_ITEMS_SCHEMA,
+  WorkItemRelationError,
+  WorkItemsStorage,
+  applyStageTransition,
+  factoryDecisionHash,
+  isAutomationActor,
+  stampSessions,
+  validateParentRelation
+};
+//# sourceMappingURL=base.js.map