@agent-native/core 0.168.7 → 0.168.10

package/corpus/templates/factory/actions/reconcile-triage-run.ts

@@ -4,6 +4,11 @@ import { z } from "zod";
 
 import { getDb } from "../server/db/index.js";
 import { triageItems, triageRuns } from "../server/db/schema.js";
+import { DEFAULT_FACTORY_ID } from "../server/factory-graph/store.js";
+import {
+  factoryIdSchema,
+  orgFactoryScopedItemWhere,
+} from "../server/lib/factory-scope.js";
 import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
@@ -48,6 +53,7 @@ export default defineAction({
     "Reconcile an observe-only pull-request monitoring run from ai-services callback and provider observations. Missing callbacks or provider reads remain typed failure states; no executor or GitHub write occurs.",
   schema: z.object({
     itemId: z.string().min(1),
+    factoryId: factoryIdSchema.optional(),
     runId: z.string().min(1),
     source: triageSourceSchema.default("github"),
     callback: z
@@ -70,6 +76,7 @@ export default defineAction({
   run: async (
     {
       itemId,
+      factoryId: factoryIdInput,
       runId,
       source,
       callback,
@@ -82,8 +89,25 @@ export default defineAction({
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
+    const db = getDb();
+    const item = (
+      await db
+        .select({ factoryId: triageItems.factoryId })
+        .from(triageItems)
+        .where(and(eq(triageItems.id, itemId), eq(triageItems.orgId, orgId)))
+        .limit(1)
+    )[0];
+    if (!item)
+      throw new Error("Factory item not found for run reconciliation.");
+    const itemFactoryId = item.factoryId ?? DEFAULT_FACTORY_ID;
+    if (factoryIdInput && factoryIdInput !== itemFactoryId) {
+      throw new Error("Factory item does not belong to this factory.");
+    }
+    const factoryId = itemFactoryId;
     const now = new Date().toISOString();
-    const databaseRunId = stableId("run", orgId, runId);
+    const scopedRunId = stableId("run", orgId, factoryId, runId);
+    const legacyRunId =
+      factoryId === DEFAULT_FACTORY_ID ? stableId("run", orgId, runId) : null;
     const result = reconcilePullRequestRun({
       triageItemId: itemId,
       runId,
@@ -93,17 +117,42 @@ export default defineAction({
       now,
       timeoutMs,
     });
-    const db = getDb();
     const existingRun = (
       await db
-        .select({ progressLogJson: triageRuns.progressLogJson })
+        .select({
+          id: triageRuns.id,
+          progressLogJson: triageRuns.progressLogJson,
+          factoryId: triageRuns.factoryId,
+        })
         .from(triageRuns)
-        .where(
-          and(eq(triageRuns.id, databaseRunId), eq(triageRuns.orgId, orgId)),
-        )
+        .where(and(eq(triageRuns.id, scopedRunId), eq(triageRuns.orgId, orgId)))
         .limit(1)
     )[0];
-    const progressLog = appendProgressLog(existingRun?.progressLogJson, {
+    let databaseRunId = scopedRunId;
+    let existing = existingRun;
+    if (!existing && legacyRunId) {
+      const legacyRun = (
+        await db
+          .select({
+            id: triageRuns.id,
+            progressLogJson: triageRuns.progressLogJson,
+            factoryId: triageRuns.factoryId,
+          })
+          .from(triageRuns)
+          .where(
+            and(eq(triageRuns.id, legacyRunId), eq(triageRuns.orgId, orgId)),
+          )
+          .limit(1)
+      )[0];
+      if (legacyRun) {
+        existing = legacyRun;
+        databaseRunId = legacyRunId;
+      }
+    }
+    if (existing && (existing.factoryId ?? DEFAULT_FACTORY_ID) !== factoryId) {
+      throw new Error("Run id is already used by another factory.");
+    }
+    const progressLog = appendProgressLog(existing?.progressLogJson, {
       at: now,
       state: result.state,
       reason: result.reason,
@@ -131,6 +180,7 @@ export default defineAction({
               : null,
           ownerEmail: userEmail,
           orgId,
+          factoryId,
         })
         .onConflictDoUpdate({
           target: triageRuns.id,
@@ -154,12 +204,12 @@ export default defineAction({
         await tx
           .update(triageItems)
           .set(result.triageItemPatch)
-          .where(and(eq(triageItems.id, itemId), eq(triageItems.orgId, orgId)));
+          .where(orgFactoryScopedItemWhere(itemId, orgId, factoryId));
       } else if (result.state === "reconciliation_required") {
         await tx
           .update(triageItems)
           .set({ status: "reconciliation_required", updatedAt: now })
-          .where(and(eq(triageItems.id, itemId), eq(triageItems.orgId, orgId)));
+          .where(orgFactoryScopedItemWhere(itemId, orgId, factoryId));
       }
     });
 

package/corpus/templates/factory/actions/record-triage-feedback.ts

@@ -6,6 +6,11 @@ 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,
+} from "../server/lib/factory-scope.js";
 import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
@@ -18,27 +23,32 @@ export default defineAction({
     "Record human feedback on a Factory shadow decision. Feedback is append-only and changes no provider or executor state.",
   schema: z.object({
     decisionId: z.string().min(1),
+    factoryId: factoryIdSchema.default(DEFAULT_FACTORY_ID),
     verdict: verdictSchema,
     note: z.string().trim().max(2_000).optional(),
   }),
   http: { method: "POST" },
-  run: async ({ decisionId, verdict, note }, context) => {
+  run: async ({ decisionId, factoryId, verdict, note }, context) => {
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
     const decision = (
       await getDb()
-        .select({ id: triageDecisions.id })
+        .select({
+          id: triageDecisions.id,
+          factoryId: triageDecisions.factoryId,
+        })
         .from(triageDecisions)
         .where(
           and(
             eq(triageDecisions.id, decisionId),
-            eq(triageDecisions.orgId, orgId),
+            orgFactoryDecisionFilter(orgId, factoryId),
           ),
         )
         .limit(1)
     )[0];
     if (!decision) throw new Error("Triage decision not found");
+    const resolvedFactoryId = decision.factoryId ?? factoryId;
 
     const createdAt = new Date().toISOString();
     const id = randomUUID();
@@ -52,6 +62,7 @@ export default defineAction({
         createdAt,
         ownerEmail: userEmail,
         orgId,
+        factoryId: resolvedFactoryId,
       });
     return { ok: true, id };
   },

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