@agent-native/core 0.176.1 → 0.176.2-nightly-20260831184159

package/corpus/templates/factory/actions/{babysit-pull-request.ts → propose-pr-babysit-status.ts}

@@ -1,13 +1,13 @@
 import { defineAction } from "@agent-native/core/action";
 import { z } from "zod";
 
-import { resolveConnectorSecret } from "../server/connectors/credentials.js";
+import { parseGitHubRepositoryRef } from "../server/lib/github-repository.js";
 import { requireFactoryAutomation } from "../server/lib/require-factory-automation.js";
 import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
 } from "../server/lib/require-workspace-member.js";
-import { createAiServicesGitReadClient } from "../server/triage/ai-services-git.js";
+import { createGitHubClient } from "../server/triage/github-client.js";
 import { reconcileBabysitState } from "../server/triage/pr-babysit.js";
 import type {
   ReviewCommentObservation,
@@ -33,55 +33,17 @@ export type FetchReviewComments = (input: FetchReviewCommentsInput) => Promise<{
   truncated: boolean;
 }>;
 
-// Same non-secret deployment endpoint/project id the Builder executor reads
-// (server/triage/builder-executor.ts); that resolver is private to this file
-// and out of scope to export, so this is a second, identical read site for
-// the same two env vars rather than a new credential path.
-function requiredAiServicesEnv(
-  name: "BUILDER_AI_SERVICES_URL" | "BUILDER_PROJECT_ID",
-): string {
-  const value =
-    name === "BUILDER_AI_SERVICES_URL"
-      ? process.env.BUILDER_AI_SERVICES_URL // guard:allow-env-credential - non-secret deployment endpoint
-      : process.env.BUILDER_PROJECT_ID; // guard:allow-env-credential - non-secret deployment project id
-  if (!value) {
-    throw new Error(
-      `review-comment fetch not configured: ${name} is required to read GitHub review comments.`,
-    );
-  }
-  return value;
-}
-
-const fetchReviewCommentsFromAiServices: FetchReviewComments = async ({
+const fetchReviewCommentsFromGitHub: FetchReviewComments = async ({
   repo,
   pullRequestNumber,
   ownerEmail,
   orgId,
 }) => {
-  const baseUrl = requiredAiServicesEnv("BUILDER_AI_SERVICES_URL");
-  const projectId = requiredAiServicesEnv("BUILDER_PROJECT_ID");
-  const privateKey = await resolveConnectorSecret(
-    "BUILDER_PRIVATE_KEY",
-    ownerEmail,
-    { orgId },
-  );
-  if (!privateKey) {
-    throw new Error(
-      "review-comment fetch not configured: no Builder executor credential (BUILDER_PRIVATE_KEY) is available for this workspace.",
-    );
-  }
-
-  const client = createAiServicesGitReadClient({
-    baseUrl,
-    authorization: `Bearer ${privateKey.startsWith("bpk-") ? privateKey : `bpk-${privateKey}`}`,
-  });
-  // Review comments ride along on the reviews read; there is no separate
-  // comments endpoint in ai-services.
-  const snapshot = await client.fetchPullRequest({
-    projectId,
-    repo,
+  const github = createGitHubClient({ ownerEmail, orgId });
+  const snapshot = await github.listPullRequestReviewComments(
+    parseGitHubRepositoryRef(repo),
     pullRequestNumber,
-  });
+  );
   return {
     comments: snapshot.comments,
     truncated: snapshot.commentsTruncated,
@@ -89,11 +51,11 @@ const fetchReviewCommentsFromAiServices: FetchReviewComments = async ({
 };
 
 export function createBabysitPullRequestAction(
-  fetchComments: FetchReviewComments = fetchReviewCommentsFromAiServices,
+  fetchComments: FetchReviewComments = fetchReviewCommentsFromGitHub,
 ) {
   return defineAction({
     description:
-      "Propose a babysit-PR status (unanswered review comments, failing/pending checks, missing changeset packages) for one pull request. Read-only and proposal-only: never replies, pushes, merges, assigns, or invokes an executor.",
+      "Propose babysit status for one pull request (unanswered review comments, failing or pending checks). Read-only: never replies, pushes, merges, or posts. Use babysit-factory-pull-request when this factory should write the feedback-fix comment.",
     schema: z.object({
       repo: z.string().trim().min(1).max(256),
       pullRequestNumber: z.number().int().positive(),

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

@@ -53,7 +53,7 @@ const observationSchema: z.ZodType<PullRequestObservation> = z.object({
 
 export default defineAction({
   description:
-    "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.",
+    "Reconcile an observe-only pull-request monitoring run from provider observations. Missing provider reads remain typed failure states; no GitHub write occurs.",
   schema: z.object({
     itemId: z.string().min(1),
     factoryId: factoryIdSchema.optional(),

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

@@ -7,9 +7,19 @@ import {
 import { listAutomationDefinitions } from "@agent-native/core/triggers";
 import { z } from "zod";
 
+import {
+  FACTORY_INBOX_LIMIT_MAX,
+  FACTORY_WORK_LIMIT_MAX,
+  applyAutomationConfigFrontmatter,
+  assertAuthorFilter,
+  clampInboxLimit,
+  clampWorkLimit,
+  readFactoryAutomationConfig,
+  replaceUserPrompt,
+  scheduleCron,
+} from "../server/lib/factory-automation-config.js";
 import {
   factoryIdSchema,
-  patchAutomationResource,
   readAutomationEnabled,
   readAutomationFactoryId,
   readAutomationModel,
@@ -24,8 +34,7 @@ import {
 
 export default defineAction({
   description:
-    "Edit a Factory automation's display name, prompt, model, schedule, or enabled state in its organization-owned markdown resource.",
-  agentTool: false,
+    "Edit a Factory automation's display name, prompt, model, schedule, authors, limits, destination, or enabled state in its organization-owned markdown resource.",
   schema: z.object({
     factoryId: factoryIdSchema,
     automationId: z.string().trim().min(1),
@@ -33,23 +42,34 @@ export default defineAction({
     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),
     enabled: z.boolean(),
+    slackWorkspace: z.enum(["primary", "secondary"]).optional(),
+    slackChannelId: z.string().trim().max(128).optional(),
+    slackChannelName: z.string().trim().max(200).optional(),
+    repository: z.string().trim().max(512).optional(),
+    sentryOrgSlug: z.string().trim().max(200).optional(),
+    sentryProjectSlug: z.string().trim().max(200).optional(),
+    sentryEnvironment: z.string().trim().max(200).optional(),
+    authorMode: z.enum(["include", "exclude"]).optional(),
+    authorIds: z.array(z.string().trim().min(1).max(32)).max(50).optional(),
+    scheduleMode: z.enum(["interval", "daily"]).optional(),
+    intervalMinutes: z
+      .union([
+        z.literal(5),
+        z.literal(10),
+        z.literal(15),
+        z.literal(30),
+        z.literal(60),
+      ])
+      .optional(),
+    dailyHour: z.number().int().min(0).max(23).optional(),
+    dailyMinute: z.number().int().min(0).max(59).optional(),
+    timezone: z.string().trim().max(80).optional(),
+    inboxLimit: z.number().int().min(1).max(FACTORY_INBOX_LIMIT_MAX).optional(),
+    workLimit: z.number().int().min(1).max(FACTORY_WORK_LIMIT_MAX).optional(),
   }),
   http: { method: "POST" },
-  run: async (
-    {
-      factoryId,
-      automationId,
-      name,
-      displayName,
-      prompt,
-      model,
-      schedule,
-      enabled,
-    },
-    context,
-  ) => {
+  run: async (input, context) => {
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
@@ -59,7 +79,8 @@ export default defineAction({
     );
     const definition = definitions.find(
       (entry) =>
-        entry.meta.domain === "factory" && entry.resource.id === automationId,
+        entry.meta.domain === "factory" &&
+        entry.resource.id === input.automationId,
     );
     if (!definition) throw new Error("Factory automation not found.");
     if (
@@ -67,36 +88,110 @@ export default defineAction({
         definition.meta,
         definition.resource.content,
         definition.resource.path,
-      ) !== factoryId
+      ) !== input.factoryId
     ) {
       throw new Error("Factory automation not found.");
     }
-    if (definition.name !== name) {
+    if (definition.name !== input.name) {
       throw new Error(
         "Factory automation id and name do not refer to the same automation.",
       );
     }
-    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);
+    const current = readFactoryAutomationConfig(resource.content, input.name);
+    const authorMode = input.authorMode ?? current.authorMode;
+    const authorIds = assertAuthorFilter(
+      current.source,
+      authorMode,
+      current.source === "sentry" ? [] : (input.authorIds ?? current.authorIds),
+    );
+    const scheduleMode = input.scheduleMode ?? current.scheduleMode;
+    const timezone =
+      scheduleMode === "daily"
+        ? input.timezone?.trim() || current.timezone
+        : null;
+    if (scheduleMode === "daily" && !timezone) {
+      throw new Error("Choose a timezone for a daily schedule.");
+    }
+    const config = {
+      ...current,
+      slackWorkspace: input.slackWorkspace ?? current.slackWorkspace,
+      slackChannelId:
+        input.slackChannelId !== undefined
+          ? input.slackChannelId.trim() || null
+          : current.slackChannelId,
+      slackChannelName:
+        input.slackChannelName !== undefined
+          ? input.slackChannelName.trim() || null
+          : current.slackChannelName,
+      repository:
+        input.repository !== undefined
+          ? input.repository.trim() || null
+          : current.repository,
+      sentryOrgSlug:
+        input.sentryOrgSlug !== undefined
+          ? input.sentryOrgSlug.trim() || null
+          : current.sentryOrgSlug,
+      sentryProjectSlug:
+        input.sentryProjectSlug !== undefined
+          ? input.sentryProjectSlug.trim() || null
+          : current.sentryProjectSlug,
+      sentryEnvironment:
+        input.sentryEnvironment !== undefined
+          ? input.sentryEnvironment.trim() || null
+          : current.sentryEnvironment,
+      authorMode,
+      authorIds,
+      scheduleMode,
+      intervalMinutes: input.intervalMinutes ?? current.intervalMinutes,
+      dailyHour: input.dailyHour ?? current.dailyHour,
+      dailyMinute: input.dailyMinute ?? current.dailyMinute,
+      timezone,
+      inboxLimit: clampInboxLimit(input.inboxLimit ?? current.inboxLimit),
+      workLimit: clampWorkLimit(
+        input.workLimit ?? current.workLimit,
+        current.source,
+      ),
+    };
+    const schedule = scheduleCron(config);
+    if (definition.meta.triggerType === "schedule" && !isValidCron(schedule)) {
+      throw new Error(`Invalid cron expression "${schedule}".`);
+    }
+    let content = applyAutomationConfigFrontmatter(resource.content, config);
+    content = replaceUserPrompt(content, input.prompt);
+    content = setAutomationFrontmatterField(
+      content,
+      "enabled",
+      input.enabled ? "true" : "false",
+    );
+    content = setAutomationFrontmatterField(
+      content,
+      "factoryId",
+      input.factoryId,
+    );
+    if (input.model !== undefined) {
+      content = setAutomationFrontmatterField(
+        content,
+        "model",
+        input.model.trim() || "",
+      );
+    }
+    if (input.displayName !== undefined) {
+      content = setAutomationFrontmatterField(
+        content,
+        "displayName",
+        input.displayName,
+      );
+    }
     if (definition.meta.triggerType === "schedule" && isValidCron(schedule)) {
       const nextRun = nextOccurrence(
         schedule,
         undefined,
-        definition.meta.timezone,
+        config.timezone ?? undefined,
       ).toISOString();
       content = setAutomationFrontmatterField(content, "nextRun", nextRun);
     }
@@ -119,10 +214,13 @@ export default defineAction({
       id: definition.resource.id,
       name: definition.name,
       displayName: resolveAutomationDisplayName(definition.name, content),
-      prompt,
+      prompt: input.prompt,
       model: readAutomationModel(content),
       schedule: readAutomationSchedule(content),
       enabled: readAutomationEnabled(content),
+      source: config.source,
+      inboxLimit: config.inboxLimit,
+      workLimit: config.workLimit,
     };
   },
 });

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

@@ -17,9 +17,37 @@ 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";
 
+function chatContextFromAction(
+  context:
+    | {
+        caller?: string;
+        threadId?: unknown;
+        runId?: unknown;
+        turnId?: unknown;
+      }
+    | undefined,
+): Record<string, string> | undefined {
+  if (!context) return undefined;
+  if (
+    context.caller !== "tool" &&
+    context.caller !== "mcp" &&
+    context.caller !== "a2a"
+  ) {
+    return undefined;
+  }
+  const chatContext = Object.fromEntries(
+    ["threadId", "runId", "turnId"].flatMap((key) =>
+      typeof context[key as keyof typeof context] === "string" &&
+      (context[key as keyof typeof context] as string).trim()
+        ? [[key, context[key as keyof typeof context] as string]]
+        : [],
+    ),
+  );
+  return chatContext.runId || chatContext.turnId ? chatContext : undefined;
+}
+
 export default defineAction({
   description:
     "Create or update a Factory's versioned visual graph. Pass expectedGraphVersion from the graph you inspected so stale edits are rejected. Use source=ai for an agent-proposed graph and source=manual for a direct editor save. This changes configuration only; it never starts provider work.",
@@ -63,8 +91,8 @@ export default defineAction({
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
+    const chatContext = chatContextFromAction(context);
     const db = getDb();
-    let createdNewFactory = false;
 
     const result = await db.transaction(async (tx) => {
       const existing = (
@@ -125,7 +153,6 @@ export default defineAction({
           );
         }
       } else {
-        createdNewFactory = true;
         await tx.insert(factoryDefinitions).values({
           id: factoryId,
           name,
@@ -149,6 +176,7 @@ export default defineAction({
         changeSummary,
         createdAt: now,
         createdBy: userEmail,
+        ...(chatContext ? { chatContext: JSON.stringify(chatContext) } : {}),
         ownerEmail: userEmail,
         orgId,
       });
@@ -161,11 +189,6 @@ export default defineAction({
         source,
       };
     });
-    if (createdNewFactory) {
-      await ensureFactoryAutomations(userEmail, orgId, factoryId, {
-        enabled: false,
-      });
-    }
     return result;
   },
 });

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

@@ -7,10 +7,7 @@ import {
   readFactoryDefinition,
   DEFAULT_FACTORY_ID,
 } from "../server/factory-graph/store.js";
-import {
-  isFactorySlackChannelConflict,
-  resolveEnabledAutomationsFromSavedConfig,
-} from "../server/lib/factory-automation-plan.js";
+import { isFactorySlackChannelConflict } from "../server/lib/factory-automation-plan.js";
 import {
   assertUniqueSlackChannelForFactory,
   builderSlackUserIdSchema,
@@ -18,15 +15,11 @@ import {
   factoryIdSchema,
   readTriageConfigRow,
 } from "../server/lib/factory-scope.js";
+import { persistGitHubRepository } from "../server/lib/github-repository.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({
@@ -44,7 +37,7 @@ export default defineAction({
     sentryOrgSlug: z.string().trim().max(200).optional(),
     sentryProjectSlug: z.string().trim().max(200).optional(),
     sentryEnvironment: z.string().trim().max(200).optional(),
-    repository: z.string().trim().max(256).optional(),
+    repository: z.string().trim().max(512).optional(),
     automationFailureAlertsEnabled: z.boolean().optional(),
     automationFailureAlertEmail: z
       .union([z.string().trim().email(), z.literal("")])
@@ -106,7 +99,10 @@ export default defineAction({
         : builderSlackUserId.toUpperCase(),
       existing?.builderSlackUserId,
     );
-    const persistedRepository = persistText(repository, existing?.repository);
+    const persistedRepository =
+      repository === undefined
+        ? persistGitHubRepository(existing?.repository)
+        : persistGitHubRepository(repository);
     const persistedSentryOrgSlug = persistText(
       sentryOrgSlug,
       existing?.sentryOrgSlug,
@@ -204,22 +200,6 @@ export default defineAction({
       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,

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

@@ -23,7 +23,7 @@ import { stableId } from "../server/triage/ids.js";
 
 export default defineAction({
   description:
-    "Create or update a Factory rule. Disabled and shadow modes are accepted; execution still requires an explicit approval action.",
+    "Create or update a Factory rule. Disabled and shadow modes are accepted; dispatch still goes through dispatch-factory-item or govern-factory-pull-request.",
   schema: z.object({
     factoryId: factoryIdSchema.default(DEFAULT_FACTORY_ID),
     id: z.string().min(1).optional(),