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

package/corpus/templates/factory/server/triage/github-client.ts

@@ -1,4 +1,9 @@
 import { resolveConnectorSecret } from "../connectors/credentials.js";
+import type { ReviewCommentObservation } from "./pr-babysit.js";
+import type {
+  PullRequestCheckObservation,
+  PullRequestReviewObservation,
+} from "./pr-monitor.js";
 
 const DEFAULT_BASE_URL = "https://api.github.com";
 const MAX_PAGE_SIZE = 100;
@@ -43,6 +48,7 @@ export interface GitHubIssue {
   state: string;
   htmlUrl: string;
   userLogin: string;
+  userId: string;
   labels: readonly string[];
   createdAt: string;
   updatedAt: string;
@@ -91,6 +97,18 @@ export class GitHubRequestError extends Error {
   }
 }
 
+export interface GitHubIssueCreateResult {
+  number: number;
+  htmlUrl: string;
+}
+
+export interface GitHubPullRequestEvidence {
+  comments: readonly ReviewCommentObservation[];
+  commentsTruncated: boolean;
+  reviews: readonly PullRequestReviewObservation[];
+  checks: readonly PullRequestCheckObservation[];
+}
+
 interface JsonResponse {
   ok: boolean;
   status: number;
@@ -168,6 +186,129 @@ function parsePullRequest(value: unknown): GitHubPullRequest {
   };
 }
 
+function requireArray(value: unknown, field: string): unknown[] {
+  if (!Array.isArray(value)) {
+    throw new Error(`GitHub ${field} response was not an array`);
+  }
+  return value;
+}
+
+function loginFromUser(value: unknown, field: string): string {
+  if (value === null) {
+    throw new Error(`GitHub ${field} has no user`);
+  }
+  return requiredString(record(value).login, `${field} user login`);
+}
+
+function requirePositivePullRequestNumber(pullRequestNumber: number): void {
+  if (!Number.isInteger(pullRequestNumber) || pullRequestNumber < 1) {
+    throw new Error("GitHub pull request number must be a positive integer");
+  }
+}
+
+function normalizeReviewState(
+  state: string,
+): PullRequestReviewObservation["state"] {
+  switch (state) {
+    case "APPROVED":
+      return "approved";
+    case "CHANGES_REQUESTED":
+      return "changes_requested";
+    case "PENDING":
+      return "pending";
+    case "DISMISSED":
+      return "dismissed";
+    default:
+      return "commented";
+  }
+}
+
+function normalizeCheckState(
+  status: string,
+  conclusion?: string,
+): PullRequestCheckObservation["state"] {
+  if (status !== "completed") {
+    return status === "in_progress" ? "in_progress" : "queued";
+  }
+  switch (conclusion) {
+    case "success":
+      return "passed";
+    case "cancelled":
+    case "timed_out":
+      return "cancelled";
+    default:
+      return "failed";
+  }
+}
+
+function parseReviewComment(value: unknown): ReviewCommentObservation {
+  const item = record(value);
+  const inReplyToId = item.in_reply_to_id;
+  const line = item.line ?? item.original_line;
+  return {
+    id: String(requiredNumber(item.id, "review comment id")),
+    author: loginFromUser(item.user, "review comment"),
+    inReplyToId:
+      inReplyToId == null
+        ? null
+        : String(requiredNumber(inReplyToId, "in_reply_to_id")),
+    body:
+      typeof item.body === "string"
+        ? item.body
+        : requiredString(item.body, "review comment body"),
+    path:
+      typeof item.path === "string" && item.path.length > 0
+        ? item.path
+        : undefined,
+    line: typeof line === "number" && Number.isFinite(line) ? line : undefined,
+    createdAt: requiredString(item.created_at, "review comment created time"),
+  };
+}
+
+function parseReview(
+  value: unknown,
+  fallbackObservedAt: string,
+): PullRequestReviewObservation {
+  const item = record(value);
+  const submittedAt =
+    (typeof item.submitted_at === "string" && item.submitted_at) ||
+    fallbackObservedAt;
+  return {
+    author: loginFromUser(item.user, "review"),
+    state: normalizeReviewState(
+      requiredString(item.state, "review state").toUpperCase(),
+    ),
+    ...(typeof item.commit_id === "string" && item.commit_id.trim()
+      ? { commitSha: item.commit_id }
+      : {}),
+    ...(typeof item.html_url === "string" && item.html_url
+      ? { htmlUrl: item.html_url }
+      : {}),
+    ...(typeof item.body === "string" ? { body: item.body } : {}),
+    observedAt: submittedAt,
+  };
+}
+
+function parseCheckRun(value: unknown): PullRequestCheckObservation {
+  const item = record(value);
+  const status = requiredString(item.status, "check-run status");
+  const conclusion =
+    item.conclusion === null || item.conclusion === undefined
+      ? undefined
+      : requiredString(item.conclusion, "check-run conclusion");
+  const observedAt =
+    (typeof item.completed_at === "string" && item.completed_at) ||
+    (typeof item.started_at === "string" && item.started_at);
+  if (!observedAt) {
+    throw new Error("GitHub check-run response is missing started_at");
+  }
+  return {
+    name: requiredString(item.name, "check-run name"),
+    state: normalizeCheckState(status, conclusion),
+    observedAt,
+  };
+}
+
 function parseIssue(value: unknown): GitHubIssue | null {
   const item = record(value);
   if (item.pull_request !== undefined) return null;
@@ -182,6 +323,7 @@ function parseIssue(value: unknown): GitHubIssue | null {
     state: requiredString(item.state, "issue state"),
     htmlUrl: requiredString(item.html_url, "issue URL"),
     userLogin: requiredString(user.login, "issue author"),
+    userId: String(requiredNumber(user.id, "issue author id")),
     labels: labels.map((label) =>
       requiredString(record(label).name, "issue label"),
     ),
@@ -276,15 +418,96 @@ export function createGitHubClient(options: GitHubClientOptions) {
       });
     },
 
-    async getPullRequestSummary(
+    async listPullRequestReviewComments(
       repository: GitHubRepositoryRef,
       pullRequestNumber: number,
     ) {
-      if (!Number.isInteger(pullRequestNumber) || pullRequestNumber < 1) {
+      requirePositivePullRequestNumber(pullRequestNumber);
+      const comments = requireArray(
+        await request<unknown>(
+          `${repositoryPath(repository)}/pulls/${pullRequestNumber}/comments?per_page=${pageSize()}`,
+        ),
+        "review comment",
+      ).map(parseReviewComment);
+      return {
+        comments,
+        commentsTruncated: comments.length >= MAX_PAGE_SIZE,
+      };
+    },
+
+    async getPullRequestEvidence(
+      repository: GitHubRepositoryRef,
+      pullRequestNumber: number,
+      headSha: string,
+    ): Promise<GitHubPullRequestEvidence> {
+      requirePositivePullRequestNumber(pullRequestNumber);
+      const sha = headSha.trim();
+      if (!sha) throw new Error("GitHub pull request head SHA is required");
+      const root = repositoryPath(repository);
+      const page = pageSize();
+      const [reviewPayload, commentPayload, checkPayload] = await Promise.all([
+        request<unknown>(
+          `${root}/pulls/${pullRequestNumber}/reviews?per_page=${page}`,
+        ),
+        request<unknown>(
+          `${root}/pulls/${pullRequestNumber}/comments?per_page=${page}`,
+        ),
+        request<unknown>(
+          `${root}/commits/${encodeURIComponent(sha)}/check-runs?per_page=${page}`,
+        ),
+      ]);
+      const observedAt = new Date().toISOString();
+      const comments = requireArray(commentPayload, "review comment").map(
+        parseReviewComment,
+      );
+      const reviews = requireArray(reviewPayload, "review").map((review) =>
+        parseReview(review, observedAt),
+      );
+      const checkBody = record(checkPayload);
+      const checkRuns = requireArray(checkBody.check_runs, "check-run");
+      const totalCount = requiredNumber(
+        checkBody.total_count,
+        "check-run total_count",
+      );
+      if (totalCount > checkRuns.length) {
         throw new Error(
-          "GitHub pull request number must be a positive integer",
+          "GitHub check-run page was truncated; cannot treat CI as complete.",
         );
       }
+      return {
+        comments,
+        commentsTruncated: comments.length >= MAX_PAGE_SIZE,
+        reviews,
+        checks: checkRuns.map(parseCheckRun),
+      };
+    },
+
+    async listPullRequestChangedFiles(
+      repository: GitHubRepositoryRef,
+      pullRequestNumber: number,
+    ): Promise<readonly string[]> {
+      requirePositivePullRequestNumber(pullRequestNumber);
+      const files = requireArray(
+        await request<unknown>(
+          `${repositoryPath(repository)}/pulls/${pullRequestNumber}/files?per_page=${pageSize()}`,
+        ),
+        "pull request file",
+      );
+      if (files.length >= MAX_PAGE_SIZE) {
+        throw new Error(
+          "GitHub pull-request file page was truncated; cannot treat the diff as complete.",
+        );
+      }
+      return files.map((file) =>
+        requiredString(record(file).filename, "pull request filename"),
+      );
+    },
+
+    async getPullRequestSummary(
+      repository: GitHubRepositoryRef,
+      pullRequestNumber: number,
+    ) {
+      requirePositivePullRequestNumber(pullRequestNumber);
       const item = record(
         await request<unknown>(
           `${repositoryPath(repository)}/pulls/${pullRequestNumber}`,
@@ -444,6 +667,54 @@ export function createGitHubClient(options: GitHubClientOptions) {
       };
     },
 
+    async createIssue(
+      repository: GitHubRepositoryRef,
+      input: { title: string; body: string },
+    ): Promise<GitHubIssueCreateResult> {
+      const title = input.title.trim();
+      const body = input.body.trim();
+      if (!title) throw new Error("GitHub issue title is required");
+      if (!body) throw new Error("GitHub issue body is required");
+      const item = record(
+        await request<unknown>(`${repositoryPath(repository)}/issues`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            title: title.slice(0, 256),
+            body: body.slice(0, 65_536),
+          }),
+        }),
+      );
+      return {
+        number: requiredNumber(item.number, "issue number"),
+        htmlUrl: requiredString(item.html_url, "issue URL"),
+      };
+    },
+
+    async addIssueReaction(
+      repository: GitHubRepositoryRef,
+      issueNumber: number,
+      content: string,
+    ): Promise<{ added: boolean; already_present: boolean }> {
+      if (!Number.isInteger(issueNumber) || issueNumber < 1) {
+        throw new Error("GitHub issue number must be a positive integer");
+      }
+      try {
+        await request<unknown>(
+          `${repositoryPath(repository)}/issues/${issueNumber}/reactions`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ content }),
+          },
+        );
+        return { added: true, already_present: false };
+      } catch (error) {
+        if (!String(error).includes("HTTP 422")) throw error;
+        return { added: false, already_present: true };
+      }
+    },
+
     async createIssueComment(
       repository: GitHubRepositoryRef,
       issueNumber: number,

package/corpus/templates/factory/server/triage/github-ingestion.ts

@@ -1,3 +1,4 @@
+import { safeHttpUrl } from "../lib/safe-http-url.js";
 import type { IngestionEnvelope } from "./contracts.js";
 import type { PullRequestObservation } from "./pr-monitor.js";
 
@@ -14,11 +15,12 @@ export function pullRequestSnapshotToEnvelope(
   snapshot: AiServicesPullRequestSnapshot,
 ): IngestionEnvelope {
   const externalId = `${snapshot.repo}#${snapshot.pullRequestNumber}@${snapshot.headSha}`;
+  const sourceUrl = safeHttpUrl(snapshot.sourceUrl);
   return {
     source: "github",
     externalId,
     receivedAt: snapshot.observedAt,
-    ...(snapshot.sourceUrl ? { sourceUrl: snapshot.sourceUrl } : {}),
+    ...(sourceUrl ? { sourceUrl } : {}),
     title: snapshot.title,
     summary: snapshot.summary,
     repository: snapshot.repo,

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

@@ -42,3 +42,15 @@ export function metadataBoolean(
   const value = metadata[key];
   return typeof value === "boolean" ? value : undefined;
 }
+
+export function triageItemAuthor(metadataJson: string): string {
+  return metadataString(parseTriageMetadata(metadataJson), "author") ?? "";
+}
+
+export function triageItemAuthorId(metadataJson: string): string {
+  return (
+    metadataString(parseTriageMetadata(metadataJson), "authorId") ??
+    metadataString(parseTriageMetadata(metadataJson), "author") ??
+    ""
+  );
+}

package/corpus/templates/factory/server/triage/pr-babysit.ts

@@ -1,19 +1,13 @@
 import type { PullRequestCheckObservation } from "./pr-monitor.js";
 
-export const BUILDER_BOT_LOGINS = new Set([
-  "builder-io-bot",
-  "builder-io-bot[bot]",
-  "builderio-bot",
-  "builderio-bot[bot]",
-  "builderio[bot]",
-]);
-
 export const DEFAULT_BABYSIT_BOT_AUTHORS = [
   "builder-io-bot",
   "builder-io-bot[bot]",
   "builderio-bot",
   "builderio-bot[bot]",
   "builderio[bot]",
+  "builder-io-integration",
+  "builder-io-integration[bot]",
   "github-actions",
   "github-actions[bot]",
   "dependabot[bot]",
@@ -49,17 +43,12 @@ export interface BabysitProposal {
   isClean: boolean;
 }
 
-export interface BuilderBotBabysitSignal {
-  author: string;
+export interface BabysitWorkSignal {
   mergeable: boolean | null;
   mergeableState: string | null;
   snapshot: BabysitProposal;
 }
 
-export function isBuilderBotLogin(login: string): boolean {
-  return BUILDER_BOT_LOGINS.has(login.trim().toLowerCase());
-}
-
 export function hasMergeConflict(input: {
   mergeable: boolean | null;
   mergeableState: string | null;
@@ -71,13 +60,8 @@ export function hasMergeConflict(input: {
   );
 }
 
-export function shouldBabysitBuilderBotPullRequest(
-  input: BuilderBotBabysitSignal,
-): boolean {
-  return (
-    isBuilderBotLogin(input.author) &&
-    (hasMergeConflict(input) || !input.snapshot.isClean)
-  );
+export function shouldRequestBabysitWork(input: BabysitWorkSignal): boolean {
+  return hasMergeConflict(input) || !input.snapshot.isClean;
 }
 
 export function babysitFingerprint(input: {
@@ -172,3 +156,20 @@ export function reconcileBabysitState(input: BabysitInput): BabysitProposal {
       pendingChecks.length === 0,
   };
 }
+
+export function formatBabysitAuditSummary(
+  pullRequestNumber: number | null | undefined,
+  clause: string,
+): string {
+  const label =
+    typeof pullRequestNumber === "number" && pullRequestNumber > 0
+      ? `#${pullRequestNumber}`
+      : "Item";
+  return `${label} ${clause}`;
+}
+
+export function babysitOutOfScopeClause(author: string | null): string {
+  return author
+    ? `skipped; author ${author} is out of scope.`
+    : "skipped; out of scope.";
+}

package/corpus/templates/factory/server/triage/review-skill-alignment.ts

@@ -19,16 +19,16 @@ contract is evidence-first and reply-producing:
   task-scoped clarification ledger with a stable scheduler identity for
   recurring rechecks. Do not claim scheduled coverage without stable durable
   state.
-- Check the existing Slack 👀 marker and owner before any write. Preserve an
-  existing marker; if reactions cannot be read, do not guess or add one. Do
-  not react to or dispatch Design UX/interaction work (Sid) or any Content
-  work (Alice); record the owner instead.
-- For an actionable repo-owned Slack item with no existing marker, 👀 is the
-  first external write. Every parent this run marks must later receive a
-  verified @agent-native Fixed, In progress, or Clarification needed reply;
-  an eye, forward, generic acknowledgement, or another person's reply is not
-  a disposition. Group only genuinely repeated symptoms and dispatch one
-  Builder thread for the cluster.
+- Check the existing Slack reaction marker and owner before any write.
+  Preserve an existing marker; if reactions cannot be read, do not guess or
+  add one. Do not react to or dispatch Design UX/interaction work (Sid) or
+  any Content work (Alice); record the owner instead.
+- For an actionable repo-owned Slack item with no existing marker, pass
+  \`reaction: robot_face\` 🤖 on \`dispatch-factory-item\`. Every parent this run
+  marks must later receive a verified @agent-native Fixed, In progress, or
+  Clarification needed reply; a reaction, forward, generic acknowledgement,
+  or another person's reply is not a disposition. Group only genuinely
+  repeated symptoms and dispatch one Builder thread for the cluster.
 - Choose the smallest owning seam: local regression for one symptom, shared
   contract for repeated cross-surface evidence, discovery/action wiring for a
   missing capability, and release/deployment diagnosis for source-versus-live
@@ -37,7 +37,7 @@ contract is evidence-first and reply-producing:
   separate. Do not claim a fix, PR, reply, or deployment without confirmation
   from the relevant action or runtime evidence.
 
-After classifying every processed item, call \`start-builder-for-item\` with
+After classifying every processed item, call \`dispatch-factory-item\` with
 \`clearBug: true\` or \`false\` and a concise evidence-grounded reason so every
 skip or dispatch is recorded.`;
 

package/corpus/templates/factory/server/triage/review-state.ts

@@ -31,3 +31,42 @@ export function statusAfterTriageSourceUpdate(
 ): string {
   return sourceChanged ? reviewStatus : (existingStatus ?? reviewStatus);
 }
+
+const STICKY_BABYSIT_STATES = new Set([
+  "out-of-scope",
+  "closed-or-draft",
+  "owner-managed",
+]);
+
+function sameGitHubLogin(left: string, right: string): boolean {
+  return left.trim().toLowerCase() === right.trim().toLowerCase();
+}
+
+/** Keep a babysit skip out of pr_observed until author or draft/open state can change the decision. */
+export function statusAfterPullRequestPoll(input: {
+  existingStatus?: string;
+  existingAuthor?: string;
+  nextAuthor: string;
+  existingBabysitState?: string;
+  nextDraft: boolean;
+  sourceChanged: boolean;
+}): string {
+  const sticky =
+    input.existingStatus === "needs_manual" &&
+    Boolean(input.existingBabysitState) &&
+    STICKY_BABYSIT_STATES.has(input.existingBabysitState!);
+  if (sticky) {
+    const authorChanged =
+      Boolean(input.existingAuthor?.trim()) &&
+      !sameGitHubLogin(input.existingAuthor ?? "", input.nextAuthor);
+    const reopenedFromClosedOrDraft =
+      input.existingBabysitState === "closed-or-draft" && !input.nextDraft;
+    if (authorChanged || reopenedFromClosedOrDraft) return "pr_observed";
+    return "needs_manual";
+  }
+  return statusAfterTriageSourceUpdate(
+    input.existingStatus,
+    input.sourceChanged,
+    "pr_observed",
+  );
+}

package/corpus/templates/factory/server/triage/slack-client.ts

@@ -1,9 +1,9 @@
 import { resolveConnectorSecret } from "../connectors/credentials.js";
 import {
   getChannelHistory as readChannelHistory,
-  addEyesReaction as writeEyesReaction,
+  addReaction as writeReaction,
   authTest as readAuthTest,
-  getEyesReaction as readEyesReaction,
+  hasReaction as readReaction,
   getThread as readThread,
   getTeamInfo as readTeamInfo,
   getUserInfo as readUserInfo,
@@ -121,13 +121,20 @@ export function createSlackReader(identity: SlackReaderIdentity) {
         tokenResolver,
       );
     },
-    async addEyesReaction(
+    async addReaction(
       workspace: Workspace,
       channelId: string,
       timestamp: string,
+      name: string,
     ): Promise<SlackReactionResult> {
       await verifyAgentNativeIdentity(workspace);
-      return writeEyesReaction(workspace, channelId, timestamp, tokenResolver);
+      return writeReaction(
+        workspace,
+        channelId,
+        timestamp,
+        name,
+        tokenResolver,
+      );
     },
     async postThreadReply(
       workspace: Workspace,
@@ -144,13 +151,14 @@ export function createSlackReader(identity: SlackReaderIdentity) {
         tokenResolver,
       );
     },
-    async getEyesReaction(
+    async hasReaction(
       workspace: Workspace,
       channelId: string,
       timestamp: string,
+      name: string,
     ): Promise<SlackReactionState> {
       await verifyAgentNativeIdentity(workspace);
-      return readEyesReaction(workspace, channelId, timestamp, tokenResolver);
+      return readReaction(workspace, channelId, timestamp, name, tokenResolver);
     },
     async getCompleteThread(
       workspace: Workspace,