@agent-native/core 0.168.6 → 0.168.9

package/corpus/templates/factory/actions/run-factory-automation.ts

@@ -5,6 +5,10 @@ import {
 } from "@agent-native/core/triggers";
 import { z } from "zod";
 
+import {
+  factoryIdSchema,
+  readAutomationFactoryId,
+} from "../server/lib/factory-scope.js";
 import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
@@ -15,11 +19,11 @@ export default defineAction({
     "Queue one organization-scoped Factory automation for an immediate run and return its durable run id.",
   agentTool: false,
   schema: z.object({
-    factoryId: z.string().trim().min(1).optional(),
+    factoryId: factoryIdSchema,
     automationId: z.string().trim().min(1),
   }),
   http: { method: "POST" },
-  run: async ({ automationId }, context) => {
+  run: async ({ factoryId, automationId }, context) => {
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
@@ -32,6 +36,12 @@ export default defineAction({
         entry.meta.domain === "factory" && entry.resource.id === automationId,
     );
     if (!definition) throw new Error("Factory automation not found.");
+    if (
+      readAutomationFactoryId(definition.meta, definition.resource.content) !==
+      factoryId
+    ) {
+      throw new Error("Factory automation not found.");
+    }
     return queueAutomationRunNow({
       userEmail,
       orgId,

package/corpus/templates/factory/actions/save-factory-automation.ts

@@ -1,10 +1,22 @@
 import { defineAction } from "@agent-native/core/action";
+import { isValidCron, nextOccurrence } from "@agent-native/core/jobs";
 import {
-  listAutomationDefinitions,
-  updateAutomation,
-} from "@agent-native/core/triggers";
+  resourceGetByPath,
+  resourcePutIfCurrent,
+} from "@agent-native/core/resources";
+import { listAutomationDefinitions } from "@agent-native/core/triggers";
 import { z } from "zod";
 
+import {
+  factoryIdSchema,
+  patchAutomationResource,
+  readAutomationEnabled,
+  readAutomationFactoryId,
+  readAutomationModel,
+  readAutomationSchedule,
+  resolveAutomationDisplayName,
+  setAutomationFrontmatterField,
+} from "../server/lib/factory-scope.js";
 import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
@@ -12,12 +24,13 @@ import {
 
 export default defineAction({
   description:
-    "Edit a Factory automation's prompt, model, schedule, or enabled state in its organization-owned markdown resource.",
+    "Edit a Factory automation's display name, prompt, model, schedule, or enabled state in its organization-owned markdown resource.",
   agentTool: false,
   schema: z.object({
-    factoryId: z.string().trim().min(1).optional(),
+    factoryId: factoryIdSchema,
     automationId: z.string().trim().min(1),
     name: z.string().trim().min(1).max(120),
+    displayName: z.string().trim().max(120).optional(),
     prompt: z.string().trim().min(1).max(20_000),
     model: z.string().trim().max(200).optional(),
     schedule: z.string().trim().min(1).max(100),
@@ -25,7 +38,16 @@ export default defineAction({
   }),
   http: { method: "POST" },
   run: async (
-    { automationId, name, prompt, model, schedule, enabled },
+    {
+      factoryId,
+      automationId,
+      name,
+      displayName,
+      prompt,
+      model,
+      schedule,
+      enabled,
+    },
     context,
   ) => {
     const { userEmail, orgId } = await requireWorkspaceMember(
@@ -40,30 +62,69 @@ export default defineAction({
         entry.meta.domain === "factory" && entry.resource.id === automationId,
     );
     if (!definition) throw new Error("Factory automation not found.");
+    if (
+      readAutomationFactoryId(definition.meta, definition.resource.content) !==
+      factoryId
+    ) {
+      throw new Error("Factory automation not found.");
+    }
     if (definition.name !== name) {
       throw new Error(
         "Factory automation id and name do not refer to the same automation.",
       );
     }
-    const updated = await updateAutomation(
-      { userEmail, orgId, appId: "factory" },
-      {
-        name: definition.name,
-        scope: "organization",
-        body: prompt,
-        model: model?.trim() || null,
-        schedule,
-        enabled,
-      },
+    if (!definition.canUpdate) {
+      throw new Error(
+        "Only the automation's creator or an organization admin can update it.",
+      );
+    }
+    if (definition.meta.triggerType === "schedule" && !isValidCron(schedule)) {
+      throw new Error(`Invalid cron expression "${schedule}".`);
+    }
+    const resource = await resourceGetByPath(
+      definition.resource.owner,
+      definition.resource.path,
     );
+    if (!resource) throw new Error("Factory automation not found.");
+    let content = patchAutomationResource(resource.content, {
+      body: prompt,
+      enabled,
+      schedule,
+      model: model?.trim() || null,
+      ...(displayName !== undefined ? { displayName } : {}),
+    });
+    content = setAutomationFrontmatterField(content, "factoryId", factoryId);
+    if (definition.meta.triggerType === "schedule" && isValidCron(schedule)) {
+      const nextRun = nextOccurrence(
+        schedule,
+        undefined,
+        definition.meta.timezone,
+      ).toISOString();
+      content = setAutomationFrontmatterField(content, "nextRun", nextRun);
+    }
+    const updated = await resourcePutIfCurrent({
+      owner: definition.resource.owner,
+      path: definition.resource.path,
+      content,
+      mimeType: "text/markdown",
+      expectedId: resource.id,
+      expectedUpdatedAt: resource.updatedAt,
+      expectedContent: resource.content,
+    });
+    if (!updated) {
+      throw new Error(
+        "Factory automation changed concurrently. Refresh and try again.",
+      );
+    }
     return {
       ok: true,
       id: definition.resource.id,
-      name: updated.name,
-      prompt: updated.body,
-      model: updated.meta.model ?? null,
-      schedule: updated.meta.schedule || null,
-      enabled: updated.meta.enabled,
+      name: definition.name,
+      displayName: resolveAutomationDisplayName(definition.name, content),
+      prompt,
+      model: readAutomationModel(content),
+      schedule: readAutomationSchedule(content),
+      enabled: readAutomationEnabled(content),
     };
   },
 });

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

@@ -17,6 +17,7 @@ import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
 } from "../server/lib/require-workspace-member.js";
+import { ensureFactoryAutomations } from "../server/plugins/factory-scheduler-job.js";
 import { stableId } from "../server/triage/ids.js";
 
 export default defineAction({
@@ -63,8 +64,9 @@ export default defineAction({
       workspaceMemberIdentityFromContext(context),
     );
     const db = getDb();
+    let createdNewFactory = false;
 
-    return db.transaction(async (tx) => {
+    const result = await db.transaction(async (tx) => {
       const existing = (
         await tx
           .select()
@@ -123,6 +125,7 @@ export default defineAction({
           );
         }
       } else {
+        createdNewFactory = true;
         await tx.insert(factoryDefinitions).values({
           id: factoryId,
           name,
@@ -158,5 +161,11 @@ export default defineAction({
         source,
       };
     });
+    if (createdNewFactory) {
+      await ensureFactoryAutomations(userEmail, orgId, factoryId, {
+        enabled: false,
+      });
+    }
+    return result;
   },
 });

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

@@ -1,20 +1,38 @@
 import { defineAction } from "@agent-native/core/action";
-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 {
+  readFactoryDefinition,
+  DEFAULT_FACTORY_ID,
+} from "../server/factory-graph/store.js";
+import {
+  isFactorySlackChannelConflict,
+  resolveEnabledAutomationsFromSavedConfig,
+} from "../server/lib/factory-automation-plan.js";
+import {
+  assertUniqueSlackChannelForFactory,
+  factoryConfigRowId,
+  factoryIdSchema,
+  readTriageConfigRow,
+} from "../server/lib/factory-scope.js";
 import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
 } from "../server/lib/require-workspace-member.js";
+import {
+  ensureFactoryAutomations,
+  syncFactoryAutomationEnabledStates,
+} from "../server/plugins/factory-scheduler-job.js";
 
 const workspaceSchema = z.enum(["primary", "secondary"]);
 
 export default defineAction({
   description:
-    "Save Factory observation and automation alert settings. Provider credentials live in shared workspace integrations; source routing metadata including the Builder Slack member id is stored on Factory config.",
+    "Save Factory observation and automation alert settings for the selected factory. Provider credentials live in shared workspace integrations; source routing metadata including the Builder Slack member id is stored on Factory config.",
   schema: z.object({
+    factoryId: factoryIdSchema.default(DEFAULT_FACTORY_ID),
     slackWorkspace: workspaceSchema.optional(),
     slackChannelId: z.string().trim().max(128).optional(),
     slackChannelName: z.string().trim().max(200).optional(),
@@ -41,6 +59,7 @@ export default defineAction({
   http: { method: "POST" },
   run: async (
     {
+      factoryId,
       slackWorkspace,
       slackChannelId,
       slackChannelName,
@@ -62,13 +81,11 @@ export default defineAction({
     );
     const now = new Date().toISOString();
     const db = getDb();
-    const existing = (
-      await db
-        .select()
-        .from(triageConfig)
-        .where(and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)))
-        .limit(1)
-    )[0];
+    if (factoryId !== DEFAULT_FACTORY_ID) {
+      const factory = await readFactoryDefinition(orgId, factoryId);
+      if (!factory) throw new Error("Factory not found.");
+    }
+    const existing = await readTriageConfigRow(db, orgId, factoryId);
     const persistText = (
       next: string | undefined,
       previous: string | null | undefined,
@@ -79,6 +96,12 @@ export default defineAction({
       slackChannelId,
       existing?.slackChannelId,
     );
+    await assertUniqueSlackChannelForFactory(
+      db,
+      orgId,
+      factoryId,
+      persistedSlackChannelId,
+    );
     const persistedSlackChannelName = persistText(
       slackChannelName,
       existing?.slackChannelName,
@@ -130,31 +153,13 @@ export default defineAction({
       automationFailureAlertEmail,
       existing?.automationFailureAlertEmail,
     );
-    await db
-      .insert(triageConfig)
-      .values({
-        id: orgId,
-        slackWorkspace: persistedSlackWorkspace,
-        slackChannelId: persistedSlackChannelId,
-        slackChannelName: persistedSlackChannelName,
-        builderSlackUserId: persistedBuilderSlackUserId,
-        pollingEnabled: persistedPollingEnabled,
-        githubPollingEnabled: persistedGithubPollingEnabled,
-        sentryPollingEnabled: persistedSentryPollingEnabled,
-        sentryOrgSlug: persistedSentryOrgSlug,
-        sentryProjectSlug: persistedSentryProjectSlug,
-        sentryEnvironment: persistedSentryEnvironment,
-        repository: persistedRepository,
-        automationFailureAlertsEnabled: persistedAutomationFailureAlertsEnabled,
-        automationFailureAlertEmail: persistedAutomationFailureAlertEmail,
-        createdAt: now,
-        updatedAt: now,
-        ownerEmail: userEmail,
-        orgId,
-      })
-      .onConflictDoUpdate({
-        target: triageConfig.id,
-        set: {
+    const configId = factoryConfigRowId(orgId, factoryId);
+    try {
+      await db
+        .insert(triageConfig)
+        .values({
+          id: configId,
+          factoryId,
           slackWorkspace: persistedSlackWorkspace,
           slackChannelId: persistedSlackChannelId,
           slackChannelName: persistedSlackChannelName,
@@ -169,12 +174,61 @@ export default defineAction({
           automationFailureAlertsEnabled:
             persistedAutomationFailureAlertsEnabled,
           automationFailureAlertEmail: persistedAutomationFailureAlertEmail,
+          createdAt: now,
           updatedAt: now,
           ownerEmail: userEmail,
-        },
-      });
+          orgId,
+        })
+        .onConflictDoUpdate({
+          target: triageConfig.id,
+          set: {
+            factoryId,
+            slackWorkspace: persistedSlackWorkspace,
+            slackChannelId: persistedSlackChannelId,
+            slackChannelName: persistedSlackChannelName,
+            builderSlackUserId: persistedBuilderSlackUserId,
+            pollingEnabled: persistedPollingEnabled,
+            githubPollingEnabled: persistedGithubPollingEnabled,
+            sentryPollingEnabled: persistedSentryPollingEnabled,
+            sentryOrgSlug: persistedSentryOrgSlug,
+            sentryProjectSlug: persistedSentryProjectSlug,
+            sentryEnvironment: persistedSentryEnvironment,
+            repository: persistedRepository,
+            automationFailureAlertsEnabled:
+              persistedAutomationFailureAlertsEnabled,
+            automationFailureAlertEmail: persistedAutomationFailureAlertEmail,
+            updatedAt: now,
+            ownerEmail: userEmail,
+          },
+        });
+    } catch (error) {
+      if (isFactorySlackChannelConflict(error)) {
+        throw new Error(
+          "That Slack channel is already used by another Factory in this workspace.",
+        );
+      }
+      throw error;
+    }
+
+    const enabledNames = resolveEnabledAutomationsFromSavedConfig({
+      pollingEnabled: persistedPollingEnabled,
+      githubPollingEnabled: persistedGithubPollingEnabled,
+      sentryPollingEnabled: persistedSentryPollingEnabled,
+      slackChannelId: persistedSlackChannelId,
+      repository: persistedRepository,
+      sentryOrgSlug: persistedSentryOrgSlug,
+      sentryProjectSlug: persistedSentryProjectSlug,
+    });
+    await ensureFactoryAutomations(userEmail, orgId, factoryId, {
+      enabledNames,
+    });
+    await syncFactoryAutomationEnabledStates(userEmail, orgId, factoryId, [
+      ...enabledNames,
+    ]);
+
     return {
       ok: true,
+      factoryId,
       pollingEnabled: persistedPollingEnabled === 1,
       githubPollingEnabled: persistedGithubPollingEnabled === 1,
       sentryPollingEnabled: persistedSentryPollingEnabled === 1,

package/corpus/templates/factory/actions/save-triage-rule.ts

@@ -4,6 +4,11 @@ import { z } from "zod";
 
 import { getDb } from "../server/db/index.js";
 import { triageRules } from "../server/db/schema.js";
+import { DEFAULT_FACTORY_ID } from "../server/factory-graph/store.js";
+import {
+  factoryIdSchema,
+  orgFactoryRuleFilter,
+} from "../server/lib/factory-scope.js";
 import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
@@ -20,6 +25,7 @@ export default defineAction({
   description:
     "Create or update a Factory rule. Disabled and shadow modes are accepted; execution still requires an explicit approval action.",
   schema: z.object({
+    factoryId: factoryIdSchema.default(DEFAULT_FACTORY_ID),
     id: z.string().min(1).optional(),
     name: z.string().trim().min(1).max(120),
     description: z.string().trim().max(500).default(""),
@@ -30,19 +36,24 @@ export default defineAction({
   }),
   http: { method: "POST" },
   run: async (
-    { id, name, description, promptText, mode, enabled, guards },
+    { factoryId, id, name, description, promptText, mode, enabled, guards },
     context,
   ) => {
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
     const now = new Date().toISOString();
-    const ruleId = id ?? stableId("rule", orgId, name);
+    const ruleId = id ?? stableId("rule", orgId, factoryId, name);
     const existing = (
       await getDb()
         .select({ promptVersion: triageRules.promptVersion })
         .from(triageRules)
-        .where(and(eq(triageRules.id, ruleId), eq(triageRules.orgId, orgId)))
+        .where(
+          and(
+            eq(triageRules.id, ruleId),
+            orgFactoryRuleFilter(orgId, factoryId),
+          ),
+        )
         .limit(1)
     )[0];
     if (id && !existing) {
@@ -68,6 +79,7 @@ export default defineAction({
         updatedAt: now,
         ownerEmail: userEmail,
         orgId,
+        factoryId,
       })
       .onConflictDoUpdate({
         target: triageRules.id,
@@ -81,6 +93,7 @@ export default defineAction({
           promptVersion: nextPromptVersion,
           updatedAt: now,
           ownerEmail: userEmail,
+          factoryId,
         },
       });
 

package/corpus/templates/factory/actions/start-builder-for-item.ts

@@ -4,11 +4,16 @@ import { z } from "zod";
 
 import { getDb } from "../server/db/index.js";
 import {
-  triageConfig,
   triageDecisions,
   triageItems,
   triageRuns,
 } from "../server/db/schema.js";
+import {
+  DEFAULT_FACTORY_ID,
+  orgFactoryItemFilter,
+  orgFactoryRunFilter,
+} from "../server/lib/factory-scope.js";
+import { readTriageConfigRow } from "../server/lib/factory-scope.js";
 import { requireFactoryAutomation } from "../server/lib/require-factory-automation.js";
 import {
   requireWorkspaceMember,
@@ -188,6 +193,7 @@ export async function recordAutomaticBuilderDecision(input: {
   itemId: string;
   userEmail: string;
   orgId: string;
+  factoryId: string;
   outcome: "propose_fix" | "needs_manual";
   reason: string;
   guardResults: Array<{ code: string; passed: boolean; reason: string }>;
@@ -214,6 +220,7 @@ export async function recordAutomaticBuilderDecision(input: {
       createdAt: now,
       ownerEmail: input.userEmail,
       orgId: input.orgId,
+      factoryId: input.factoryId,
     })
     .onConflictDoUpdate({
       target: triageDecisions.id,
@@ -260,11 +267,6 @@ export default defineAction({
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
-    await requireFactoryAutomation(
-      context,
-      { userEmail, orgId },
-      "builderDispatch",
-    );
     const db = getDb();
     const item = (
       await db
@@ -274,6 +276,13 @@ export default defineAction({
         .limit(1)
     )[0];
     if (!item) throw new Error("Factory item not found.");
+    const factoryId = item.factoryId ?? DEFAULT_FACTORY_ID;
+    await requireFactoryAutomation(
+      context,
+      { userEmail, orgId },
+      "builderDispatch",
+      factoryId,
+    );
     const metadata = parseTriageMetadata(item.metadataJson);
     const relatedIds = [...new Set(relatedItemIds)].filter(
       (relatedId) => relatedId !== itemId,
@@ -285,7 +294,7 @@ export default defineAction({
             .from(triageItems)
             .where(
               and(
-                eq(triageItems.orgId, orgId),
+                orgFactoryItemFilter(orgId, factoryId),
                 inArray(triageItems.id, relatedIds),
               ),
             )
@@ -319,7 +328,7 @@ export default defineAction({
             .from(triageRuns)
             .where(
               and(
-                eq(triageRuns.orgId, orgId),
+                orgFactoryRunFilter(orgId, factoryId),
                 inArray(triageRuns.itemId, relatedIds),
               ),
             )
@@ -385,6 +394,7 @@ export default defineAction({
       itemId,
       userEmail,
       orgId,
+      factoryId,
       outcome: blocked ? "needs_manual" : "propose_fix",
       reason,
       guardResults,
@@ -395,6 +405,7 @@ export default defineAction({
       {
         action: "start-builder-for-item",
         kind: "decision",
+        factoryId,
         itemId,
         source: item.source,
         sourceUrl: item.sourceUrl,
@@ -483,6 +494,7 @@ export default defineAction({
         error: null,
         ownerEmail: item.ownerEmail,
         orgId,
+        factoryId: item.factoryId ?? DEFAULT_FACTORY_ID,
       });
     }
 
@@ -493,18 +505,11 @@ export default defineAction({
             "Slack feedback is missing its channel or thread identity.",
           );
         }
-        const config = (
-          await db
-            .select({
-              slackWorkspace: triageConfig.slackWorkspace,
-              builderSlackUserId: triageConfig.builderSlackUserId,
-            })
-            .from(triageConfig)
-            .where(
-              and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)),
-            )
-            .limit(1)
-        )[0];
+        const config = await readTriageConfigRow(
+          db,
+          orgId,
+          item.factoryId ?? DEFAULT_FACTORY_ID,
+        );
         const workspace =
           config?.slackWorkspace === "secondary" ? "secondary" : "primary";
         const builderSlackUserId = requireBuilderSlackUserId(
@@ -638,6 +643,7 @@ export default defineAction({
             itemId: related.id,
             userEmail,
             orgId,
+            factoryId: related.factoryId ?? factoryId,
             outcome: "propose_fix",
             reason: `Grouped with Factory item ${itemId}: ${reason}`,
             guardResults,
@@ -656,6 +662,7 @@ export default defineAction({
           {
             action: "start-builder-for-item",
             kind: "external_action",
+            factoryId,
             itemId,
             source: item.source,
             sourceUrl: item.sourceUrl,
@@ -728,6 +735,7 @@ export default defineAction({
         {
           action: "start-builder-for-item",
           kind: "external_action",
+          factoryId,
           itemId,
           source: item.source,
           sourceUrl: item.sourceUrl,

package/corpus/templates/factory/actions/suggest-factory-rules.ts

@@ -1,9 +1,15 @@
 import { defineAction } from "@agent-native/core/action";
-import { desc, eq } from "drizzle-orm";
+import { desc } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb } from "../server/db/index.js";
 import { triageDecisions, triageFeedback } from "../server/db/schema.js";
+import { DEFAULT_FACTORY_ID } from "../server/factory-graph/store.js";
+import {
+  factoryIdSchema,
+  orgFactoryDecisionFilter,
+  orgFactoryFeedbackFilter,
+} from "../server/lib/factory-scope.js";
 import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
@@ -13,11 +19,12 @@ export default defineAction({
   description:
     "Mine human feedback on Factory decisions into inspectable rule proposals. This never edits a rule or enables execution.",
   schema: z.object({
+    factoryId: factoryIdSchema.default(DEFAULT_FACTORY_ID),
     limit: z.coerce.number().int().min(1).max(50).default(10),
   }),
   http: { method: "GET" },
   readOnly: true,
-  run: async ({ limit }, context) => {
+  run: async ({ factoryId, limit }, context) => {
     const { orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
@@ -25,13 +32,13 @@ export default defineAction({
     const decisions = await db
       .select()
       .from(triageDecisions)
-      .where(eq(triageDecisions.orgId, orgId))
+      .where(orgFactoryDecisionFilter(orgId, factoryId))
       .orderBy(desc(triageDecisions.createdAt))
       .limit(500);
     const feedback = await db
       .select()
       .from(triageFeedback)
-      .where(eq(triageFeedback.orgId, orgId))
+      .where(orgFactoryFeedbackFilter(orgId, factoryId))
       .orderBy(desc(triageFeedback.createdAt))
       .limit(500);
     const decisionsById = new Map(