@agent-native/core 0.147.0 → 0.148.1

package/corpus/templates/factory/actions/govern-agent-native-pull-request.ts

@@ -16,6 +16,7 @@ import {
   workspaceMemberIdentityFromContext,
 } from "../server/lib/require-workspace-member.js";
 import { createAiServicesGitReadClient } from "../server/triage/ai-services-git.js";
+import { recordFactoryAudit } from "../server/triage/audit.js";
 import { createGitHubClient } from "../server/triage/github-client.js";
 import { stableId } from "../server/triage/ids.js";
 import {
@@ -231,6 +232,34 @@ export default defineAction({
       factoryTriggered,
     });
 
+    await recordFactoryAudit(
+      context,
+      { userEmail, orgId },
+      {
+        action: "govern-agent-native-pull-request",
+        kind: "governance",
+        status: governance.autoApprove ? "success" : "skipped",
+        itemId: itemId ?? null,
+        source: "github",
+        sourceUrl: pullRequest.htmlUrl,
+        summary: governance.reason,
+        details: {
+          repo,
+          pullRequestNumber,
+          clearBug,
+          productUxImplications,
+          internalBuilderMember: internalMember.isMember,
+          factoryTriggered,
+          checksPassed,
+          reviewFeedbackHandled,
+          autoApprove: governance.autoApprove,
+          autoMerge: governance.autoMerge,
+          ownerOwnedArea: governance.ownerOwnedArea ?? null,
+          guardResults: governance.guardResults,
+        },
+      },
+    );
+
     if (itemId) {
       const item = (
         await getDb()
@@ -338,6 +367,19 @@ export default defineAction({
     }
 
     if (!governance.autoMerge) {
+      await recordFactoryAudit(
+        context,
+        { userEmail, orgId },
+        {
+          action: "govern-agent-native-pull-request",
+          kind: "external_action",
+          itemId: itemId ?? null,
+          source: "github",
+          sourceUrl: approvalUrl,
+          summary: "Approved the pull request after governance checks passed.",
+          details: { repo, pullRequestNumber, approvalUrl },
+        },
+      );
       return {
         ok: true,
         action: "approved",
@@ -374,6 +416,19 @@ export default defineAction({
         })
         .where(and(eq(triageItems.id, itemId), eq(triageItems.orgId, orgId)));
     }
+    await recordFactoryAudit(
+      context,
+      { userEmail, orgId },
+      {
+        action: "govern-agent-native-pull-request",
+        kind: "external_action",
+        itemId: itemId ?? null,
+        source: "github",
+        sourceUrl: pullRequest.htmlUrl,
+        summary: "Merged the pull request after governance checks passed.",
+        details: { repo, pullRequestNumber, approvalUrl, mergeSha: merge.sha },
+      },
+    );
     return {
       ok: true,
       action: "merged",

package/corpus/templates/factory/actions/ingest-github-observation.ts

@@ -7,6 +7,7 @@ import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
 } from "../server/lib/require-workspace-member.js";
+import { recordFactoryAudit } from "../server/triage/audit.js";
 import { pullRequestSnapshotToEnvelope } from "../server/triage/github-ingestion.js";
 import { itemDedupeKey } from "../server/triage/ids.js";
 import type {
@@ -90,6 +91,26 @@ export default defineAction({
         },
       });
 
+    await recordFactoryAudit(
+      context,
+      { userEmail, orgId },
+      {
+        action: "ingest-github-observation",
+        kind: "observed",
+        itemId: id,
+        source: envelope.source,
+        sourceUrl: envelope.sourceUrl,
+        summary: envelope.title,
+        details: {
+          repository: envelope.repository,
+          pullRequestNumber: envelope.pullRequestNumber,
+          coverage: envelope.coverage,
+          reviewCount: input.reviews.length,
+          checkCount: input.checks.length,
+        },
+      },
+    );
+
     return {
       ok: true,
       id,

package/corpus/templates/factory/actions/list-factory-audit.ts

@@ -0,0 +1,118 @@
+import { defineAction } from "@agent-native/core/action";
+import {
+  listAutomationDefinitions,
+  listAutomationRuns,
+} from "@agent-native/core/triggers";
+import { and, desc, eq, inArray } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb } from "../server/db/index.js";
+import { factoryAuditEvents } from "../server/db/schema.js";
+import {
+  requireWorkspaceMember,
+  workspaceMemberIdentityFromContext,
+} from "../server/lib/require-workspace-member.js";
+
+export default defineAction({
+  description:
+    "List recent Factory automation runs with the bounded source observations, decisions, and external actions recorded for each run.",
+  agentTool: false,
+  schema: z.object({
+    factoryId: z.string().trim().min(1).optional(),
+    automation: z.string().trim().min(1).optional(),
+    limit: z.coerce.number().int().min(1).max(50).default(20),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async ({ automation, limit }, context) => {
+    const { userEmail, orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    const definitions = await listAutomationDefinitions(
+      { userEmail, orgId, appId: "factory" },
+      "organization",
+    );
+    const factoryDefinitions = definitions.filter(
+      ({ meta, name }) =>
+        meta.domain === "factory" && (!automation || name === automation),
+    );
+    const runGroups = await Promise.all(
+      factoryDefinitions.map(async ({ name, resource }) =>
+        listAutomationRuns({
+          owners: [resource.owner],
+          automation: name,
+          appId: "factory",
+          limit,
+        }),
+      ),
+    );
+    const runs = runGroups.flat().sort((a, b) => b.startedAt - a.startedAt);
+    const boundedRuns = runs.slice(0, limit);
+    const runIds = boundedRuns
+      .map((run) => run.runId)
+      .filter((runId): runId is string => Boolean(runId));
+
+    const db = getDb();
+    const events = runIds.length
+      ? await db
+          .select()
+          .from(factoryAuditEvents)
+          .where(
+            and(
+              eq(factoryAuditEvents.orgId, orgId),
+              inArray(factoryAuditEvents.automationRunId, runIds),
+            ),
+          )
+          .orderBy(desc(factoryAuditEvents.createdAt))
+      : [];
+    const eventsByRun = new Map<string, typeof events>();
+    for (const event of events) {
+      if (!event.automationRunId) continue;
+      const current = eventsByRun.get(event.automationRunId) ?? [];
+      current.push(event);
+      eventsByRun.set(event.automationRunId, current);
+    }
+
+    return {
+      runs: boundedRuns.map((run) => ({
+        id: run.id,
+        automation: run.automation,
+        runId: run.runId,
+        threadId: run.threadId,
+        status: run.status,
+        startedAt: run.startedAt,
+        finishedAt: run.finishedAt,
+        error: run.error,
+        events: (eventsByRun.get(run.runId ?? "") ?? []).map((event) => ({
+          id: event.id,
+          automationRunId: event.automationRunId,
+          automationThreadId: event.automationThreadId,
+          automationName: event.automationName,
+          itemId: event.itemId,
+          source: event.source,
+          sourceUrl: event.sourceUrl,
+          action: event.action,
+          kind: event.kind,
+          status: event.status,
+          summary: event.summary,
+          details: parseDetails(event.detailsJson),
+          createdAt: event.createdAt,
+        })),
+      })),
+      count: boundedRuns.length,
+    };
+  },
+});
+
+function parseDetails(value: string): Record<string, unknown> {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    throw new Error("Factory audit details are unreadable.");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Factory audit details are unreadable.");
+  }
+  return parsed as Record<string, unknown>;
+}

package/corpus/templates/factory/actions/list-factory-automations.ts

@@ -22,7 +22,7 @@ export default defineAction({
       workspaceMemberIdentityFromContext(context),
     );
     const definitions = await listAutomationDefinitions(
-      { userEmail, orgId },
+      { userEmail, orgId, appId: "factory" },
       "organization",
     );
     return Promise.all(
@@ -45,6 +45,7 @@ export default defineAction({
           runs: await listAutomationRuns({
             owners: [resource.owner],
             automation: name,
+            appId: "factory",
             limit: 20,
           }),
         })),

package/corpus/templates/factory/actions/list-triage-items.ts

@@ -8,6 +8,7 @@ import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
 } from "../server/lib/require-workspace-member.js";
+import { recordFactoryAudit } from "../server/triage/audit.js";
 import {
   triageItemStatusSchema,
   triageSourceSchema,
@@ -24,7 +25,7 @@ export default defineAction({
   http: { method: "GET" },
   readOnly: true,
   run: async ({ status, source, limit }, context) => {
-    const { orgId } = await requireWorkspaceMember(
+    const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
     const db = getDb();
@@ -54,7 +55,7 @@ export default defineAction({
       }
     }
 
-    return items.map((item) => {
+    const listedItems = items.map((item) => {
       const latestDecision = latestByItem.get(item.id);
       return {
         id: item.id,
@@ -86,5 +87,26 @@ export default defineAction({
           : null,
       };
     });
+
+    for (const item of listedItems) {
+      await recordFactoryAudit(
+        context,
+        { userEmail, orgId },
+        {
+          action: "list-triage-items",
+          kind: "read",
+          itemId: item.itemId,
+          source: item.source,
+          sourceUrl: item.sourceUrl,
+          summary: item.title,
+          details: {
+            status: item.status,
+            coverage: item.coverage,
+            decision: item.latestDecision?.outcome ?? null,
+          },
+        },
+      );
+    }
+    return listedItems;
   },
 });

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

@@ -9,6 +9,7 @@ import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
 } from "../server/lib/require-workspace-member.js";
+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";
@@ -193,6 +194,65 @@ export default defineAction({
       }
     });
 
+    if (issues.length === 0 && pullRequests.length === 0) {
+      await recordFactoryAudit(
+        context,
+        { userEmail, orgId },
+        {
+          action: "poll-github-sources",
+          kind: "observed",
+          source: "github",
+          summary: "No open GitHub issues or pull requests were observed.",
+          details: { repository: repositoryName },
+        },
+      );
+    } 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,
+            ),
+            source: "github_issue",
+            sourceUrl: issue.htmlUrl,
+            summary: issue.title,
+            details: { repository: repositoryName, number: issue.number },
+          },
+        );
+      }
+      for (const pullRequest of pullRequests) {
+        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,
+            ),
+            source: "github",
+            sourceUrl: pullRequest.htmlUrl,
+            summary: pullRequest.title,
+            details: { repository: repositoryName, number: pullRequest.number },
+          },
+        );
+      }
+    }
+
     return {
       ok: true,
       repository: repositoryName,

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

@@ -9,6 +9,7 @@ import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
 } from "../server/lib/require-workspace-member.js";
+import { recordFactoryAudit } from "../server/triage/audit.js";
 import { itemDedupeKey } from "../server/triage/ids.js";
 import { mergeTriageMetadata } from "../server/triage/metadata.js";
 import { createSentryClient } from "../server/triage/sentry-client.js";
@@ -151,6 +152,44 @@ export default defineAction({
         .where(and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)));
     });
 
+    if (observedIssues.length === 0) {
+      await recordFactoryAudit(
+        context,
+        { userEmail, orgId },
+        {
+          action: "poll-sentry-errors",
+          kind: "observed",
+          source: "sentry",
+          summary: "No unresolved Sentry errors were observed.",
+          details: { sentryOrgSlug: config.sentryOrgSlug },
+        },
+      );
+    } else {
+      for (const issue of observedIssues) {
+        await recordFactoryAudit(
+          context,
+          { userEmail, orgId },
+          {
+            action: "poll-sentry-errors",
+            kind: "observed",
+            itemId: itemDedupeKey(
+              { source: "sentry", externalId: issue.id },
+              orgId,
+            ),
+            source: "sentry",
+            sourceUrl: issue.permalink,
+            summary: issue.title,
+            details: {
+              shortId: issue.shortId,
+              level: issue.level,
+              count: issue.count,
+              projectSlug: issue.projectSlug,
+            },
+          },
+        );
+      }
+    }
+
     return {
       ok: true,
       observed: observedIssues.length,

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

@@ -4,10 +4,12 @@ import { z } from "zod";
 
 import { getDb } from "../server/db/index.js";
 import { triageConfig, triageItems } from "../server/db/schema.js";
+import { requireFactoryAutomation } from "../server/lib/require-factory-automation.js";
 import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
 } from "../server/lib/require-workspace-member.js";
+import { recordFactoryAudit } from "../server/triage/audit.js";
 import { itemDedupeKey } from "../server/triage/ids.js";
 import { pollSlackChannel } from "../server/triage/slack-poller.js";
 
@@ -17,11 +19,16 @@ export default defineAction({
   schema: z.object({
     channelId: z.string().trim().min(1).max(128).optional(),
   }),
-  http: { method: "POST" },
+  http: false,
   run: async ({ channelId: requestedChannelId }, context) => {
     const { userEmail, orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
+    await requireFactoryAutomation(
+      context,
+      { userEmail, orgId },
+      "sourcePolling",
+    );
     const db = getDb();
     const config = (
       await db
@@ -106,6 +113,43 @@ export default defineAction({
       }
     });
 
+    if (result.envelopes.length === 0) {
+      await recordFactoryAudit(
+        context,
+        { userEmail, orgId },
+        {
+          action: "poll-slack-channel",
+          kind: "observed",
+          source: "slack",
+          summary: "No new Slack feedback was observed.",
+          details: {
+            channelId,
+            coverage: result.hasMore ? "partial" : "complete",
+          },
+        },
+      );
+    } else {
+      for (const envelope of result.envelopes) {
+        await recordFactoryAudit(
+          context,
+          { userEmail, orgId },
+          {
+            action: "poll-slack-channel",
+            kind: "observed",
+            itemId: itemDedupeKey(envelope, orgId),
+            source: envelope.source,
+            sourceUrl: envelope.sourceUrl ?? null,
+            summary: envelope.summary ?? envelope.title,
+            details: {
+              channelId,
+              threadTs: envelope.threadTs ?? null,
+              coverage: envelope.coverage,
+            },
+          },
+        );
+      }
+    }
+
     return {
       ok: true,
       source: "slack",

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

@@ -24,7 +24,7 @@ export default defineAction({
       workspaceMemberIdentityFromContext(context),
     );
     const definitions = await listAutomationDefinitions(
-      { userEmail, orgId },
+      { userEmail, orgId, appId: "factory" },
       "organization",
     );
     const definition = definitions.find(

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

@@ -32,7 +32,7 @@ export default defineAction({
       workspaceMemberIdentityFromContext(context),
     );
     const definitions = await listAutomationDefinitions(
-      { userEmail, orgId },
+      { userEmail, orgId, appId: "factory" },
       "organization",
     );
     const definition = definitions.find(
@@ -46,7 +46,7 @@ export default defineAction({
       );
     }
     const updated = await updateAutomation(
-      { userEmail, orgId },
+      { userEmail, orgId, appId: "factory" },
       {
         name: definition.name,
         scope: "organization",

package/corpus/templates/factory/actions/start-builder-for-item.ts

@@ -14,6 +14,7 @@ import {
   requireWorkspaceMember,
   workspaceMemberIdentityFromContext,
 } from "../server/lib/require-workspace-member.js";
+import { recordFactoryAudit } from "../server/triage/audit.js";
 import { startBuilderRun } from "../server/triage/builder-executor.js";
 import { stableId } from "../server/triage/ids.js";
 import {
@@ -182,6 +183,26 @@ export default defineAction({
         : reason,
       guardResults,
     });
+    await recordFactoryAudit(
+      context,
+      { userEmail, orgId },
+      {
+        action: "start-builder-for-item",
+        kind: "decision",
+        itemId,
+        source: item.source,
+        sourceUrl: item.sourceUrl,
+        status: blocked ? "skipped" : "success",
+        summary: blocked ? "Factory kept this item for manual review." : reason,
+        details: {
+          decisionId,
+          clearBug,
+          productUxImplications,
+          ownerOwnedArea: ownerOwnedArea ?? null,
+          guardResults,
+        },
+      },
+    );
     if (blocked) {
       await db
         .update(triageItems)
@@ -332,6 +353,19 @@ export default defineAction({
             updatedAt: new Date().toISOString(),
           })
           .where(and(eq(triageItems.id, itemId), eq(triageItems.orgId, orgId)));
+        await recordFactoryAudit(
+          context,
+          { userEmail, orgId },
+          {
+            action: "start-builder-for-item",
+            kind: "external_action",
+            itemId,
+            source: item.source,
+            sourceUrl: item.sourceUrl,
+            summary: "Tagged Builder in the Slack thread and requested a PR.",
+            details: { provider: "bot-tag", runId },
+          },
+        );
         return {
           ok: true,
           started: true,
@@ -385,6 +419,23 @@ export default defineAction({
           updatedAt: new Date().toISOString(),
         })
         .where(and(eq(triageItems.id, itemId), eq(triageItems.orgId, orgId)));
+      await recordFactoryAudit(
+        context,
+        { userEmail, orgId },
+        {
+          action: "start-builder-for-item",
+          kind: "external_action",
+          itemId,
+          source: item.source,
+          sourceUrl: item.sourceUrl,
+          summary: "Submitted the clear bug to Builder.",
+          details: {
+            provider: "builder-http",
+            runId,
+            providerTaskId: result.providerTaskId ?? null,
+          },
+        },
+      );
       return {
         ok: true,
         started: true,