@agent-native/core 0.168.7 → 0.168.9

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],
+    };
+  },
+});

package/corpus/templates/factory/actions/evaluate-triage-item.ts

@@ -11,6 +11,12 @@ import {
   triageItems,
   triageRules,
 } from "../server/db/schema.js";
+import { DEFAULT_FACTORY_ID } from "../server/factory-graph/store.js";
+import {
+  factoryIdSchema,
+  orgFactoryItemFilter,
+  orgFactoryRuleFilter,
+} from "../server/lib/factory-scope.js";
 import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
@@ -25,9 +31,12 @@ import { evaluateStructuredGuards } from "../server/triage/guards.js";
 export default defineAction({
   description:
     "Triage one Factory item against enabled rules and append structured guard decisions. This records proposals only and never changes a provider.",
-  schema: z.object({ itemId: z.string().min(1) }),
+  schema: z.object({
+    factoryId: factoryIdSchema.default(DEFAULT_FACTORY_ID),
+    itemId: z.string().min(1),
+  }),
   http: { method: "POST" },
-  run: async ({ itemId }, context) => {
+  run: async ({ factoryId, itemId }, context) => {
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
@@ -36,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("Triage item not found");
@@ -44,7 +58,9 @@ export default defineAction({
     const rules = await db
       .select()
       .from(triageRules)
-      .where(and(eq(triageRules.orgId, orgId), eq(triageRules.enabled, 1)));
+      .where(
+        and(eq(triageRules.enabled, 1), orgFactoryRuleFilter(orgId, factoryId)),
+      );
     const metadata = parseMetadata(item.metadataJson);
     const evidence = {
       repository: item.repository ?? undefined,
@@ -77,6 +93,7 @@ export default defineAction({
         {
           action: "evaluate-triage-item",
           kind: "decision",
+          factoryId,
           status: "skipped",
           itemId,
           source: item.source,
@@ -116,6 +133,7 @@ export default defineAction({
         createdAt: now,
         ownerEmail: userEmail,
         orgId,
+        factoryId,
       };
     });
 
@@ -131,7 +149,12 @@ export default defineAction({
             : "shadow_decided",
           updatedAt: now,
         })
-        .where(and(eq(triageItems.id, itemId), eq(triageItems.orgId, orgId)));
+        .where(
+          and(
+            eq(triageItems.id, itemId),
+            orgFactoryItemFilter(orgId, factoryId),
+          ),
+        );
     });
 
     for (const decision of decisions) {
@@ -141,6 +164,7 @@ export default defineAction({
         {
           action: "evaluate-triage-item",
           kind: "decision",
+          factoryId,
           itemId,
           source: item.source,
           sourceUrl: item.sourceUrl,

package/corpus/templates/factory/actions/get-factory-graph.ts

@@ -28,7 +28,7 @@ export default defineAction({
     const row = await readFactoryDefinition(orgId, factoryId);
     const fallback = defaultFactoryDefinition();
     const graph = row ? parseFactoryGraph(row.graphJson) : fallback.graph;
-    const metrics = await readFactoryMetrics(orgId);
+    const metrics = await readFactoryMetrics(orgId, factoryId);
 
     const metricValues: Record<string, number> = {
       items: metrics.totalItems,

package/corpus/templates/factory/actions/get-slack-feedback-context.ts

@@ -3,7 +3,13 @@ import { and, eq } from "drizzle-orm";
 import { z } from "zod";
 
 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,
+  orgFactoryItemFilter,
+  readTriageConfigRow,
+} from "../server/lib/factory-scope.js";
 import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
@@ -14,10 +20,13 @@ import { createSlackReader } from "../server/triage/slack-client.js";
 export default defineAction({
   description:
     "Read the bounded full Slack thread for one Factory feedback item. Use this before deciding whether a report is a clear bug; unreadable or truncated context is not a green light.",
-  schema: z.object({ itemId: z.string().min(1) }),
+  schema: z.object({
+    factoryId: factoryIdSchema.default(DEFAULT_FACTORY_ID),
+    itemId: z.string().min(1),
+  }),
   http: { method: "GET" },
   readOnly: true,
-  run: async ({ itemId }, context) => {
+  run: async ({ factoryId, itemId }, context) => {
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
@@ -25,7 +34,12 @@ export default defineAction({
       await getDb()
         .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.");
@@ -33,13 +47,7 @@ export default defineAction({
       throw new Error("Factory item is not a readable Slack feedback item.");
     }
 
-    const config = (
-      await getDb()
-        .select({ slackWorkspace: triageConfig.slackWorkspace })
-        .from(triageConfig)
-        .where(and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)))
-        .limit(1)
-    )[0];
+    const config = await readTriageConfigRow(getDb(), orgId, factoryId);
     const workspace =
       config?.slackWorkspace === "secondary" ? "secondary" : "primary";
     const slack = createSlackReader({ ownerEmail: userEmail, orgId });
@@ -66,6 +74,7 @@ export default defineAction({
           messageCount: messages.length,
         },
       },
+      factoryId,
     );
 
     return {

package/corpus/templates/factory/actions/get-triage-config.ts

@@ -1,10 +1,13 @@
 import { defineAction } from "@agent-native/core/action";
 import { getEmailReadiness } from "@agent-native/core/server";
-import { and, eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb } from "../server/db/index.js";
-import { triageConfig } 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 {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
@@ -12,24 +15,21 @@ import {
 
 export default defineAction({
   description:
-    "Read Factory observation settings for the active workspace. Secret values are never returned.",
-  schema: z.object({}),
+    "Read Factory observation settings for the selected factory. Secret values are never returned.",
+  schema: z.object({
+    factoryId: factoryIdSchema.default(DEFAULT_FACTORY_ID),
+  }),
   http: { method: "GET" },
   readOnly: true,
-  run: async (_, context) => {
+  run: async ({ factoryId }, context) => {
     const { orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
     const emailReadiness = await getEmailReadiness();
-    const row = (
-      await getDb()
-        .select()
-        .from(triageConfig)
-        .where(and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)))
-        .limit(1)
-    )[0];
+    const row = await readTriageConfigRow(getDb(), orgId, factoryId);
     if (!row) {
       return {
+        factoryId,
         slackWorkspace: "primary",
         slackChannelId: null,
         slackChannelName: null,
@@ -51,6 +51,7 @@ export default defineAction({
     }
     return {
       ...row,
+      factoryId,
       pollingEnabled: row.pollingEnabled === 1,
       githubPollingEnabled: row.githubPollingEnabled === 1,
       sentryPollingEnabled: row.sentryPollingEnabled === 1,