@mastra/factory 0.2.1-alpha.2 → 0.2.1-alpha.4

package/dist/integrations/platform/github/integration.js

@@ -93,95 +93,8 @@ async function clearGithubPat(storage, orgId, kind = "default") {
   await storage.settings.save(orgId, PAT_SETTINGS_USER_ID, rest);
 }
 
-// src/integrations/github/project-lock.ts
-import { createHash } from "crypto";
-var inProcessLocks = /* @__PURE__ */ new Map();
-var DEFAULT_PROJECT_LOCK_TIMEOUT_MS = 6e4;
-var ProjectLockTimeoutError = class extends Error {
-  key;
-  timeoutMs;
-  constructor(key, timeoutMs) {
-    super(`Project lock critical section for "${key}" exceeded ${timeoutMs}ms`);
-    this.name = "ProjectLockTimeoutError";
-    this.key = key;
-    this.timeoutMs = timeoutMs;
-  }
-};
-async function runWithTimeout(key, timeoutMs, fn) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  const abortError = new Promise((_, reject) => {
-    controller.signal.addEventListener("abort", () => reject(new ProjectLockTimeoutError(key, timeoutMs)), {
-      once: true
-    });
-  });
-  const work = fn(controller.signal);
-  work.catch(() => {
-  });
-  try {
-    return await Promise.race([work, abortError]);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-function hashKey(key) {
-  const digest = createHash("sha256").update(key).digest();
-  const a = digest.readInt32BE(0);
-  const b = digest.readInt32BE(4);
-  return [a, b];
-}
-function withProjectLock(options) {
-  const { key, storage, fn, pool, timeoutMs = DEFAULT_PROJECT_LOCK_TIMEOUT_MS } = options;
-  const prev = inProcessLocks.get(key) ?? Promise.resolve();
-  const run = () => withDbAdvisoryLock({ key, storage, fn, pool, timeoutMs });
-  const next = prev.then(run, run);
-  const tail = next.then(
-    () => void 0,
-    () => void 0
-  );
-  inProcessLocks.set(key, tail);
-  void tail.then(() => {
-    if (inProcessLocks.get(key) === tail) {
-      inProcessLocks.delete(key);
-    }
-  });
-  return next;
-}
-async function withDbAdvisoryLock(options) {
-  const { key, storage, fn, pool, timeoutMs = DEFAULT_PROJECT_LOCK_TIMEOUT_MS } = options;
-  if (process.env.MASTRACODE_DISTRIBUTED_LOCK === "0") {
-    return runWithTimeout(key, timeoutMs, fn);
-  }
-  if (pool) return advisoryLockOver(pool, key, timeoutMs, fn);
-  if (typeof storage?.withDistributedLock !== "function") {
-    return runWithTimeout(key, timeoutMs, fn);
-  }
-  return storage.withDistributedLock(key, () => runWithTimeout(key, timeoutMs, fn));
-}
-async function advisoryLockOver(pool, key, timeoutMs, fn) {
-  const [k1, k2] = hashKey(key);
-  const client = await pool.connect();
-  try {
-    await client.query("BEGIN");
-    await client.query("SELECT pg_advisory_xact_lock($1, $2)", [k1, k2]);
-    try {
-      const result = await runWithTimeout(key, timeoutMs, fn);
-      await client.query("COMMIT");
-      return result;
-    } catch (err) {
-      try {
-        await client.query("ROLLBACK");
-      } catch {
-      }
-      throw err;
-    }
-  } finally {
-    client.release();
-  }
-}
-
 // src/integrations/github/sandbox.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash } from "crypto";
 function bindingStore(row, storage) {
   return {
     sandboxId: row.sandboxId,
@@ -377,7 +290,7 @@ var WorktreeError = class extends Error {
 function safeBranchDir(branch) {
   const sanitized = branch.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/\/+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, 100) || "work";
   if (sanitized === branch) return sanitized;
-  const hash = createHash2("sha256").update(branch).digest("hex").slice(0, 8);
+  const hash = createHash("sha256").update(branch).digest("hex").slice(0, 8);
   return `${sanitized}-${hash}`;
 }
 function computeWorktreePath(repoWorkdir, branch) {
@@ -799,6 +712,20 @@ async function handleGithubWebhook(c, options) {
 }
 
 // src/integrations/github/routes.ts
+var sessionOperationLocks = /* @__PURE__ */ new Map();
+function withSessionOperationLock(sessionId, fn) {
+  const previous = sessionOperationLocks.get(sessionId) ?? Promise.resolve();
+  const next = previous.then(fn, fn);
+  const tail = next.then(
+    () => void 0,
+    () => void 0
+  );
+  sessionOperationLocks.set(sessionId, tail);
+  void tail.then(() => {
+    if (sessionOperationLocks.get(sessionId) === tail) sessionOperationLocks.delete(sessionId);
+  });
+  return next;
+}
 function loose(c) {
   return c;
 }
@@ -818,8 +745,8 @@ function pullRequestNumberFromUrl(value, expectedRepo) {
     if (url.protocol !== "https:" || url.hostname !== "github.com" || match?.[1]?.toLowerCase() !== expectedRepo.toLowerCase()) {
       return void 0;
     }
-    const number = Number(match[2]);
-    return Number.isInteger(number) && number > 0 ? number : void 0;
+    const number2 = Number(match[2]);
+    return Number.isInteger(number2) && number2 > 0 ? number2 : void 0;
   } catch {
     return void 0;
   }
@@ -1483,7 +1410,7 @@ function buildGithubRoutes(options) {
       }
     })
   );
-  routes.push(...buildProjectGitRoutes({ github, auth, fleet, storage, emitAudit }));
+  routes.push(...buildProjectGitRoutes({ github, auth, fleet, emitAudit }));
   return routes;
 }
 async function loadOrgProject(options) {
@@ -1600,7 +1527,6 @@ function buildProjectGitRoutes({
   github,
   auth,
   fleet,
-  storage,
   emitAudit
 }) {
   return [
@@ -1721,31 +1647,27 @@ function buildProjectGitRoutes({
         }
         const { workdir, sandboxBinding } = sessionWorkspace;
         try {
-          return await withProjectLock({
-            key: `${project.id}:${userId}`,
-            storage,
-            fn: async () => {
-              const sandbox = await resolveProjectSandbox({ fleet, sandboxRow: sandboxBinding });
-              const result = await commitAll(
-                sandbox,
-                workdir,
-                body.message,
-                identityFromUser(await auth.ensureUser(loose(c)))
-              );
-              if (result.committed) {
-                await emitAudit?.({
-                  context: loose(c),
-                  input: {
-                    action: "factory.git.commit",
-                    factoryProjectId: project.factoryProjectId,
-                    projectRepositoryId: project.id,
-                    targets: [{ type: "session", id: sessionWorkspace.session.sessionId }],
-                    metadata: { sessionId: sessionWorkspace.session.sessionId }
-                  }
-                });
-              }
-              return c.json({ committed: result.committed });
+          return await withSessionOperationLock(sessionWorkspace.session.sessionId, async () => {
+            const sandbox = await resolveProjectSandbox({ fleet, sandboxRow: sandboxBinding });
+            const result = await commitAll(
+              sandbox,
+              workdir,
+              body.message,
+              identityFromUser(await auth.ensureUser(loose(c)))
+            );
+            if (result.committed) {
+              await emitAudit?.({
+                context: loose(c),
+                input: {
+                  action: "factory.git.commit",
+                  factoryProjectId: project.factoryProjectId,
+                  projectRepositoryId: project.id,
+                  targets: [{ type: "session", id: sessionWorkspace.session.sessionId }],
+                  metadata: { sessionId: sessionWorkspace.session.sessionId }
+                }
+              });
             }
+            return c.json({ committed: result.committed });
           });
         } catch (err) {
           return gitErrorResponse(loose(c), err);
@@ -1776,29 +1698,25 @@ function buildProjectGitRoutes({
         }
         const { workdir, sandboxBinding } = sessionWorkspace;
         try {
-          return await withProjectLock({
-            key: `${project.id}:${userId}`,
-            storage,
-            fn: async () => {
-              const sandbox = await resolveProjectSandbox({ fleet, sandboxRow: sandboxBinding });
-              const access = await github.versionControl.getRepositoryAccess({
-                orgId,
-                repositoryId: project.repository.id
-              });
-              if (!access.authorization) throw new Error("Repository access did not include a bearer token.");
-              await pushBranch(sandbox, workdir, branch, access.authorization.token, project.repository.slug);
-              await emitAudit?.({
-                context: loose(c),
-                input: {
-                  action: "factory.git.push",
-                  factoryProjectId: project.factoryProjectId,
-                  projectRepositoryId: project.id,
-                  targets: [{ type: "branch", id: branch }],
-                  metadata: { branch, sessionId: sessionWorkspace.session.sessionId }
-                }
-              });
-              return c.json({ pushed: true, branch });
-            }
+          return await withSessionOperationLock(sessionWorkspace.session.sessionId, async () => {
+            const sandbox = await resolveProjectSandbox({ fleet, sandboxRow: sandboxBinding });
+            const access = await github.versionControl.getRepositoryAccess({
+              orgId,
+              repositoryId: project.repository.id
+            });
+            if (!access.authorization) throw new Error("Repository access did not include a bearer token.");
+            await pushBranch(sandbox, workdir, branch, access.authorization.token, project.repository.slug);
+            await emitAudit?.({
+              context: loose(c),
+              input: {
+                action: "factory.git.push",
+                factoryProjectId: project.factoryProjectId,
+                projectRepositoryId: project.id,
+                targets: [{ type: "branch", id: branch }],
+                metadata: { branch, sessionId: sessionWorkspace.session.sessionId }
+              }
+            });
+            return c.json({ pushed: true, branch });
           });
         } catch (err) {
           return gitErrorResponse(loose(c), err);
@@ -1840,60 +1758,56 @@ function buildProjectGitRoutes({
           return c.json({ error: "Invalid sessionId" }, 400);
         }
         try {
-          return await withProjectLock({
-            key: `${project.id}:${userId}`,
-            storage,
-            fn: async () => {
-              const result = await github.versionControl.createPullRequest({
-                connection: {
-                  type: "app-installation",
-                  installationId: Number(project.installation.externalId)
-                },
-                sourceId: project.repository.slug,
-                baseBranch: base,
-                headBranch: head,
-                title,
-                body: prBody,
-                actingUserId: userId
-              });
-              await emitAudit?.({
-                context: loose(c),
-                input: {
-                  action: "factory.git.pr_opened",
-                  factoryProjectId: project.factoryProjectId,
+          return await withSessionOperationLock(sessionWorkspace.session.sessionId, async () => {
+            const result = await github.versionControl.createPullRequest({
+              connection: {
+                type: "app-installation",
+                installationId: Number(project.installation.externalId)
+              },
+              sourceId: project.repository.slug,
+              baseBranch: base,
+              headBranch: head,
+              title,
+              body: prBody,
+              actingUserId: userId
+            });
+            await emitAudit?.({
+              context: loose(c),
+              input: {
+                action: "factory.git.pr_opened",
+                factoryProjectId: project.factoryProjectId,
+                projectRepositoryId: project.id,
+                targets: [{ type: "pull_request", id: result.url, name: title }],
+                metadata: { branch: head, base, url: result.url }
+              }
+            });
+            const pullRequestNumber = pullRequestNumberFromUrl(result.url, project.repository.slug);
+            if (pullRequestNumber) {
+              const sessionId = sessionWorkspace.session.sessionId;
+              await subscribeToPullRequest(
+                {
+                  orgId,
+                  installationExternalId: project.installation.externalId,
                   projectRepositoryId: project.id,
-                  targets: [{ type: "pull_request", id: result.url, name: title }],
-                  metadata: { branch: head, base, url: result.url }
-                }
+                  repositoryExternalId: project.repository.externalId,
+                  repositorySlug: project.repository.slug,
+                  changeRequestId: pullRequestNumber.toString(),
+                  sessionId,
+                  ownerId: userId,
+                  resourceId: sessionId,
+                  threadId: sessionId,
+                  source: "factory-pr-create",
+                  subscribedByUserId: userId
+                },
+                github.integrationStorage
+              ).catch((error) => {
+                console.warn(
+                  `[GitHub] Pull request ${result.url} was created but automatic subscription failed.`,
+                  error
+                );
               });
-              const pullRequestNumber = pullRequestNumberFromUrl(result.url, project.repository.slug);
-              if (pullRequestNumber) {
-                const sessionId = sessionWorkspace.session.sessionId;
-                await subscribeToPullRequest(
-                  {
-                    orgId,
-                    installationExternalId: project.installation.externalId,
-                    projectRepositoryId: project.id,
-                    repositoryExternalId: project.repository.externalId,
-                    repositorySlug: project.repository.slug,
-                    changeRequestId: pullRequestNumber.toString(),
-                    sessionId,
-                    ownerId: userId,
-                    resourceId: sessionId,
-                    threadId: sessionId,
-                    source: "factory-pr-create",
-                    subscribedByUserId: userId
-                  },
-                  github.integrationStorage
-                ).catch((error) => {
-                  console.warn(
-                    `[GitHub] Pull request ${result.url} was created but automatic subscription failed.`,
-                    error
-                  );
-                });
-              }
-              return c.json({ url: result.url });
             }
+            return c.json({ url: result.url });
           });
         } catch (err) {
           return c.json(
@@ -1913,24 +1827,20 @@ function buildProjectGitRoutes({
       handler: async (c) => {
         const owned = await loadOwnedProject({ github, auth, fleet, c: loose(c) });
         if ("response" in owned) return owned.response;
-        const { userId, project, sandboxRow } = owned;
+        const { sandboxRow } = owned;
         if (!sandboxRow.sandboxId) {
           return c.json({ tornDown: false });
         }
         try {
-          return await withProjectLock({
-            key: `${project.id}:${userId}`,
-            storage,
-            fn: async () => {
-              const sandbox = await fleet.reattachSandbox(sandboxRow.sandboxId);
-              await teardownProjectSandbox({
-                fleet,
-                row: sandboxRow,
-                storage: github.sourceControlStorage.sandboxes,
-                sandbox
-              });
-              return c.json({ tornDown: true });
-            }
+          return await withSessionOperationLock(`sandbox:${sandboxRow.id}`, async () => {
+            const sandbox = await fleet.reattachSandbox(sandboxRow.sandboxId);
+            await teardownProjectSandbox({
+              fleet,
+              row: sandboxRow,
+              storage: github.sourceControlStorage.sandboxes,
+              sandbox
+            });
+            return c.json({ tornDown: true });
           });
         } catch (err) {
           return gitErrorResponse(loose(c), err);
@@ -1962,6 +1872,503 @@ async function resolveSessionWorkspace(github, projectId, userId, sessionId) {
   };
 }
 
+// src/rules/resolve.ts
+function resolveFactoryGithubRule(rules, event) {
+  return rules.github[event]?.onEvent;
+}
+
+// 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/integrations/github/rules.ts
+var TRUSTED_PERMISSIONS = /* @__PURE__ */ new Set(["write", "admin"]);
+var RULE_TIMEOUT_MS = 5e3;
+async function withRuleTimeout(promise) {
+  let timeout;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(new Error("FACTORY_RULE_TIMEOUT")), RULE_TIMEOUT_MS);
+      })
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+function object(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function string(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function number(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function boolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function eventName(parsed) {
+  const action = string(parsed.payload.action);
+  if (parsed.event === "issues" && action === "opened") return "issueOpened";
+  if (parsed.event === "pull_request" && action === "opened") return "pullRequestOpened";
+  if (parsed.event === "pull_request" && action === "synchronize") return "pullRequestUpdated";
+  if (parsed.event === "pull_request" && action === "closed" && boolean(object(parsed.payload.pull_request)?.merged)) {
+    return "pullRequestMerged";
+  }
+  if (parsed.event === "pull_request" && action === "review_requested") return "pullRequestReviewRequested";
+  return void 0;
+}
+function canonicalSourceKey(kind, itemNumber) {
+  return kind === "issue" ? `github-issue:${itemNumber}` : `github-pr:${itemNumber}`;
+}
+function legacySourceKey(repositoryId, kind, itemNumber) {
+  return `github:${repositoryId}:${kind}:${itemNumber}`;
+}
+function provenanceTarget(repositoryId, pullRequestNumber) {
+  return `factory-pr-provenance:${repositoryId}:${pullRequestNumber}`;
+}
+function workItemSource(item) {
+  if (!item.externalSource) return "manual";
+  return item.externalSource.type === "pull-request" ? "github-pr" : "github-issue";
+}
+function workItemSourceKey(item) {
+  return item.externalSource?.externalId ?? null;
+}
+async function githubActor(github, input) {
+  let trusted = false;
+  try {
+    const permission = await github.getRepositoryCollaboratorPermission(
+      input.installationId,
+      input.repository,
+      input.login
+    );
+    trusted = permission !== void 0 && TRUSTED_PERMISSIONS.has(permission);
+  } catch {
+    trusted = false;
+  }
+  return { type: "github", login: input.login, trusted, factoryAuthored: input.factoryAuthored };
+}
+function pullRequestProvenance(data) {
+  if (!data || data.kind !== "factory-pr-provenance" || typeof data.workItemId !== "string") return null;
+  return { kind: "factory-pr-provenance", workItemId: data.workItemId };
+}
+var GithubRules = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async ingest(parsed) {
+    const event = eventName(parsed);
+    const repository = object(parsed.payload.repository);
+    const installationId = number(object(parsed.payload.installation)?.id);
+    const repositoryId = number(repository?.id);
+    const repositoryName = string(repository?.full_name);
+    const login = string(object(parsed.payload.sender)?.login);
+    if (!event || !installationId || !repositoryId || !repositoryName || !login) return { status: "ignored" };
+    const projects = await this.options.sourceControl.projectRepositories.listByExternalRepository({
+      installationExternalId: String(installationId),
+      repositoryExternalId: String(repositoryId)
+    });
+    if (projects.length === 0) return { status: "ignored" };
+    const results = [];
+    for (const project of projects) {
+      results.push(
+        await this.#ingestProject(parsed, event, installationId, repositoryId, repositoryName, login, project)
+      );
+    }
+    if (results.some((result) => result.status === "committed")) return { status: "committed" };
+    if (results.some((result) => result.status === "replayed")) return { status: "replayed" };
+    return results[0] ?? { status: "ignored" };
+  }
+  async #ingestProject(parsed, event, installationId, repositoryId, repositoryName, login, project) {
+    const factoryProject = await this.options.projects.get({
+      orgId: project.orgId,
+      id: project.factoryProjectId
+    });
+    if (!factoryProject) return { status: "missing" };
+    const issue = object(parsed.payload.issue);
+    const pullRequest = object(parsed.payload.pull_request);
+    const issueNumber = number(issue?.number);
+    const pullRequestNumber = number(pullRequest?.number);
+    const provenance = pullRequestNumber ? pullRequestProvenance(
+      (await this.options.integrationStorage.subscriptions.listByTarget(
+        provenanceTarget(repositoryId, pullRequestNumber),
+        { status: "active" }
+      )).find((subscription) => subscription.orgId === project.orgId)?.data
+    ) : null;
+    const relatedItem = await this.#relatedItem(
+      project.orgId,
+      project.factoryProjectId,
+      repositoryId,
+      issueNumber,
+      pullRequestNumber,
+      string(object(pullRequest?.head)?.ref),
+      provenance
+    );
+    const actor = await githubActor(this.options.github, {
+      installationId,
+      repository: repositoryName,
+      login,
+      factoryAuthored: provenance !== null
+    });
+    const context = {
+      tenant: { orgId: project.orgId, projectId: project.factoryProjectId },
+      actor,
+      ingress: { type: "github", id: `${installationId}:${parsed.deliveryId}` },
+      cause: `github.${event}`,
+      causalChain: [],
+      ruleSetVersion: this.options.rules.version,
+      ...relatedItem ? {
+        item: {
+          id: relatedItem.id,
+          source: workItemSource(relatedItem),
+          sourceKey: workItemSourceKey(relatedItem),
+          parentWorkItemId: relatedItem.parentWorkItemId,
+          title: relatedItem.title,
+          url: relatedItem.externalSource?.url ?? null,
+          stages: relatedItem.stages
+        },
+        board: relatedItem.externalSource?.type === "pull-request" ? "review" : "work",
+        itemRevision: relatedItem.revision
+      } : {},
+      event,
+      deliveryId: parsed.deliveryId,
+      factory: { createdAt: factoryProject.createdAt.toISOString() },
+      repository: { id: repositoryId, fullName: repositoryName },
+      ...issueNumber && string(issue?.title) && string(issue?.html_url) ? {
+        issue: {
+          number: issueNumber,
+          title: string(issue?.title),
+          url: string(issue?.html_url),
+          ...string(issue?.created_at) ? { createdAt: string(issue?.created_at) } : {}
+        }
+      } : {},
+      ...pullRequestNumber && string(pullRequest?.title) && string(pullRequest?.html_url) ? {
+        pullRequest: {
+          number: pullRequestNumber,
+          title: string(pullRequest?.title),
+          url: string(pullRequest?.html_url),
+          ...string(pullRequest?.created_at) ? { createdAt: string(pullRequest?.created_at) } : {},
+          state: string(pullRequest?.state) === "closed" ? "closed" : "open",
+          merged: boolean(pullRequest?.merged) ?? false,
+          headBranch: string(object(pullRequest?.head)?.ref) ?? "",
+          baseBranch: string(object(pullRequest?.base)?.ref) ?? ""
+        }
+      } : {},
+      ...object(parsed.payload.review) ? {
+        review: {
+          id: number(object(parsed.payload.review)?.id) ?? 0,
+          state: string(object(parsed.payload.review)?.state) ?? "unknown",
+          url: string(object(parsed.payload.review)?.html_url) ?? ""
+        }
+      } : {}
+    };
+    const rule = resolveFactoryGithubRule(this.options.rules, event);
+    let decision;
+    let decisions = [];
+    let outcome = { status: "accepted" };
+    try {
+      decision = rule ? await withRuleTimeout(Promise.resolve(rule(Object.freeze(context)))) : void 0;
+      if (decision?.type === "reject") {
+        outcome = { status: "rejected", code: decision.code, reason: decision.reason };
+      } else if (decision) {
+        decisions = validateFactoryRuleDecisions([decision]).map((entry) => ({ ...entry }));
+      }
+    } 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 GitHub rule failed."
+      };
+    }
+    const committed = await this.options.storage.commitRuleEvaluation({
+      orgId: project.orgId,
+      factoryProjectId: project.factoryProjectId,
+      workItemId: relatedItem?.id ?? null,
+      ingress: { identity: `${installationId}:${parsed.deliveryId}`, triggerType: `github.${event}` },
+      ruleSetVersion: this.options.rules.version,
+      expectedRevision: relatedItem?.revision ?? null,
+      actor: { ...actor },
+      outcome,
+      decisions,
+      causalChain: [],
+      now: /* @__PURE__ */ new Date()
+    });
+    return { status: committed.status };
+  }
+  async #relatedItem(orgId, projectId, repositoryId, issueNumber, pullRequestNumber, pullRequestHeadBranch, provenance) {
+    const items = await this.options.storage.list({ orgId, factoryProjectId: projectId });
+    if (provenance) return items.find((item) => item.id === provenance.workItemId);
+    if (issueNumber) {
+      return items.find((item) => item.externalSource?.externalId === canonicalSourceKey("issue", issueNumber)) ?? items.find((item) => item.externalSource?.externalId === legacySourceKey(repositoryId, "issue", issueNumber));
+    }
+    if (pullRequestNumber) {
+      return items.find((item) => item.externalSource?.externalId === canonicalSourceKey("pull-request", pullRequestNumber)) ?? items.find(
+        (item) => item.externalSource?.externalId === legacySourceKey(repositoryId, "pull-request", pullRequestNumber)
+      ) ?? // Provenance fallback: a PR pushed from a work item's session branch
+      // belongs to that item even when no gh-pr-create provenance was
+      // recorded (session predating state seeding, or the PR was opened
+      // outside the tracked tool call). Session branches are per-item
+      // (`factory/issue-N`), so a head-branch match is unambiguous.
+      (pullRequestHeadBranch ? items.find(
+        (item) => item.externalSource?.type !== "pull-request" && Object.values(item.sessions).some((session) => session.branch === pullRequestHeadBranch)
+      ) : void 0);
+    }
+    return void 0;
+  }
+};
+function attachGithubRules(github, context) {
+  if (!context.rules) return void 0;
+  const rules = new GithubRules({
+    github,
+    sourceControl: context.storage.sourceControl,
+    integrationStorage: context.storage.generic,
+    projects: context.storage.projects,
+    storage: context.rules.workItems,
+    rules: context.rules.config
+  });
+  return (event) => rules.ingest(event);
+}
+
 // src/integrations/github/session-subscriptions.ts
 import { createTool } from "@mastra/core/tools";
 import { z } from "zod";
@@ -2057,16 +2464,16 @@ async function subscriptionInput(target, pullRequestNumber) {
 async function subscribeCurrentSessionToPullRequest(requestContext, pullRequest, source, github) {
   if (source === "auto-gh-pr-create" && !isGithubProjectSession(requestContext)) return void 0;
   const target = await resolveSessionTarget(requestContext, github);
-  const number = parsePullRequest(pullRequest, target.repository.slug);
-  await verifyPullRequest(target, number, github);
-  await subscribeToPullRequest({ ...await subscriptionInput(target, number), source }, github.integrationStorage);
-  return number;
+  const number2 = parsePullRequest(pullRequest, target.repository.slug);
+  await verifyPullRequest(target, number2, github);
+  await subscribeToPullRequest({ ...await subscriptionInput(target, number2), source }, github.integrationStorage);
+  return number2;
 }
 async function unsubscribeCurrentSessionFromPullRequest(requestContext, pullRequest, github) {
   const target = await resolveSessionTarget(requestContext, github);
-  const number = parsePullRequest(pullRequest, target.repository.slug);
-  await unsubscribeFromPullRequest(await subscriptionInput(target, number), github.integrationStorage);
-  return number;
+  const number2 = parsePullRequest(pullRequest, target.repository.slug);
+  await unsubscribeFromPullRequest(await subscriptionInput(target, number2), github.integrationStorage);
+  return number2;
 }
 async function refreshGithubToken(requestContext, github) {
   const target = await resolveSessionTarget(requestContext, github);
@@ -2106,8 +2513,8 @@ function createGithubSubscriptionTools(requestContext, github) {
       description: "Subscribe this thread to GitHub pull request activity. You usually do not need this tool: successful gh pr create commands subscribe automatically. Use it for an existing PR or to recover when automatic subscription did not occur. Closed or merged PRs are unsubscribed automatically. Accepts a PR number or canonical URL for the active project.",
       inputSchema: pullRequestInputSchema,
       execute: async ({ pullRequest }) => {
-        const number = await subscribeCurrentSessionToPullRequest(requestContext, pullRequest, "explicit-tool", github);
-        return { subscribed: true, pullRequestNumber: number };
+        const number2 = await subscribeCurrentSessionToPullRequest(requestContext, pullRequest, "explicit-tool", github);
+        return { subscribed: true, pullRequestNumber: number2 };
       }
     }),
     github_unsubscribe_pr: createTool({
@@ -2115,8 +2522,8 @@ function createGithubSubscriptionTools(requestContext, github) {
       description: "Manually unsubscribe this thread from GitHub pull request activity. You usually do not need this tool because closed or merged PRs are unsubscribed automatically. Use it to stop notifications before then. Accepts a PR number or canonical URL for the active project.",
       inputSchema: pullRequestInputSchema,
       execute: async ({ pullRequest }) => {
-        const number = await unsubscribeCurrentSessionFromPullRequest(requestContext, pullRequest, github);
-        return { subscribed: false, pullRequestNumber: number };
+        const number2 = await unsubscribeCurrentSessionFromPullRequest(requestContext, pullRequest, github);
+        return { subscribed: false, pullRequestNumber: number2 };
       }
     })
   };
@@ -2844,6 +3251,7 @@ var PlatformGithubIntegration = class {
     });
   }
   routes(ctx) {
+    const ingestFactoryEvent = attachGithubRules(this, ctx);
     return [
       this.#statusRoute(ctx),
       this.#connectRoute(ctx),
@@ -2858,7 +3266,7 @@ var PlatformGithubIntegration = class {
         controller: ctx.controller,
         projects: ctx.storage.projects,
         emitAudit: ctx.hooks?.emitAudit,
-        ingestFactoryEvent: ctx.hooks?.ingestGithubEvent
+        ingestFactoryEvent
       }).filter(
         (route) => route.path !== "/web/github/status" && route.path !== "/web/github/webhook" && !route.path.startsWith("/auth/github/")
       )
@@ -3016,7 +3424,7 @@ var PlatformGithubIntegration = class {
         controller: ctx.controller,
         github: this,
         storage: ctx.storage.generic,
-        ingestFactoryEvent: ctx.hooks?.ingestGithubEvent,
+        ingestFactoryEvent: attachGithubRules(this, ctx),
         intervalMs: this.#pollingIntervalMs
       })
     ];