@agent-native/core 0.136.4 → 0.137.0

package/corpus/templates/factory/server/plugins/factory-scheduler-job.ts

@@ -1,41 +1,146 @@
+import { resolveOrgIdForEmail } from "@agent-native/core/org";
 import {
-  WORKSPACE_OWNER,
+  organizationResourceOwner,
   resourceGetByPath,
   resourcePut,
+  WORKSPACE_OWNER,
 } from "@agent-native/core/resources";
 import { defineNitroPlugin } from "@agent-native/core/server";
+import { and, eq } from "drizzle-orm";
 
-const JOB_PATH = "jobs/factory-observation-scheduler.md";
+import { getDb } from "../db/index.js";
+import { triageConfig } from "../db/schema.js";
 
-const JOB_BODY = `
-# Factory observation scheduler
+const LEGACY_JOB_PATH = "jobs/factory-observation-scheduler.md";
+const DEFAULT_SLACK_CHANNEL_ID = "C0ATH3CCZT4";
+const DEFAULT_SLACK_CHANNEL_NAME = "product-agent-native-feedback";
 
-Call get-triage-config. If pollingEnabled is true and a Slack channel is
-configured, call poll-slack-channel. Then call list-triage-items with status
-received and evaluate each returned item with evaluate-triage-item. Keep the
-work bounded to the returned page. This scheduled observer does not start work
-or send provider messages; interactive approvals happen through the Factory agent.
-If any action reports an error, preserve that error and continue to the next
-item; do not report a false success.
-`;
+type AutomationSeed = {
+  name: string;
+  schedule: string;
+  timezone?: string;
+  body: string;
+};
+
+const AUTOMATION_SEEDS: AutomationSeed[] = [
+  {
+    name: "factory-slack-feedback",
+    schedule: "* * * * *",
+    body: `
+# Factory Slack feedback triage
+
+Read the Factory configuration. When Slack polling is enabled and a channel is
+configured, call poll-slack-channel first. Then list a bounded page of
+received Slack items and call get-slack-feedback-context for each item before
+classifying it.
+
+Start work only for a clear bug: a concrete broken behavior, reproducible
+failure, error, regression, stuck run, incorrect result, or a report with a
+specific failing path and enough evidence to investigate. Do not treat feature
+requests, wish-list ideas, broad UX suggestions, vague questions, or an
+incomplete/truncated thread as clear bugs. The user's historical eyeball
+reactions are calibration evidence, not an automatic authorization signal.
+That history is strongest for concrete failures such as stuck or never-starting
+runs, incorrect object/object output, disk-full or database-locked errors,
+stale loops, broken uploads or duplicate imports, missing scaffolding or docs,
+and concrete auth or configuration failures. Use those examples to recognize
+the shape of a bug, not to turn similar-sounding reports into automatic work.
+
+For a clear bug outside Clips, Design, and Content, call start-builder-for-item
+with clearBug true and a short evidence-grounded reason. That action adds the
+eyes reaction and tags @builderio in the Slack thread, asking Builder to fix
+it in a reply and send a PR. Never add the reaction or tag Builder for
+owner-managed Clips, Design, or Content work, or for a non-bug report.
+
+Keep each run bounded. Preserve action errors and do not claim a Builder reply,
+PR, merge, or fix unless an action returned that state.
+`,
+  },
+  {
+    name: "factory-sentry-errors",
+    schedule: "0 9 * * *",
+    timezone: "America/Los_Angeles",
+    body: `
+# Factory Sentry error triage
+
+Read the Factory configuration. When Sentry polling is enabled and a Sentry
+organization is configured, call poll-sentry-errors. List a bounded page of
+received Sentry items and inspect the title, culprit, level, event count, and
+errorReport metadata.
+
+Only classify a concrete unresolved error as a clear bug when the Sentry
+evidence is sufficient to investigate. Do not dispatch on noise, expected
+errors, product ideas, or incomplete provider responses. Clips, Design, and
+Content errors are owner-managed and must remain needs_manual.
+
+For each eligible clear bug, call start-builder-for-item with clearBug true,
+an evidence-grounded reason, and clearErrorReport containing only the bounded
+Sentry evidence. Builder should open a PR; do not claim it did so until the
+run callback or PR observation confirms it.
+`,
+  },
+  {
+    name: "factory-github-issues",
+    schedule: "* * * * *",
+    body: `
+# Factory GitHub issue triage
 
-function workspaceOwnerEmail() {
+Read the Factory configuration. When GitHub source polling is enabled and a
+repository is configured, call poll-github-sources with includeIssues true and
+includePullRequests false. List a bounded page of received github_issue items.
+
+Treat an issue as a clear bug only when it has a concrete error report,
+reproduction, incorrect behavior, regression, or specific failing path. Do
+not dispatch feature requests, vague questions, or issues without enough
+evidence. Clips, Design, and Content remain owner-managed.
+
+For each eligible item call start-builder-for-item with clearBug true,
+evidence-grounded reason, and the bounded issue body as clearErrorReport.
+Preserve failures and never report a successful Builder run without its action
+confirmation.
+`,
+  },
+  {
+    name: "factory-pr-governance",
+    schedule: "*/5 * * * *",
+    body: `
+# Factory pull-request governance
+
+Read the Factory configuration. When GitHub polling is enabled and a repository
+is configured, call poll-github-sources with includeIssues false and
+includePullRequests true. List a bounded page of github pull-request items.
+
+For each open agent-native PR, inspect the item and classify whether it is a
+clear bug fix or has product or UX implications. Call
+govern-agent-native-pull-request with the item id, repository, pull request
+number, clearBug, productUxImplications, and a short reason. The action fetches
+fresh CI and review evidence before approving or merging. Clear internal bug
+fixes with passing CI and handled review feedback may be auto-approved.
+
+Only auto-merge when the PR proves its Factory origin by retaining the Factory
+item id or source link in the PR description, or by using the Factory branch
+name. A normal open PR must never be treated as a Builder-triggered run.
+
+Never auto-approve or auto-merge Clips, Design, or Content PRs. Those apps are
+fully owned by their product owners. Auto-merge is limited to PRs with a
+verified Factory Builder run; all other PRs can at most pass the approval
+policy. Do not call GitHub write actions directly or claim a merge unless the
+governance action confirms it.
+`,
+  },
+];
+
+function workspaceOwnerEmail(): string | undefined {
   const email = process.env.WORKSPACE_OWNER_EMAIL?.trim().toLowerCase(); // guard:allow-env-credential - deployment owner identity, not a user credential
   if (!email || /[\r\n]/.test(email)) return undefined;
   return email;
 }
 
-function readFrontmatterField(content: string, key: string): string | null {
-  if (!content.startsWith("---\n")) return null;
-  const end = content.indexOf("\n---", 4);
-  if (end === -1) return null;
-  const match = content
-    .slice(4, end)
-    .match(new RegExp(`^${key}:\\s*(.*)$`, "m"));
-  return match ? match[1].trim() : null;
-}
-
-function setFrontmatterField(content: string, key: string, value: string) {
+function setFrontmatterField(
+  content: string,
+  key: string,
+  value: string,
+): string {
   if (!content.startsWith("---\n")) return content;
   const end = content.indexOf("\n---", 4);
   if (end === -1) return content;
@@ -47,70 +152,116 @@ function setFrontmatterField(content: string, key: string, value: string) {
   return `${content.slice(0, end)}\n${key}: ${value}${content.slice(end)}`;
 }
 
-function jobContent(createdBy: string) {
+function automationContent(
+  ownerEmail: string,
+  orgId: string,
+  seed: AutomationSeed,
+): string {
   return `---
-schedule: "* * * * *"
-enabled: true
-createdBy: ${createdBy}
+schedule: "${seed.schedule}"
+${seed.timezone ? `timezone: ${seed.timezone}\n` : ""}enabled: true
+triggerType: schedule
+domain: factory
+orgId: ${orgId}
+createdBy: ${ownerEmail}
 runAs: creator
 ---
-${JOB_BODY}`;
+${seed.body.trim()}
+`;
 }
 
-async function ensureSchedulerJob() {
-  const existing = await resourceGetByPath(WORKSPACE_OWNER, JOB_PATH);
-  const ownerEmail = workspaceOwnerEmail();
-
-  if (!existing) {
-    if (!ownerEmail) {
-      throw new Error(
-        "WORKSPACE_OWNER_EMAIL is required to seed the Factory scheduler",
-      );
-    }
+async function disableLegacyObserver(): Promise<void> {
+  const existing = await resourceGetByPath(WORKSPACE_OWNER, LEGACY_JOB_PATH);
+  if (!existing) return;
+  const disabled = setFrontmatterField(existing.content, "enabled", "false");
+  if (disabled !== existing.content) {
     await resourcePut(
       WORKSPACE_OWNER,
-      JOB_PATH,
-      jobContent(ownerEmail),
+      LEGACY_JOB_PATH,
+      disabled,
+      "text/markdown",
+    );
+  }
+}
+
+async function ensureOrganizationAutomations(
+  ownerEmail: string,
+  orgId: string,
+): Promise<void> {
+  const owner = organizationResourceOwner(orgId);
+  for (const seed of AUTOMATION_SEEDS) {
+    const path = `jobs/${seed.name}.md`;
+    if (await resourceGetByPath(owner, path)) continue;
+    await resourcePut(
+      owner,
+      path,
+      automationContent(ownerEmail, orgId, seed),
       "text/markdown",
     );
-    return;
   }
+}
 
+async function ensureDefaultTriageConfig(
+  ownerEmail: string,
+  orgId: string,
+): Promise<void> {
+  const db = getDb();
+  const existing = (
+    await db
+      .select({ id: triageConfig.id })
+      .from(triageConfig)
+      .where(and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)))
+      .limit(1)
+  )[0];
+  if (existing) return;
+  const now = new Date().toISOString();
+  await db.insert(triageConfig).values({
+    id: orgId,
+    slackWorkspace: "primary",
+    slackChannelId: DEFAULT_SLACK_CHANNEL_ID,
+    slackChannelName: DEFAULT_SLACK_CHANNEL_NAME,
+    pollingEnabled: 1,
+    githubPollingEnabled: 0,
+    sentryPollingEnabled: 0,
+    lastSlackTs: null,
+    slackHistoryCursor: null,
+    repository: null,
+    sentryOrgSlug: null,
+    sentryProjectSlug: null,
+    sentryEnvironment: null,
+    lastSentrySeenAt: null,
+    createdAt: now,
+    updatedAt: now,
+    ownerEmail,
+    orgId,
+  });
+}
+
+async function ensureSchedulerJobs(): Promise<void> {
+  const ownerEmail = workspaceOwnerEmail();
   if (!ownerEmail) {
-    const runAs = readFrontmatterField(existing.content, "runAs");
-    const createdBy = readFrontmatterField(existing.content, "createdBy");
-    if (runAs === "creator" && createdBy) return;
     throw new Error(
-      "WORKSPACE_OWNER_EMAIL is required to repair the Factory scheduler",
+      "WORKSPACE_OWNER_EMAIL is required to seed Factory automations",
     );
   }
-
-  if (
-    !existing.content.startsWith("---\n") ||
-    !existing.content.includes("\n---", 4)
-  ) {
-    await resourcePut(
-      WORKSPACE_OWNER,
-      JOB_PATH,
-      jobContent(ownerEmail),
-      "text/markdown",
+  const orgId = await resolveOrgIdForEmail(ownerEmail);
+  if (!orgId) {
+    throw new Error(
+      "The Factory deployment owner must belong to an organization before automations can be seeded",
     );
-    return;
   }
-
-  const migrated = setFrontmatterField(
-    setFrontmatterField(existing.content, "createdBy", ownerEmail),
-    "runAs",
-    "creator",
-  );
-  if (migrated === existing.content) return;
-  await resourcePut(WORKSPACE_OWNER, JOB_PATH, migrated, "text/markdown");
+  await ensureDefaultTriageConfig(ownerEmail, orgId);
+  await ensureOrganizationAutomations(ownerEmail, orgId);
+  await disableLegacyObserver();
 }
 
 export default defineNitroPlugin(async () => {
   try {
-    await ensureSchedulerJob();
+    await ensureSchedulerJobs();
   } catch (error) {
-    console.error("[factory-scheduler-job] failed to seed job:", error);
+    console.error(
+      "[factory-scheduler-job] failed to seed organization automations:",
+      error,
+    );
   }
 });

package/corpus/templates/factory/server/triage/builder-executor.ts

@@ -8,6 +8,7 @@ export interface BuilderExecutorInput {
   repository?: string | null;
   summary?: string | null;
   sourceUrl?: string | null;
+  instructions?: string | null;
 }
 
 export interface BuilderExecutorResult {
@@ -63,12 +64,15 @@ export async function startBuilderRun(
   const branchName = `factory/${input.itemId.slice(0, 12)}`;
   const prompt = [
     "Work on this approved Factory item.",
+    `Factory item: ${input.itemId}`,
     input.summary
       ? `Feedback: ${input.summary}`
       : "No feedback summary was supplied.",
     input.sourceUrl ? `Source: ${input.sourceUrl}` : "",
     input.repository ? `Repository: ${input.repository}` : "",
+    input.instructions ? `Triage instructions: ${input.instructions}` : "",
     "Inspect the repository, make the smallest safe fix, run validation, and open a pull request.",
+    "Include the Factory item id and source link in the pull request description.",
     "Do not touch protected areas: auth/session/identity, credentials/vault, migrations, payments, security, or publishable packages.",
   ]
     .filter(Boolean)

package/corpus/templates/factory/server/triage/contracts.ts

@@ -1,6 +1,11 @@
 import { z } from "zod";
 
-export const triageSourceSchema = z.enum(["slack", "github"]);
+export const triageSourceSchema = z.enum([
+  "slack",
+  "github",
+  "github_issue",
+  "sentry",
+]);
 export type TriageSource = z.infer<typeof triageSourceSchema>;
 
 export const triageItemStatusSchema = z.enum([
@@ -12,6 +17,10 @@ export const triageItemStatusSchema = z.enum([
   "needs_manual",
   "failed",
   "reconciliation_required",
+  "automation_started",
+  "pr_observed",
+  "auto_approved",
+  "merged",
 ]);
 export type TriageItemStatus = z.infer<typeof triageItemStatusSchema>;
 
@@ -37,6 +46,8 @@ export const triageDecisionOutcomeSchema = z.enum([
   "needs_manual",
   "propose_fix",
   "propose_review",
+  "auto_approve",
+  "auto_merge",
 ]);
 export type TriageDecisionOutcome = z.infer<typeof triageDecisionOutcomeSchema>;
 
@@ -68,6 +79,7 @@ export const triageGuardCodeSchema = z.enum([
   "path_denied",
   "diff_too_large",
   "unknown_change",
+  "owner_owned",
 ]);
 export type TriageGuardCode = z.infer<typeof triageGuardCodeSchema>;
 
@@ -81,6 +93,7 @@ export const hardNeverAutomateGuardCodes: TriageGuardCode[] = [
   "payments",
   "security",
   "publishable_package",
+  "owner_owned",
 ];
 
 export const triagePolicyGuardsSchema = z.object({