@agent-native/core 0.168.7 → 0.168.9

package/corpus/templates/factory/actions/poll-sentry-errors.ts

@@ -4,6 +4,12 @@ import { z } from "zod";
 
 import { getDb } from "../server/db/index.js";
 import { triageConfig, triageItems } from "../server/db/schema.js";
+import { repairFactoryAutomationsFromConfig } from "../server/lib/factory-automation-repair.js";
+import {
+  factoryIdSchema,
+  readTriageConfigRow,
+  triageConfigUpdateRowId,
+} from "../server/lib/factory-scope.js";
 import { requireFactoryAutomation } from "../server/lib/require-factory-automation.js";
 import {
   requireWorkspaceMember,
@@ -21,9 +27,12 @@ import { createSentryClient } from "../server/triage/sentry-client.js";
 export default defineAction({
   description:
     "Poll bounded unresolved Sentry issues for the configured organization and record them in the Factory queue. This does not change Sentry.",
-  schema: z.object({ limit: z.number().int().min(1).max(50).default(25) }),
+  schema: z.object({
+    factoryId: factoryIdSchema,
+    limit: z.number().int().min(1).max(50).default(25),
+  }),
   http: false,
-  run: async ({ limit }, context) => {
+  run: async ({ factoryId, limit }, context) => {
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
@@ -31,14 +40,11 @@ export default defineAction({
       context,
       { userEmail, orgId },
       "sourcePolling",
+      factoryId,
     );
-    const config = (
-      await getDb()
-        .select()
-        .from(triageConfig)
-        .where(and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)))
-        .limit(1)
-    )[0];
+    const db = getDb();
+    const config = await readTriageConfigRow(db, orgId, factoryId);
+    await repairFactoryAutomationsFromConfig(userEmail, orgId, factoryId);
     if (config?.sentryPollingEnabled !== 1) {
       throw new Error("Enable Sentry polling before polling Sentry.");
     }
@@ -74,14 +80,15 @@ export default defineAction({
         );
     }
     const observedIssues = issues;
-    const db = getDb();
     const now = new Date().toISOString();
+    const configRowId = triageConfigUpdateRowId(config, orgId, factoryId);
 
     await db.transaction(async (tx) => {
       for (const issue of observedIssues) {
         const id = itemDedupeKey(
           { source: "sentry", externalId: issue.id },
           orgId,
+          factoryId,
         );
         const existing = (
           await tx
@@ -140,6 +147,7 @@ export default defineAction({
             updatedAt,
             ownerEmail: existing?.ownerEmail ?? userEmail,
             orgId,
+            factoryId,
           })
           .onConflictDoUpdate({
             target: triageItems.id,
@@ -151,6 +159,7 @@ export default defineAction({
               metadataJson: metadata,
               lastSeenAt,
               updatedAt,
+              factoryId,
             },
           });
       }
@@ -167,7 +176,9 @@ export default defineAction({
             }, config.lastSentrySeenAt) ?? config.lastSentrySeenAt,
           updatedAt: now,
         })
-        .where(and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)));
+        .where(
+          and(eq(triageConfig.id, configRowId), eq(triageConfig.orgId, orgId)),
+        );
     });
 
     if (observedIssues.length === 0) {
@@ -181,6 +192,7 @@ export default defineAction({
           summary: "No unresolved Sentry errors were observed.",
           details: { sentryOrgSlug: config.sentryOrgSlug },
         },
+        factoryId,
       );
     } else {
       for (const issue of observedIssues) {
@@ -193,6 +205,7 @@ export default defineAction({
             itemId: itemDedupeKey(
               { source: "sentry", externalId: issue.id },
               orgId,
+              factoryId,
             ),
             source: "sentry",
             sourceUrl: issue.permalink,
@@ -204,12 +217,14 @@ export default defineAction({
               projectSlug: issue.projectSlug,
             },
           },
+          factoryId,
         );
       }
     }
 
     return {
       ok: true,
+      factoryId,
       observed: observedIssues.length,
       fetched: issues.length,
       sentryOrgSlug: config.sentryOrgSlug,

package/corpus/templates/factory/actions/poll-slack-channel.ts

@@ -4,6 +4,12 @@ import { z } from "zod";
 
 import { getDb } from "../server/db/index.js";
 import { triageConfig, triageItems } from "../server/db/schema.js";
+import { repairFactoryAutomationsFromConfig } from "../server/lib/factory-automation-repair.js";
+import {
+  factoryIdSchema,
+  readTriageConfigRow,
+  triageConfigUpdateRowId,
+} from "../server/lib/factory-scope.js";
 import { requireFactoryAutomation } from "../server/lib/require-factory-automation.js";
 import {
   requireWorkspaceMember,
@@ -21,10 +27,11 @@ export default defineAction({
   description:
     "Poll the configured Slack channel and append new messages to the Factory queue. This action only observes and never posts, replies, starts work, or changes a provider.",
   schema: z.object({
+    factoryId: factoryIdSchema,
     channelId: z.string().trim().min(1).max(128).optional(),
   }),
   http: false,
-  run: async ({ channelId: requestedChannelId }, context) => {
+  run: async ({ factoryId, channelId: requestedChannelId }, context) => {
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
@@ -32,22 +39,24 @@ export default defineAction({
       context,
       { userEmail, orgId },
       "sourcePolling",
+      factoryId,
     );
     const db = getDb();
-    const config = (
-      await db
-        .select()
-        .from(triageConfig)
-        .where(and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)))
-        .limit(1)
-    )[0];
+    const config = await readTriageConfigRow(db, orgId, factoryId);
+    await repairFactoryAutomationsFromConfig(userEmail, orgId, factoryId);
     if (config?.pollingEnabled !== 1) {
       throw new Error("Enable Slack polling before polling Slack.");
     }
-    const channelId = requestedChannelId ?? config?.slackChannelId;
-    if (!channelId) {
+    const configuredChannelId = config?.slackChannelId;
+    if (!configuredChannelId) {
       throw new Error("Configure a Slack channel before polling.");
     }
+    if (requestedChannelId && requestedChannelId !== configuredChannelId) {
+      throw new Error(
+        "Poll only the Slack channel configured for this factory.",
+      );
+    }
+    const channelId = configuredChannelId;
 
     const result = await pollSlackChannel({
       workspace:
@@ -59,10 +68,11 @@ export default defineAction({
       orgId,
     });
     const now = new Date().toISOString();
+    const configRowId = triageConfigUpdateRowId(config, orgId, factoryId);
 
     await db.transaction(async (tx) => {
       for (const envelope of result.envelopes) {
-        const id = itemDedupeKey(envelope, orgId);
+        const id = itemDedupeKey(envelope, orgId, factoryId);
         const existing = (
           await tx
             .select()
@@ -117,6 +127,7 @@ export default defineAction({
             updatedAt,
             ownerEmail: userEmail,
             orgId,
+            factoryId,
           })
           .onConflictDoUpdate({
             target: triageItems.id,
@@ -131,6 +142,7 @@ export default defineAction({
               status,
               lastSeenAt,
               updatedAt,
+              factoryId,
             },
           });
       }
@@ -144,7 +156,10 @@ export default defineAction({
             updatedAt: now,
           })
           .where(
-            and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)),
+            and(
+              eq(triageConfig.id, configRowId),
+              eq(triageConfig.orgId, orgId),
+            ),
           );
       }
     });
@@ -163,6 +178,7 @@ export default defineAction({
             coverage: result.hasMore ? "partial" : "complete",
           },
         },
+        factoryId,
       );
     } else {
       for (const envelope of result.envelopes) {
@@ -172,7 +188,7 @@ export default defineAction({
           {
             action: "poll-slack-channel",
             kind: "observed",
-            itemId: itemDedupeKey(envelope, orgId),
+            itemId: itemDedupeKey(envelope, orgId, factoryId),
             source: envelope.source,
             sourceUrl: envelope.sourceUrl ?? null,
             summary: envelope.summary ?? envelope.title,
@@ -182,6 +198,7 @@ export default defineAction({
               coverage: envelope.coverage,
             },
           },
+          factoryId,
         );
       }
     }
@@ -189,6 +206,7 @@ export default defineAction({
     return {
       ok: true,
       source: "slack",
+      factoryId,
       channelId,
       observed: result.envelopes.length,
       hasMore: result.hasMore,

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