@agent-native/core 0.168.6 → 0.168.9

package/corpus/templates/clips/server/lib/calendar-event-meetings.ts

@@ -23,6 +23,8 @@ import {
 
 export const CALENDAR_MEETING_ID_PREFIX = "gcal";
 
+const CALENDAR_REQUEST_SAFETY_MARGIN_MS = 60 * 1000;
+
 export interface CalendarAccountForEvents {
   id: string;
   provider: string;
@@ -74,8 +76,7 @@ export function shouldMarkNeedsReauth(message: string): boolean {
     lower.includes("google calendar event failed (401)") ||
     lower.includes("invalid_grant") ||
     lower.includes("invalid_token") ||
-    lower.includes("insufficient_scope") ||
-    lower.includes("token refresh failed")
+    lower.includes("insufficient_scope")
   );
 }
 
@@ -122,10 +123,16 @@ export async function resolveCalendarAccessToken(
     });
   } catch (err) {
     // Only a permanent failure (dead refresh token / bad OAuth client) means
-    // "needs-reauth" — collapse those to `null` as before. A transient
-    // failure (network error, 429, 5xx, timeout) is rethrown so callers can
-    // record it as a soft sync error without flipping account status.
+    // "needs-reauth" — collapse those to `null` as before. During the refresh
+    // buffer, a transient failure can safely reuse the still-valid token.
     if (isPermanentRefreshFailure(err)) return null;
+    if (
+      bundle?.accessToken &&
+      bundle.expiresAt &&
+      bundle.expiresAt > Date.now() + CALENDAR_REQUEST_SAFETY_MARGIN_MS
+    ) {
+      return bundle.accessToken;
+    }
     throw err;
   }
   if (!refreshed.access_token) return null;
@@ -158,13 +165,13 @@ export async function recordCalendarFetchSuccess(
     .set({
       lastSyncedAt: now,
       lastSyncError: null,
-      status: "connected",
       updatedAt: now,
     })
     .where(
       and(
         eq(schema.calendarAccounts.id, account.id),
         eq(schema.calendarAccounts.ownerEmail, account.ownerEmail),
+        eq(schema.calendarAccounts.status, "connected"),
       ),
     );
 }
@@ -172,10 +179,11 @@ export async function recordCalendarFetchSuccess(
 export async function recordCalendarFetchError(
   account: CalendarAccountForEvents,
   error: unknown,
+  options: { needsReauth?: boolean } = {},
 ): Promise<CalendarFetchError> {
   const message =
     error instanceof Error ? error.message : String(error || "Calendar failed");
-  const needsReauth = shouldMarkNeedsReauth(message);
+  const needsReauth = options.needsReauth ?? shouldMarkNeedsReauth(message);
   if (!account.ownerEmail) {
     return { accountId: account.id, error: message, needsReauth };
   }
@@ -183,7 +191,7 @@ export async function recordCalendarFetchError(
   await db
     .update(schema.calendarAccounts)
     .set({
-      status: needsReauth ? "needs-reauth" : "connected",
+      ...(needsReauth ? { status: "needs-reauth" as const } : {}),
       lastSyncError: needsReauth
         ? "Google Calendar needs to be reconnected."
         : message,
@@ -320,7 +328,9 @@ export async function fetchLiveCalendarEventFromId(virtualId: string) {
     return null;
   }
   if (!accessToken) {
-    await recordCalendarFetchError(account, new Error("Token refresh failed"));
+    await recordCalendarFetchError(account, new Error("Token refresh failed"), {
+      needsReauth: true,
+    });
     return null;
   }
 

package/corpus/templates/factory/.agents/skills/factory-graphs/SKILL.md

@@ -16,6 +16,11 @@ explains them, but never hides a topology change in prose. Until an execution
 binding is explicitly added, the blueprint must not be described as the runtime
 router.
 
+Runtime work — settings, inbox, rules, automations, and activity — is scoped by
+`factoryId`. Reusable agents stay workspace-wide; graph nodes may reference any
+workspace agent as blueprint only. Pass `factoryId` on triage, config, automation,
+and audit actions for the factory the user is viewing.
+
 ## Workflow
 
 1. Read `view-screen` to identify the selected Factory, tab, node, or edge.

package/corpus/templates/factory/AGENTS.md

@@ -21,22 +21,11 @@ decisions, feedback, agent runs, and provider audit records.
   reconciliation is not success; preserve typed failure or
   `reconciliation_required` state.
 - Deduplicate by Factory item and rule/run identity, not provider comment ID.
-- Slack clear bugs go through `start-builder-for-item` (👀 and a Slack user
-  mention for `/address-feedback`); never post Slack messages or `@handles`.
-  Group repeats into one Builder thread. GitHub/Sentry use the Builder run
-  API. Follow `review-latest-feedback` for full-thread evidence, existing
-  reaction and owner checks, answered-clarification priority, one-question
-  clarification limits, durable rechecks, and the required `@agent-native`
-  disposition after every actionable 👀. Clips, Design, and Content stay
-  owner-managed outside autonomous dispatch and PR governance.
-- PR governance follows `review-prs`: verify BuilderIO membership and complete
-  diff/review/check evidence; skip drafts/current approvals and never approve
-  external authors. Keep ultra-scary security, auth, tenant-isolation,
-  secrets, data-loss, execution, payment, and deployment risks manual.
-  Verified members may pass ordinary uncertain checks or review feedback, but
-  record exact states and never call them clean. Apply the Alice/Content,
-  Nick/Slides, Enzo/Factory, Sid/Design, and docs-only exceptions only after
-  membership and the ultra-scary gate. Never auto-merge.
+- Slack clear bugs go through `start-builder-for-item`; never post Slack
+  messages or `@handles`. GitHub/Sentry use the Builder run API. Read
+  `review-latest-feedback` for thread evidence and disposition rules.
+- PR governance follows `review-prs`: verify membership and evidence; skip
+  drafts and external authors; keep ultra-scary risks manual; never auto-merge.
 - Graph edits create immutable blueprint versions. AI proposes with `source=ai`;
   a person reviews and publishes through the same action surface.
 - Provider credentials belong to Dispatch/shared workspace integrations, never
@@ -46,16 +35,16 @@ decisions, feedback, agent runs, and provider audit records.
 
 ## Application state
 
-- `navigation.view` is `factory`, `agents`, or `factory-settings`.
-  Observation settings are workspace-scoped at `/factory-settings`.
-  `factoryId`, `factoryTab`, `factoryAuditRunId`, `factoryNodeId`, and
-  `factoryEdgeId` hold Factory context. Read `view-screen` first.
+- `navigation.view` is `factory` or `agents`. Runtime data is scoped by
+  `factoryId`; reusable agents stay workspace-wide. Read `view-screen` and
+  `factory-graphs` for tab and selection keys.
 
 ## Action contract
 
 | Action | Purpose |
 | --- | --- |
-| `list-triage-items` / `get-triage-item` | Inspect bounded queue evidence; scheduled reviewers pass `needsReview: true`, `source`, and `limit`. |
+| `list-triage-items` / `get-triage-item` | Inspect queue evidence; pass `factoryId`. |
+| `get-triage-config` / `save-triage-config` | Read or save observation settings for one factory. |
 | `poll-slack-channel` | Observe Slack history; never writes to Slack. |
 | `get-slack-feedback-context` | Read the bounded full Slack thread before classification. |
 | `poll-github-sources` / `poll-sentry-errors` | Observe bounded source queues. |
@@ -67,11 +56,12 @@ decisions, feedback, agent runs, and provider audit records.
 | `start-builder-for-item` | Govern clear-bug dispatch through Slack or Builder API, or record a skip reason. |
 | `govern-agent-native-pull-request` | Apply PR evidence and ownership gates. |
 | `list-factory-automations` / `save-factory-automation` / `run-factory-automation` | Inspect or edit org-owned automations. |
-| `list-factory-audit` | Inspect automation runs, evidence, decisions, and provider actions. |
+| `list-factory-audit` | Inspect runs, evidence, and provider actions for one factory. |
 | `get-factory-automation-health` | Inspect scheduler heartbeat and last error. |
 | `suggest-factory-rules` | Mine feedback into proposals. |
 | `reconcile-triage-run` | Persist callback/provider reconciliation. |
 | `list-factories` / `get-factory-graph` | Inspect definitions, versions, and metrics. |
+| `create-factory` | Create a factory from `/new-factory` with optional sources. |
 | `save-factory-graph` | Create/version a graph with inspected `expectedGraphVersion`; never starts provider work. |
 | graph history actions | Factory graph version history. |
 | `list-factory-comments` / `add-factory-comment` | Read or attach comments to a canvas, node, or edge. |

package/corpus/templates/factory/README.md

@@ -44,19 +44,22 @@ shared `app_secrets` rows must use the same
 encryption fallback). Never copy raw tokens between apps or add a second
 env-only read in a provider client.
 
-Factory's default observer still keeps organization-scoped source metadata -
-such as a Slack channel, repository, or Sentry project - for its normalized
-queue adapters. That metadata is not a credential or a per-factory integration
-setup. GitHub issue polling defaults to hourly; Slack and pull-request checks
-use shorter bounded cadences because those sources can need faster feedback.
-Every poll preserves errors for reconciliation.
+Factory's observer keeps **per-factory** source metadata — Slack channel,
+repository, Sentry project, and related polling settings — for its normalized
+queue adapters. Each factory has its own inbox, rules, automations, and activity.
+Reusable agents and workspace credentials stay shared. Each factory's observation
+settings live on its Settings tab in the factory detail view. That metadata is
+not a credential or a per-factory
+integration setup. GitHub issue polling defaults to hourly; Slack and
+pull-request checks use shorter bounded cadences because those sources can need
+faster feedback. Every poll preserves errors for reconciliation.
 
 Factory agents can discover connected provider APIs with
 `provider-api-catalog`, inspect their docs with `provider-api-docs`, and call
 them through `provider-api-request`. Scheduled Factory runs also receive the
 workspace's connected MCP tools, subject to the same workspace and request
-scope gates. The three normalized pollers are compatibility adapters for the
-default triage queue, not the agent's capability limit.
+scope gates. The three normalized pollers are compatibility adapters scoped by
+`factoryId`, not the agent's capability limit.
 
 The generic Slack bot is wired to Factory. Mention `@agent-native` in a feedback
 thread to inspect the linked item, explain its decision, tune a rule, or say

package/corpus/templates/factory/actions/approve-factory-item.ts

@@ -8,6 +8,13 @@ import {
   triageItems,
   triageRuns,
 } from "../server/db/schema.js";
+import { DEFAULT_FACTORY_ID } from "../server/factory-graph/store.js";
+import {
+  factoryIdSchema,
+  orgFactoryDecisionFilter,
+  orgFactoryItemFilter,
+  orgFactoryRunFilter,
+} from "../server/lib/factory-scope.js";
 import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
@@ -19,6 +26,7 @@ export default defineAction({
   description:
     "Explicitly approve one Factory item and start one deduplicated Builder coding run. The approver, decision, guard results, and callback state are recorded before provider work is considered successful.",
   schema: z.object({
+    factoryId: factoryIdSchema.default(DEFAULT_FACTORY_ID),
     itemId: z.string().min(1),
     decisionId: z.string().min(1).optional(),
     confirm: z.literal(true),
@@ -27,7 +35,7 @@ export default defineAction({
   // must remain paused until a human approves this exact agent tool call.
   needsApproval: true,
   http: { method: "POST" },
-  run: async ({ itemId, decisionId, confirm }, context) => {
+  run: async ({ factoryId, itemId, decisionId, confirm }, context) => {
     if (!confirm) throw new Error("Explicit confirmation is required.");
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
@@ -37,7 +45,12 @@ export default defineAction({
       await db
         .select()
         .from(triageItems)
-        .where(and(eq(triageItems.id, itemId), eq(triageItems.orgId, orgId)))
+        .where(
+          and(
+            eq(triageItems.id, itemId),
+            orgFactoryItemFilter(orgId, factoryId),
+          ),
+        )
         .limit(1)
     )[0];
     if (!item) throw new Error("Factory item not found.");
@@ -47,8 +60,8 @@ export default defineAction({
       .from(triageDecisions)
       .where(
         and(
-          eq(triageDecisions.orgId, orgId),
           eq(triageDecisions.itemId, itemId),
+          orgFactoryDecisionFilter(orgId, factoryId),
         ),
       )
       .orderBy(asc(triageDecisions.createdAt));
@@ -72,7 +85,9 @@ export default defineAction({
       await db
         .select()
         .from(triageRuns)
-        .where(and(eq(triageRuns.id, runId), eq(triageRuns.orgId, orgId)))
+        .where(
+          and(eq(triageRuns.id, runId), orgFactoryRunFilter(orgId, factoryId)),
+        )
         .limit(1)
     )[0];
     if (
@@ -110,6 +125,7 @@ export default defineAction({
         error: null,
         ownerEmail: item.ownerEmail,
         orgId,
+        factoryId,
       })
       .onConflictDoNothing();
 
@@ -117,7 +133,9 @@ export default defineAction({
       await db
         .select()
         .from(triageRuns)
-        .where(and(eq(triageRuns.id, runId), eq(triageRuns.orgId, orgId)))
+        .where(
+          and(eq(triageRuns.id, runId), orgFactoryRunFilter(orgId, factoryId)),
+        )
         .limit(1)
     )[0];
     if (!run) throw new Error("Factory run could not be recorded.");
@@ -155,11 +173,18 @@ export default defineAction({
           progressLogJson: JSON.stringify(progress),
           heartbeatAt: new Date().toISOString(),
         })
-        .where(and(eq(triageRuns.id, runId), eq(triageRuns.orgId, orgId)));
+        .where(
+          and(eq(triageRuns.id, runId), orgFactoryRunFilter(orgId, factoryId)),
+        );
       await db
         .update(triageItems)
         .set({ status: "classified", updatedAt: new Date().toISOString() })
-        .where(and(eq(triageItems.id, itemId), eq(triageItems.orgId, orgId)));
+        .where(
+          and(
+            eq(triageItems.id, itemId),
+            orgFactoryItemFilter(orgId, factoryId),
+          ),
+        );
       return {
         ok: true,
         deduplicated: false,
@@ -176,7 +201,9 @@ export default defineAction({
           completedAt: new Date().toISOString(),
           heartbeatAt: new Date().toISOString(),
         })
-        .where(and(eq(triageRuns.id, runId), eq(triageRuns.orgId, orgId)));
+        .where(
+          and(eq(triageRuns.id, runId), orgFactoryRunFilter(orgId, factoryId)),
+        );
       throw new Error(
         `Factory approval was recorded, but Builder dispatch failed: ${message}`,
       );

package/corpus/templates/factory/actions/babysit-agent-native-pull-request.ts

@@ -4,7 +4,12 @@ import { z } from "zod";
 
 import { resolveConnectorSecret } from "../server/connectors/credentials.js";
 import { getDb } from "../server/db/index.js";
-import { triageConfig, triageItems } from "../server/db/schema.js";
+import { triageItems } from "../server/db/schema.js";
+import { DEFAULT_FACTORY_ID } from "../server/factory-graph/store.js";
+import {
+  factoryIdSchema,
+  readTriageConfigRow,
+} from "../server/lib/factory-scope.js";
 import { requireFactoryAutomation } from "../server/lib/require-factory-automation.js";
 import {
   requireWorkspaceMember,
@@ -85,13 +90,13 @@ export default defineAction({
     "Watch one builder-io-bot pull request, post the bounded feedback-fix request when CI, mergeability, or review feedback needs work, and stop after 20 quiet minutes. The action never merges or approves.",
   schema: z.object({
     itemId: z.string().min(1),
+    factoryId: factoryIdSchema.optional(),
   }),
   http: false,
-  run: async ({ itemId }, context) => {
+  run: async ({ itemId, factoryId: factoryIdInput }, context) => {
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
-    await requireFactoryAutomation(context, { userEmail, orgId }, "prBabysit");
 
     const db = getDb();
     const item = (
@@ -102,6 +107,16 @@ export default defineAction({
         .limit(1)
     )[0];
     if (!item) throw new Error("Factory item not found for PR babysitting.");
+    const factoryId = factoryIdInput ?? item.factoryId ?? DEFAULT_FACTORY_ID;
+    if ((item.factoryId ?? DEFAULT_FACTORY_ID) !== factoryId) {
+      throw new Error("Factory item does not belong to this factory.");
+    }
+    await requireFactoryAutomation(
+      context,
+      { userEmail, orgId },
+      "prBabysit",
+      factoryId,
+    );
     if (
       item.source !== "github" ||
       !item.repository ||
@@ -115,12 +130,8 @@ export default defineAction({
     }
 
     const configuredRepository = (
-      await db
-        .select({ repository: triageConfig.repository })
-        .from(triageConfig)
-        .where(and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)))
-        .limit(1)
-    )[0]?.repository;
+      await readTriageConfigRow(db, orgId, factoryId)
+    )?.repository;
     if (
       !configuredRepository ||
       configuredRepository.trim() !== item.repository.trim()
@@ -154,6 +165,7 @@ export default defineAction({
           summary: "Skipped because the pull request is closed or a draft.",
           details: { state: pullRequest.state, draft: pullRequest.draft },
         },
+        factoryId,
       );
       return { ok: true, action: "skipped", reason: "PR is closed or draft." };
     }
@@ -182,6 +194,7 @@ export default defineAction({
           summary: `${ownerOwnedArea} is owner-managed; no bot feedback was posted.`,
           details: { ownerOwnedArea },
         },
+        factoryId,
       );
       return {
         ok: true,
@@ -257,6 +270,7 @@ export default defineAction({
           reviewFeedbackClean: signal.isClean,
         },
       },
+      factoryId,
     );
     const now = new Date();
     const nowIso = now.toISOString();
@@ -326,6 +340,7 @@ export default defineAction({
         summary: "Posted the bounded feedback-fix request to builder-io-bot.",
         details: { commentUrl: comment.htmlUrl, quietForMinutes: 0 },
       },
+      factoryId,
     );
     await updateBabysitMetadata(itemId, orgId, {
       prBabysitState: "active",

package/corpus/templates/factory/actions/create-factory.ts

@@ -0,0 +1,211 @@
+import { defineAction } from "@agent-native/core/action";
+import { buildDeepLink } from "@agent-native/core/server";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import {
+  factoryDefinitions,
+  factoryGraphVersions,
+  triageConfig,
+} from "../server/db/schema.js";
+import {
+  minimalFactoryGraph,
+  normalizeFactoryGraph,
+} from "../server/factory-graph/contracts.js";
+import {
+  resolveEnabledAutomations,
+  isFactoryIdConflict,
+  isFactorySlackChannelConflict,
+} from "../server/lib/factory-automation-plan.js";
+import {
+  assertUniqueSlackChannelForFactory,
+  factoryConfigRowId,
+  resolveUniqueFactoryId,
+} from "../server/lib/factory-scope.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+import {
+  ensureFactoryAutomations,
+  removeFactoryAutomationResources,
+  syncFactoryAutomationEnabledStates,
+} from "../server/plugins/factory-scheduler-job.js";
+import { stableId } from "../server/triage/ids.js";
+
+export default defineAction({
+  description:
+    "Create a new Factory with a minimal blueprint, optional observation settings, and seeded automations. Name is required; sources and automations are optional.",
+  schema: z.object({
+    name: z.string().trim().min(1).max(120),
+    description: z.string().trim().max(500).optional(),
+    slackChannelId: z.string().trim().max(128).optional(),
+    slackChannelName: z.string().trim().max(200).optional(),
+    observeSlack: z.boolean().optional(),
+    repository: z.string().trim().max(256).optional(),
+    observeGithub: z.boolean().optional(),
+    sentryOrgSlug: z.string().trim().max(200).optional(),
+    sentryProjectSlug: z.string().trim().max(200).optional(),
+    sentryEnvironment: z.string().trim().max(200).optional(),
+    observeSentry: z.boolean().optional(),
+  }),
+  http: { method: "POST" },
+  link: ({ result }) => ({
+    url: buildDeepLink({
+      app: "factory",
+      view: "factory",
+      params: { factoryId: result.factoryId },
+    }),
+    label: `Open ${result.name} in Factory`,
+  }),
+  run: async (input, context) => {
+    const { userEmail, orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const db = getDb();
+    const description = input.description?.trim() ?? "";
+    const graph = normalizeFactoryGraph(
+      minimalFactoryGraph(input.name, description),
+    );
+    const now = new Date().toISOString();
+    const automationPlan = resolveEnabledAutomations({
+      observeSlack: input.observeSlack === true,
+      slackChannelId: input.slackChannelId,
+      observeGithub: input.observeGithub === true,
+      repository: input.repository,
+      observeSentry: input.observeSentry === true,
+      sentryOrgSlug: input.sentryOrgSlug,
+      sentryProjectSlug: input.sentryProjectSlug,
+    });
+
+    const MAX_FACTORY_CREATE_ATTEMPTS = 5;
+    let factoryId = "";
+    for (let attempt = 0; attempt < MAX_FACTORY_CREATE_ATTEMPTS; attempt++) {
+      factoryId = await resolveUniqueFactoryId(db, orgId, input.name);
+      const versionId = stableId("factory-graph", orgId, factoryId, "1");
+      try {
+        await db.transaction(async (tx) => {
+          await tx.insert(factoryDefinitions).values({
+            id: factoryId,
+            name: input.name,
+            description,
+            prompt: "",
+            graphVersion: 1,
+            graphJson: JSON.stringify(graph),
+            createdAt: now,
+            updatedAt: now,
+            ownerEmail: userEmail,
+            orgId,
+          });
+          await tx.insert(factoryGraphVersions).values({
+            id: versionId,
+            factoryId,
+            version: 1,
+            graphJson: JSON.stringify(graph),
+            source: "manual",
+            changeSummary: "Created from the new factory dialog.",
+            createdAt: now,
+            createdBy: userEmail,
+            ownerEmail: userEmail,
+            orgId,
+          });
+
+          if (automationPlan.hasConfig) {
+            const slackChannelId = input.slackChannelId?.trim() || null;
+            await assertUniqueSlackChannelForFactory(
+              tx as unknown as typeof db,
+              orgId,
+              factoryId,
+              slackChannelId,
+            );
+            await tx.insert(triageConfig).values({
+              id: factoryConfigRowId(orgId, factoryId),
+              factoryId,
+              slackWorkspace: "primary",
+              slackChannelId,
+              slackChannelName: input.slackChannelName?.trim() || null,
+              builderSlackUserId: null,
+              pollingEnabled: automationPlan.pollingEnabled ? 1 : 0,
+              githubPollingEnabled: automationPlan.githubPollingEnabled ? 1 : 0,
+              sentryPollingEnabled: automationPlan.sentryPollingEnabled ? 1 : 0,
+              sentryOrgSlug: input.sentryOrgSlug?.trim() || null,
+              sentryProjectSlug: input.sentryProjectSlug?.trim() || null,
+              sentryEnvironment: input.sentryEnvironment?.trim() || null,
+              repository: input.repository?.trim() || null,
+              automationFailureAlertsEnabled: 1,
+              automationFailureAlertEmail: null,
+              createdAt: now,
+              updatedAt: now,
+              ownerEmail: userEmail,
+              orgId,
+            });
+          }
+        });
+        break;
+      } catch (error) {
+        if (isFactorySlackChannelConflict(error)) {
+          throw new Error(
+            "That Slack channel is already used by another Factory in this workspace.",
+          );
+        }
+        if (
+          isFactoryIdConflict(error) &&
+          attempt < MAX_FACTORY_CREATE_ATTEMPTS - 1
+        ) {
+          continue;
+        }
+        throw error;
+      }
+    }
+    if (!factoryId) {
+      throw new Error("Could not allocate a unique factory id.");
+    }
+
+    try {
+      await ensureFactoryAutomations(userEmail, orgId, factoryId, {
+        enabledNames: automationPlan.enabledNames,
+      });
+      if (automationPlan.enabledNames.size > 0) {
+        await syncFactoryAutomationEnabledStates(userEmail, orgId, factoryId, [
+          ...automationPlan.enabledNames,
+        ]);
+      }
+    } catch (error) {
+      await removeFactoryAutomationResources(orgId, factoryId);
+      await db
+        .delete(triageConfig)
+        .where(
+          and(
+            eq(triageConfig.orgId, orgId),
+            eq(triageConfig.factoryId, factoryId),
+          ),
+        );
+      await db
+        .delete(factoryGraphVersions)
+        .where(
+          and(
+            eq(factoryGraphVersions.orgId, orgId),
+            eq(factoryGraphVersions.factoryId, factoryId),
+          ),
+        );
+      await db
+        .delete(factoryDefinitions)
+        .where(
+          and(
+            eq(factoryDefinitions.id, factoryId),
+            eq(factoryDefinitions.orgId, orgId),
+          ),
+        );
+      throw error;
+    }
+
+    return {
+      ok: true,
+      factoryId,
+      name: input.name,
+      graphVersion: 1,
+      enabledAutomations: [...automationPlan.enabledNames],
+    };
+  },
+});