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

package/corpus/templates/factory/actions/poll-github-sources.ts

@@ -4,12 +4,14 @@ import { z } from "zod";
 
 import { getDb } from "../server/db/index.js";
 import { triageItems } from "../server/db/schema.js";
+import { readCallingFactoryAutomation } from "../server/lib/factory-automation-caller.js";
 import { repairFactoryAutomationsFromConfig } from "../server/lib/factory-automation-repair.js";
 import {
   factoryIdSchema,
   readTriageConfigRow,
   requireExistingFactory,
 } from "../server/lib/factory-scope.js";
+import { parseGitHubRepositoryRef } from "../server/lib/github-repository.js";
 import { requireFactoryAutomation } from "../server/lib/require-factory-automation.js";
 import {
   requireWorkspaceMember,
@@ -18,18 +20,39 @@ import {
 import { recordFactoryAudit } from "../server/triage/audit.js";
 import { createGitHubClient } from "../server/triage/github-client.js";
 import { itemDedupeKey } from "../server/triage/ids.js";
-import { mergeTriageMetadata } from "../server/triage/metadata.js";
+import {
+  mergeTriageMetadata,
+  metadataString,
+  parseTriageMetadata,
+} from "../server/triage/metadata.js";
 import {
   hasTriageSourceChanged,
+  statusAfterPullRequestPoll,
   statusAfterTriageSourceUpdate,
 } from "../server/triage/review-state.js";
 
-function parseRepository(value: string): { owner: string; repo: string } {
-  const match = /^([^/\s]+)\/([^/\s]+)$/.exec(value.trim());
-  if (!match) {
-    throw new Error("Factory repository must use the owner/repository format.");
+type NewlyObservedSource = {
+  itemId: string;
+  source: "github" | "github_issue";
+  sourceUrl: string;
+  summary: string;
+  number: number;
+};
+
+function githubPollRollupSummary(
+  issueCount: number,
+  pullRequestCount: number,
+): string {
+  const parts: string[] = [];
+  if (issueCount > 0) {
+    parts.push(`${issueCount} open issue${issueCount === 1 ? "" : "s"}`);
+  }
+  if (pullRequestCount > 0) {
+    parts.push(
+      `${pullRequestCount} open pull request${pullRequestCount === 1 ? "" : "s"}`,
+    );
   }
-  return { owner: match[1], repo: match[2] };
+  return `Polled ${parts.join(" and ")}.`;
 }
 
 export default defineAction({
@@ -48,21 +71,24 @@ export default defineAction({
     await requireFactoryAutomation(
       context,
       { userEmail, orgId },
-      "sourcePolling",
+      "githubPolling",
       factoryId,
     );
     const db = getDb();
     const config = await readTriageConfigRow(db, orgId, factoryId);
     await repairFactoryAutomationsFromConfig(userEmail, orgId, factoryId);
-    if (config?.githubPollingEnabled !== 1) {
-      throw new Error("Enable GitHub polling before polling GitHub sources.");
-    }
-    if (!config.repository) {
+    const job = await readCallingFactoryAutomation(context, {
+      userEmail,
+      orgId,
+    });
+    const repositoryRef = job?.config.repository || config?.repository;
+    if (!repositoryRef) {
       throw new Error("Configure a GitHub repository before polling GitHub.");
     }
+    const inboxLimit = job?.config.inboxLimit ?? 25;
 
-    const repositoryName = config.repository;
-    const repository = parseRepository(repositoryName);
+    const repository = parseGitHubRepositoryRef(repositoryRef);
+    const repositoryName = `${repository.owner}/${repository.repo}`;
     const client = createGitHubClient({ ownerEmail: userEmail, orgId });
     const [issues, pullRequests] = await Promise.all([
       includeIssues
@@ -75,6 +101,8 @@ export default defineAction({
     const now = new Date().toISOString();
     let issueCount = 0;
     let pullRequestCount = 0;
+    let added = 0;
+    const newlyObserved: NewlyObservedSource[] = [];
 
     await db.transaction(async (tx) => {
       for (const issue of issues) {
@@ -93,9 +121,11 @@ export default defineAction({
             .where(and(eq(triageItems.id, id), eq(triageItems.orgId, orgId)))
             .limit(1)
         )[0];
+        if (!existing && added >= inboxLimit) continue;
         const metadata = mergeTriageMetadata(existing?.metadataJson ?? "{}", {
           kind: "github_issue",
           author: issue.userLogin,
+          authorId: issue.userId,
           labels: [...issue.labels],
           errorReport: [issue.title, issue.body ?? ""]
             .filter(Boolean)
@@ -118,6 +148,16 @@ export default defineAction({
         const lastSeenAt = sourceChanged
           ? issue.updatedAt
           : (existing?.lastSeenAt ?? issue.updatedAt);
+        if (!existing) added += 1;
+        if (!existing || sourceChanged) {
+          newlyObserved.push({
+            itemId: id,
+            source: "github_issue",
+            sourceUrl: issue.htmlUrl,
+            summary: issue.title,
+            number: issue.number,
+          });
+        }
         await tx
           .insert(triageItems)
           .values({
@@ -173,31 +213,50 @@ export default defineAction({
             .where(and(eq(triageItems.id, id), eq(triageItems.orgId, orgId)))
             .limit(1)
         )[0];
+        if (!existing && added >= inboxLimit) continue;
         const metadata = mergeTriageMetadata(existing?.metadataJson ?? "{}", {
           kind: "pull_request",
           author: pullRequest.userLogin,
+          authorId: String(pullRequest.userId),
           headRef: pullRequest.headRef,
           baseRef: pullRequest.baseRef,
           draft: pullRequest.draft,
           updatedAt: pullRequest.updatedAt,
         });
         const summary = pullRequest.body?.slice(0, 4_000) ?? null;
+        // GitHub updatedAt moves on CI and comments; head SHA is the review signal.
         const sourceChanged = hasTriageSourceChanged(existing, {
           sourceUrl: pullRequest.htmlUrl,
           title: pullRequest.title,
           summary,
-          lastSeenAt: pullRequest.updatedAt,
           headSha: pullRequest.headSha,
         });
-        const status = statusAfterTriageSourceUpdate(
-          existing?.status,
+        const existingMetadata = existing
+          ? parseTriageMetadata(existing.metadataJson)
+          : {};
+        const status = statusAfterPullRequestPoll({
+          existingStatus: existing?.status,
+          existingAuthor: metadataString(existingMetadata, "author"),
+          nextAuthor: pullRequest.userLogin,
+          existingBabysitState: metadataString(
+            existingMetadata,
+            "prBabysitState",
+          ),
+          nextDraft: pullRequest.draft,
           sourceChanged,
-          "pr_observed",
-        );
+        });
         const updatedAt = sourceChanged ? now : (existing?.updatedAt ?? now);
-        const lastSeenAt = sourceChanged
-          ? pullRequest.updatedAt
-          : (existing?.lastSeenAt ?? pullRequest.updatedAt);
+        const lastSeenAt = pullRequest.updatedAt;
+        if (!existing) added += 1;
+        if (!existing || (sourceChanged && status === "pr_observed")) {
+          newlyObserved.push({
+            itemId: id,
+            source: "github",
+            sourceUrl: pullRequest.htmlUrl,
+            summary: pullRequest.title,
+            number: pullRequest.number,
+          });
+        }
         await tx
           .insert(triageItems)
           .values({
@@ -261,50 +320,35 @@ export default defineAction({
         factoryId,
       );
     } else {
-      for (const issue of issues) {
-        await recordFactoryAudit(
-          context,
-          { userEmail, orgId },
-          {
-            action: "poll-github-sources",
-            kind: "observed",
-            itemId: itemDedupeKey(
-              {
-                source: "github_issue",
-                externalId: `${repositoryName}#${issue.number}`,
-              },
-              orgId,
-              factoryId,
-            ),
-            source: "github_issue",
-            sourceUrl: issue.htmlUrl,
-            summary: issue.title,
-            details: { repository: repositoryName, number: issue.number },
+      await recordFactoryAudit(
+        context,
+        { userEmail, orgId },
+        {
+          action: "poll-github-sources",
+          kind: "observed",
+          source: "github",
+          summary: githubPollRollupSummary(issueCount, pullRequestCount),
+          details: {
+            repository: repositoryName,
+            issues: issueCount,
+            pullRequests: pullRequestCount,
+            newlyObserved: newlyObserved.length,
           },
-          factoryId,
-        );
-      }
-      for (const pullRequest of pullRequests) {
+        },
+        factoryId,
+      );
+      for (const item of newlyObserved) {
         await recordFactoryAudit(
           context,
           { userEmail, orgId },
           {
             action: "poll-github-sources",
             kind: "observed",
-            itemId: itemDedupeKey(
-              {
-                source: "github",
-                externalId: `${repositoryName}#${pullRequest.number}`,
-                repository: repositoryName,
-                pullRequestNumber: pullRequest.number,
-              },
-              orgId,
-              factoryId,
-            ),
-            source: "github",
-            sourceUrl: pullRequest.htmlUrl,
-            summary: pullRequest.title,
-            details: { repository: repositoryName, number: pullRequest.number },
+            itemId: item.itemId,
+            source: item.source,
+            sourceUrl: item.sourceUrl,
+            summary: item.summary,
+            details: { repository: repositoryName, number: item.number },
           },
           factoryId,
         );

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

@@ -4,7 +4,12 @@ import { z } from "zod";
 
 import { getDb } from "../server/db/index.js";
 import { triageConfig, triageItems } from "../server/db/schema.js";
+import { readCallingFactoryAutomation } from "../server/lib/factory-automation-caller.js";
 import { repairFactoryAutomationsFromConfig } from "../server/lib/factory-automation-repair.js";
+import {
+  readFactoryPollCursor,
+  writeFactoryPollCursor,
+} from "../server/lib/factory-poll-cursors.js";
 import {
   factoryIdSchema,
   factoryStillPresent,
@@ -47,27 +52,43 @@ export default defineAction({
     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.");
-    }
-    if (!config.sentryOrgSlug) {
+    const job = await readCallingFactoryAutomation(context, {
+      userEmail,
+      orgId,
+    });
+    const sentryOrgSlug =
+      job?.config.sentryOrgSlug?.trim() || config?.sentryOrgSlug || "";
+    const sentryProjectSlug =
+      job?.config.sentryProjectSlug?.trim() || config?.sentryProjectSlug || "";
+    const sentryEnvironment =
+      job?.config.sentryEnvironment?.trim() || config?.sentryEnvironment || "";
+    if (!sentryOrgSlug) {
       throw new Error("Configure a Sentry organization before polling Sentry.");
     }
+    const inboxLimit = Math.min(job?.config.inboxLimit ?? 25, limit);
+    const destinationKey = `${sentryOrgSlug}/${sentryProjectSlug}`;
+    const storedCursor = await readFactoryPollCursor(
+      db,
+      orgId,
+      factoryId,
+      "sentry",
+      destinationKey,
+    );
     const query = [
       "is:unresolved",
-      config.sentryProjectSlug ? `project:${config.sentryProjectSlug}` : "",
-      config.sentryEnvironment ? `environment:${config.sentryEnvironment}` : "",
+      sentryProjectSlug ? `project:${sentryProjectSlug}` : "",
+      sentryEnvironment ? `environment:${sentryEnvironment}` : "",
     ]
       .filter(Boolean)
       .join(" ");
     const issues = await createSentryClient({
       ownerEmail: userEmail,
       orgId,
-      orgSlug: config.sentryOrgSlug,
-    }).listIssues(query, limit);
-    const cursor = config.lastSentrySeenAt
-      ? Date.parse(config.lastSentrySeenAt)
-      : null;
+      orgSlug: sentryOrgSlug,
+    }).listIssues(query, inboxLimit);
+    const lastSentrySeenAt =
+      storedCursor?.lastSentrySeenAt ?? config?.lastSentrySeenAt ?? null;
+    const cursor = lastSentrySeenAt ? Date.parse(lastSentrySeenAt) : null;
     if (cursor !== null && Number.isNaN(cursor)) {
       throw new Error("Stored Sentry polling cursor is not a valid timestamp.");
     }
@@ -83,7 +104,17 @@ export default defineAction({
     }
     const observedIssues = issues;
     const now = new Date().toISOString();
-    const configRowId = triageConfigUpdateRowId(config, orgId, factoryId);
+    const configRowId = config
+      ? triageConfigUpdateRowId(config, orgId, factoryId)
+      : null;
+    let added = 0;
+    const nextSentrySeenAt =
+      observedIssues.reduce<string | null>((latest, issue) => {
+        if (!latest) return issue.firstSeen;
+        return Date.parse(issue.firstSeen) > Date.parse(latest)
+          ? issue.firstSeen
+          : latest;
+      }, lastSentrySeenAt) ?? lastSentrySeenAt;
 
     await db.transaction(async (tx) => {
       for (const issue of observedIssues) {
@@ -99,6 +130,8 @@ export default defineAction({
             .where(and(eq(triageItems.id, id), eq(triageItems.orgId, orgId)))
             .limit(1)
         )[0];
+        if (!existing && added >= inboxLimit) continue;
+        if (!existing) added += 1;
         const metadata = mergeTriageMetadata(existing?.metadataJson ?? "{}", {
           kind: "sentry_issue",
           sentryIssueId: issue.id,
@@ -166,29 +199,33 @@ export default defineAction({
           });
       }
 
-      await tx
-        .update(triageConfig)
-        .set({
-          lastSentrySeenAt:
-            observedIssues.reduce<string | null>((latest, issue) => {
-              if (!latest) return issue.firstSeen;
-              return Date.parse(issue.firstSeen) > Date.parse(latest)
-                ? issue.firstSeen
-                : latest;
-            }, config.lastSentrySeenAt) ?? config.lastSentrySeenAt,
-          updatedAt: now,
-        })
-        .where(
-          and(
-            eq(triageConfig.id, configRowId),
-            eq(triageConfig.orgId, orgId),
-            factoryStillPresent(
-              tx as unknown as ReturnType<typeof getDb>,
-              orgId,
-              factoryId,
+      await writeFactoryPollCursor(tx as unknown as ReturnType<typeof getDb>, {
+        orgId,
+        factoryId,
+        source: "sentry",
+        destinationKey,
+        ownerEmail: userEmail,
+        lastSentrySeenAt: nextSentrySeenAt,
+      });
+      if (config && configRowId) {
+        await tx
+          .update(triageConfig)
+          .set({
+            lastSentrySeenAt: nextSentrySeenAt,
+            updatedAt: now,
+          })
+          .where(
+            and(
+              eq(triageConfig.id, configRowId),
+              eq(triageConfig.orgId, orgId),
+              factoryStillPresent(
+                tx as unknown as ReturnType<typeof getDb>,
+                orgId,
+                factoryId,
+              ),
             ),
-          ),
-        );
+          );
+      }
       await requireExistingFactory(
         tx as unknown as ReturnType<typeof getDb>,
         orgId,
@@ -205,7 +242,7 @@ export default defineAction({
           kind: "observed",
           source: "sentry",
           summary: "No unresolved Sentry errors were observed.",
-          details: { sentryOrgSlug: config.sentryOrgSlug },
+          details: { sentryOrgSlug },
         },
         factoryId,
       );
@@ -242,7 +279,7 @@ export default defineAction({
       factoryId,
       observed: observedIssues.length,
       fetched: issues.length,
-      sentryOrgSlug: config.sentryOrgSlug,
+      sentryOrgSlug,
     };
   },
 });

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

@@ -4,7 +4,13 @@ import { z } from "zod";
 
 import { getDb } from "../server/db/index.js";
 import { triageConfig, triageItems } from "../server/db/schema.js";
+import { readCallingFactoryAutomation } from "../server/lib/factory-automation-caller.js";
+import { authorMatchesFilter } from "../server/lib/factory-automation-config.js";
 import { repairFactoryAutomationsFromConfig } from "../server/lib/factory-automation-repair.js";
+import {
+  readFactoryPollCursor,
+  writeFactoryPollCursor,
+} from "../server/lib/factory-poll-cursors.js";
 import {
   factoryIdSchema,
   factoryStillPresent,
@@ -18,6 +24,7 @@ import {
   workspaceMemberIdentityFromContext,
 } from "../server/lib/require-workspace-member.js";
 import { recordFactoryAudit } from "../server/triage/audit.js";
+import type { IngestionEnvelope } from "../server/triage/contracts.js";
 import { itemDedupeKey } from "../server/triage/ids.js";
 import {
   hasTriageSourceChanged,
@@ -27,7 +34,7 @@ import { pollSlackChannel } from "../server/triage/slack-poller.js";
 
 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.",
+    "Poll the Slack channel for this Factory job 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(),
@@ -46,34 +53,86 @@ export default defineAction({
     const db = getDb();
     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 configuredChannelId = config?.slackChannelId;
-    if (!configuredChannelId) {
+    const job = await readCallingFactoryAutomation(context, {
+      userEmail,
+      orgId,
+    });
+    const jobConfig = job?.config;
+    const channelId =
+      jobConfig?.slackChannelId?.trim() || config?.slackChannelId || "";
+    if (!channelId) {
       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.",
-      );
+    if (requestedChannelId && requestedChannelId !== channelId) {
+      throw new Error("Poll only the Slack channel configured for this job.");
     }
-    const channelId = configuredChannelId;
+    const workspace =
+      jobConfig?.slackWorkspace === "secondary" ||
+      config?.slackWorkspace === "secondary"
+        ? "secondary"
+        : "primary";
+    const destinationKey = channelId;
+    const storedCursor = await readFactoryPollCursor(
+      db,
+      orgId,
+      factoryId,
+      "slack",
+      destinationKey,
+    );
+    const priorLastSlackTs =
+      storedCursor?.lastSlackTs ?? config?.lastSlackTs ?? "0";
+    const historyCursor =
+      storedCursor?.slackHistoryCursor ?? config?.slackHistoryCursor;
+    const inboxLimit = jobConfig?.inboxLimit ?? 25;
 
     const result = await pollSlackChannel({
-      workspace:
-        config?.slackWorkspace === "secondary" ? "secondary" : "primary",
+      workspace,
       channelId,
-      priorLastSlackTs: config?.lastSlackTs ?? "0",
-      historyCursor: config?.slackHistoryCursor,
+      priorLastSlackTs,
+      historyCursor,
       ownerEmail: userEmail,
       orgId,
     });
     const now = new Date().toISOString();
-    const configRowId = triageConfigUpdateRowId(config, orgId, factoryId);
+    const configRowId = config
+      ? triageConfigUpdateRowId(config, orgId, factoryId)
+      : null;
+    const accepted: IngestionEnvelope[] = [];
+    let nextLastSlackTs =
+      result.envelopes.length === 0
+        ? (result.nextLastSlackTs ?? priorLastSlackTs)
+        : priorLastSlackTs;
+    for (const envelope of result.envelopes) {
+      const authorId =
+        typeof envelope.metadata?.authorId === "string"
+          ? envelope.metadata.authorId
+          : typeof envelope.metadata?.author === "string"
+            ? envelope.metadata.author
+            : null;
+      if (
+        jobConfig &&
+        !authorMatchesFilter(
+          authorId,
+          jobConfig.authorMode,
+          jobConfig.authorIds,
+        )
+      ) {
+        if (typeof envelope.metadata?.messageTs === "string") {
+          nextLastSlackTs = envelope.metadata.messageTs;
+        }
+        continue;
+      }
+      accepted.push(envelope);
+    }
+    const truncated = accepted.length < result.envelopes.length;
+    let nextHistoryCursor = truncated
+      ? (historyCursor ?? null)
+      : result.nextHistoryCursor;
 
+    const ingested: IngestionEnvelope[] = [];
+    let added = 0;
     await db.transaction(async (tx) => {
-      for (const envelope of result.envelopes) {
+      for (const envelope of accepted) {
         const id = itemDedupeKey(envelope, orgId, factoryId);
         const existing = (
           await tx
@@ -82,6 +141,15 @@ export default defineAction({
             .where(and(eq(triageItems.id, id), eq(triageItems.orgId, orgId)))
             .limit(1)
         )[0];
+        if (!existing && added >= inboxLimit) {
+          nextHistoryCursor = historyCursor ?? null;
+          break;
+        }
+        if (!existing) added += 1;
+        ingested.push(envelope);
+        if (typeof envelope.metadata?.messageTs === "string") {
+          nextLastSlackTs = envelope.metadata.messageTs;
+        }
         const sourceChanged = hasTriageSourceChanged(existing, {
           title: envelope.title,
           summary: envelope.summary ?? null,
@@ -149,12 +217,21 @@ export default defineAction({
           });
       }
 
-      if (config) {
+      await writeFactoryPollCursor(tx as unknown as ReturnType<typeof getDb>, {
+        orgId,
+        factoryId,
+        source: "slack",
+        destinationKey,
+        ownerEmail: userEmail,
+        lastSlackTs: nextLastSlackTs,
+        slackHistoryCursor: nextHistoryCursor,
+      });
+      if (config && configRowId) {
         await tx
           .update(triageConfig)
           .set({
-            lastSlackTs: result.nextLastSlackTs,
-            slackHistoryCursor: result.nextHistoryCursor,
+            lastSlackTs: nextLastSlackTs,
+            slackHistoryCursor: nextHistoryCursor,
             updatedAt: now,
           })
           .where(
@@ -176,7 +253,8 @@ export default defineAction({
       );
     });
 
-    if (result.envelopes.length === 0) {
+    const truncatedByLimit = ingested.length < accepted.length;
+    if (ingested.length === 0) {
       await recordFactoryAudit(
         context,
         { userEmail, orgId },
@@ -187,13 +265,16 @@ export default defineAction({
           summary: "No new Slack feedback was observed.",
           details: {
             channelId,
-            coverage: result.hasMore ? "partial" : "complete",
+            coverage:
+              result.hasMore || truncated || truncatedByLimit
+                ? "partial"
+                : "complete",
           },
         },
         factoryId,
       );
     } else {
-      for (const envelope of result.envelopes) {
+      for (const envelope of ingested) {
         await recordFactoryAudit(
           context,
           { userEmail, orgId },
@@ -220,11 +301,14 @@ export default defineAction({
       source: "slack",
       factoryId,
       channelId,
-      observed: result.envelopes.length,
-      hasMore: result.hasMore,
-      nextLastSlackTs: result.nextLastSlackTs,
-      nextHistoryCursor: result.nextHistoryCursor,
-      coverage: result.hasMore ? "partial" : "complete",
+      observed: ingested.length,
+      hasMore: result.hasMore || truncated || truncatedByLimit,
+      nextLastSlackTs,
+      nextHistoryCursor,
+      coverage:
+        result.hasMore || truncated || truncatedByLimit
+          ? "partial"
+          : "complete",
     };
   },
 });