@agent-native/core 0.145.4 → 0.145.6

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

@@ -0,0 +1,279 @@
+import { defineAction } from "@agent-native/core/action";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { resolveConnectorSecret } from "../server/connectors/credentials.js";
+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 { createAiServicesGitReadClient } from "../server/triage/ai-services-git.js";
+import { createGitHubClient } from "../server/triage/github-client.js";
+import {
+  metadataString,
+  parseTriageMetadata,
+  serializeTriageMetadata,
+} from "../server/triage/metadata.js";
+import {
+  babysitFingerprint,
+  DEFAULT_BABYSIT_BOT_AUTHORS,
+  reconcileBabysitState,
+  shouldBabysitBuilderBotPullRequest,
+} from "../server/triage/pr-babysit.js";
+import { detectOwnerOwnedArea } from "../server/triage/pr-policy.js";
+
+const QUIET_PERIOD_MS = 20 * 60_000;
+const MIN_COMMENT_INTERVAL_MS = 90_000;
+const BUILDER_BOT_REQUEST =
+  "@builderio-bot look at latest PR feedback and fix anything you agree with. Be skeptical. Reply to every comment (directly on the comment thread of each comment) if you fixed it or not and why. then check back every 2 minutes on a loop and see if any new feedback posted, until at least 20 minutes go by without any new feedback posted we want to address, including making sure CI passes too and no merge conflicts (make sure code is mergeable)";
+
+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(`${name} is required for PR babysitting.`);
+  return value;
+}
+
+function parseTimestamp(value: string | undefined): number | null {
+  if (!value) return null;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function repositoryRef(value: string): { owner: string; repo: string } {
+  const match = /^([^/\s]+)\/([^/\s]+)$/.exec(value.trim());
+  if (!match)
+    throw new Error("Repository must use the owner/repository format.");
+  return { owner: match[1], repo: match[2] };
+}
+
+async function updateBabysitMetadata(
+  itemId: string,
+  orgId: string,
+  patch: Record<string, unknown>,
+): Promise<void> {
+  const db = getDb();
+  const item = (
+    await db
+      .select({ metadataJson: triageItems.metadataJson })
+      .from(triageItems)
+      .where(and(eq(triageItems.id, itemId), eq(triageItems.orgId, orgId)))
+      .limit(1)
+  )[0];
+  if (!item) throw new Error("Factory item disappeared during PR babysitting.");
+  const metadata = parseTriageMetadata(item.metadataJson);
+  Object.assign(metadata, patch);
+  await db
+    .update(triageItems)
+    .set({
+      metadataJson: serializeTriageMetadata(metadata),
+      updatedAt: new Date().toISOString(),
+    })
+    .where(and(eq(triageItems.id, itemId), eq(triageItems.orgId, orgId)));
+}
+
+export default defineAction({
+  description:
+    "Watch one builder-io-bot pull request, post the bounded feedback-fix request when CI, mergeability, or review feedback needs work, and stop after 20 quiet minutes. The action never merges or approves.",
+  schema: z.object({
+    itemId: z.string().min(1),
+  }),
+  http: false,
+  run: async ({ itemId }, context) => {
+    const { userEmail, orgId } = await requireWorkspaceMember(
+      workspaceMemberIdentityFromContext(context),
+    );
+    await requireFactoryAutomation(context, { userEmail, orgId }, "prBabysit");
+
+    const db = getDb();
+    const item = (
+      await db
+        .select()
+        .from(triageItems)
+        .where(and(eq(triageItems.id, itemId), eq(triageItems.orgId, orgId)))
+        .limit(1)
+    )[0];
+    if (!item) throw new Error("Factory item not found for PR babysitting.");
+    if (
+      item.source !== "github" ||
+      !item.repository ||
+      !item.pullRequestNumber
+    ) {
+      return {
+        ok: true,
+        action: "skipped",
+        reason: "Item is not a pull request.",
+      };
+    }
+
+    const configuredRepository = (
+      await db
+        .select({ repository: triageConfig.repository })
+        .from(triageConfig)
+        .where(and(eq(triageConfig.id, orgId), eq(triageConfig.orgId, orgId)))
+        .limit(1)
+    )[0]?.repository;
+    if (
+      !configuredRepository ||
+      configuredRepository.trim() !== item.repository.trim()
+    ) {
+      throw new Error(
+        "PR babysitting is restricted to the configured Factory repository.",
+      );
+    }
+
+    const repository = repositoryRef(item.repository);
+    const github = createGitHubClient({ ownerEmail: userEmail, orgId });
+    const pullRequest = await github.getPullRequestSummary(
+      repository,
+      item.pullRequestNumber,
+    );
+    if (pullRequest.state !== "open" || pullRequest.draft) {
+      await updateBabysitMetadata(itemId, orgId, {
+        prBabysitState: "closed-or-draft",
+        prBabysitLastCheckedAt: new Date().toISOString(),
+      });
+      return { ok: true, action: "skipped", reason: "PR is closed or draft." };
+    }
+
+    const ownerOwnedArea = detectOwnerOwnedArea([
+      item.repository,
+      pullRequest.title,
+      pullRequest.body,
+    ]);
+    if (ownerOwnedArea) {
+      await updateBabysitMetadata(itemId, orgId, {
+        prBabysitState: "owner-managed",
+        prBabysitOwnerArea: ownerOwnedArea,
+        prBabysitLastCheckedAt: new Date().toISOString(),
+      });
+      return {
+        ok: true,
+        action: "skipped",
+        reason: `${ownerOwnedArea} is owner-managed.`,
+      };
+    }
+
+    const privateKey = await resolveConnectorSecret(
+      "BUILDER_PRIVATE_KEY",
+      userEmail,
+      { orgId },
+    );
+    if (!privateKey) {
+      throw new Error(
+        "BUILDER_PRIVATE_KEY is required to read PR feedback for babysitting.",
+      );
+    }
+    const snapshot = await createAiServicesGitReadClient({
+      baseUrl: requiredAiServicesEnv("BUILDER_AI_SERVICES_URL"),
+      authorization: `Bearer ${privateKey.startsWith("bpk-") ? privateKey : `bpk-${privateKey}`}`,
+    }).fetchPullRequest({
+      projectId: requiredAiServicesEnv("BUILDER_PROJECT_ID"),
+      repo: item.repository,
+      pullRequestNumber: item.pullRequestNumber,
+    });
+    if (snapshot.headSha !== pullRequest.headSha) {
+      throw new Error(
+        `PR evidence is stale: GitHub reports ${pullRequest.headSha}, ai-services reports ${snapshot.headSha}.`,
+      );
+    }
+
+    const proposal = reconcileBabysitState({
+      comments: snapshot.comments,
+      checks: snapshot.checks,
+      commentsTruncated: snapshot.commentsTruncated,
+      botAuthors: [...DEFAULT_BABYSIT_BOT_AUTHORS],
+    });
+    const unresolvedReviewState = snapshot.reviews.some(
+      (review) =>
+        review.state === "changes_requested" || review.state === "pending",
+    );
+    const signal = {
+      ...proposal,
+      isClean: proposal.isClean && !unresolvedReviewState,
+    };
+    const needsBabysit = shouldBabysitBuilderBotPullRequest({
+      author: pullRequest.userLogin,
+      mergeable: pullRequest.mergeable,
+      mergeableState: pullRequest.mergeableState,
+      snapshot: signal,
+    });
+    const now = new Date();
+    const nowIso = now.toISOString();
+    const metadata = parseTriageMetadata(item.metadataJson);
+    const fingerprint = babysitFingerprint({
+      headSha: snapshot.headSha,
+      mergeable: pullRequest.mergeable,
+      mergeableState: pullRequest.mergeableState,
+      snapshot: signal,
+      reviewStates: snapshot.reviews.map((review) => review.state),
+    });
+    const previousFingerprint = metadataString(
+      metadata,
+      "prBabysitFingerprint",
+    );
+    const previousState = metadataString(metadata, "prBabysitState");
+    if (!needsBabysit) {
+      await updateBabysitMetadata(itemId, orgId, {
+        prBabysitState: "clean",
+        prBabysitLastCheckedAt: nowIso,
+        prBabysitFingerprint: fingerprint,
+      });
+      return { ok: true, action: "clean" };
+    }
+
+    const quietSince =
+      previousFingerprint === fingerprint && previousState !== "clean"
+        ? (parseTimestamp(metadataString(metadata, "prBabysitQuietSinceAt")) ??
+          now.getTime())
+        : now.getTime();
+    const lastCommentAt = parseTimestamp(
+      metadataString(metadata, "prBabysitLastCommentAt"),
+    );
+    const quietForMs = now.getTime() - quietSince;
+    const shouldPost =
+      previousFingerprint !== fingerprint &&
+      (lastCommentAt === null ||
+        now.getTime() - lastCommentAt >= MIN_COMMENT_INTERVAL_MS);
+    if (!shouldPost || quietForMs >= QUIET_PERIOD_MS) {
+      await updateBabysitMetadata(itemId, orgId, {
+        prBabysitState: quietForMs >= QUIET_PERIOD_MS ? "quiet" : "waiting",
+        prBabysitFingerprint: fingerprint,
+        prBabysitQuietSinceAt: new Date(quietSince).toISOString(),
+        prBabysitLastCheckedAt: nowIso,
+      });
+      return {
+        ok: true,
+        action: quietForMs >= QUIET_PERIOD_MS ? "quiet" : "waiting",
+        quietForMinutes: Math.floor(Math.max(0, quietForMs) / 60_000),
+      };
+    }
+
+    const comment = await github.createIssueComment(
+      repository,
+      item.pullRequestNumber,
+      BUILDER_BOT_REQUEST,
+    );
+    await updateBabysitMetadata(itemId, orgId, {
+      prBabysitState: "active",
+      prBabysitFingerprint: fingerprint,
+      prBabysitQuietSinceAt: new Date(quietSince).toISOString(),
+      prBabysitLastCheckedAt: nowIso,
+      prBabysitLastCommentAt: nowIso,
+      prBabysitLastCommentUrl: comment.htmlUrl,
+    });
+    return {
+      ok: true,
+      action: "commented",
+      commentUrl: comment.htmlUrl,
+      quietForMinutes: Math.floor(Math.max(0, quietForMs) / 60_000),
+    };
+  },
+});

package/corpus/templates/factory/actions/get-factory-automation-health.ts

@@ -19,10 +19,27 @@ export default defineAction({
     const { orgId } = await requireWorkspaceMember(
       workspaceMemberIdentityFromContext(context),
     );
-    const health = await getAutomationSchedulerHealth({
-      appId: "factory",
-      orgId,
-    });
+    const [organizationHealth, globalHealth] = await Promise.all([
+      getAutomationSchedulerHealth({
+        appId: "factory",
+        orgId,
+      }),
+      getAutomationSchedulerHealth({ appId: "factory", orgId: null }),
+    ]);
+    const health =
+      [organizationHealth, globalHealth]
+        .filter(
+          (candidate): candidate is NonNullable<typeof candidate> =>
+            candidate !== null && candidate.lastCheckedAt !== null,
+        )
+        .sort(
+          (left, right) =>
+            (right.lastCheckedAt ?? 0) - (left.lastCheckedAt ?? 0),
+        )[0] ??
+      organizationHealth ??
+      globalHealth;
+    const healthScope =
+      health?.orgId === orgId ? ("organization" as const) : ("global" as const);
     if (!health?.lastCheckedAt) {
       return {
         status: "no-data" as const,
@@ -30,6 +47,7 @@ export default defineAction({
         lastDispatchedAt: health?.lastDispatchedAt ?? null,
         lastError: health?.lastError ?? null,
         runtime: health?.runtime ?? null,
+        scope: healthScope,
         staleAfterMs: STALE_AFTER_MS,
       };
     }
@@ -44,6 +62,7 @@ export default defineAction({
       lastDispatchedAt: health.lastDispatchedAt,
       lastError: health.lastError,
       runtime: health.runtime,
+      scope: healthScope,
       staleAfterMs: STALE_AFTER_MS,
     };
   },

package/corpus/templates/factory/app/components/factory/FactoryCanvas.tsx

@@ -92,7 +92,7 @@ type DragState = {
   startPosition: { x: number; y: number };
 };
 
-const DRAG_THRESHOLD = 3;
+const DRAG_THRESHOLD = 6;
 
 export function FactoryCanvas({
   graph,

package/corpus/templates/factory/app/routes/factory.tsx

@@ -258,7 +258,10 @@ export default function FactoryRoute() {
 
   function updateGraph(next: FactoryCanvasGraph) {
     setDraftGraph(next);
-    setDirty(true);
+    setDirty(
+      !graphData?.graph ||
+        JSON.stringify(next) !== JSON.stringify(graphData.graph),
+    );
   }
 
   function addNode() {
@@ -645,14 +648,29 @@ function AutomationsView({
 
   useEffect(() => {
     if (!selected) {
-      setDraft(null);
+      setDraft((current) => (current === null ? current : null));
       return;
     }
     if (selected.id !== selectedId) {
       selectAutomation(selected.id);
       return;
     }
-    setDraft(draftForAutomation(selected));
+    const nextDraft = draftForAutomation(selected);
+    setDraft((current) => {
+      if (
+        current &&
+        current.id === nextDraft.id &&
+        current.name === nextDraft.name &&
+        current.prompt === nextDraft.prompt &&
+        current.body === nextDraft.body &&
+        current.model === nextDraft.model &&
+        current.schedule === nextDraft.schedule &&
+        current.enabled === nextDraft.enabled
+      ) {
+        return current;
+      }
+      return nextDraft;
+    });
   }, [selected, selectedId]);
 
   async function saveAutomation() {

package/corpus/templates/factory/changelog/2026-08-07-factory-can-keep-builder-bot-pull-requests-moving-by-request.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-08-07
+---
+
+Factory can keep Builder bot pull requests moving by requesting fixes for review feedback, CI failures, and merge conflicts.

package/corpus/templates/factory/server/lib/require-factory-automation.ts

@@ -10,6 +10,7 @@ const FACTORY_AUTOMATION_NAMES = {
     "factory-github-issues",
   ]),
   governance: new Set(["factory-pr-governance"]),
+  prBabysit: new Set(["factory-pr-babysit"]),
   sourcePolling: new Set([
     "factory-slack-feedback",
     "factory-sentry-errors",

package/corpus/templates/factory/server/plugins/agent-chat.ts

@@ -24,6 +24,7 @@ const INITIAL_TOOL_NAMES = [
   "start-builder-for-item",
   "govern-agent-native-pull-request",
   "babysit-pull-request",
+  "babysit-agent-native-pull-request",
   "approve-factory-item",
   "list-triage-rules",
   "get-triage-config",
@@ -70,7 +71,9 @@ BuilderIO author, a clear bug, passing CI, and handled review feedback. Auto-mer
 also requires a verified Factory Builder run. When a user says to do a review-gated
 item now, use the explicit approval action, which records the approver and applies
 the rule's configured executor policy. Keep Slack replies concise and link to the
-Factory item when a review is needed.`,
+Factory item when a review is needed. The scheduled builder-io-bot PR babysitter
+posts its exact feedback-fix request through GitHub, persists a 20-minute quiet
+window, and never approves or merges.`,
 } satisfies AgentChatPluginOptions;
 
 export default createAgentChatPlugin(options);

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

@@ -5,6 +5,7 @@ import {
   organizationResourceOwner,
   resourceGetByPath,
   resourcePut,
+  resourcePutIfCurrent,
   WORKSPACE_OWNER,
 } from "@agent-native/core/resources";
 import {
@@ -264,6 +265,30 @@ 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.
+`,
+  },
+  {
+    name: "factory-pr-babysit",
+    schedule: "*/2 * * * *",
+    body: `
+# Factory builder-io-bot PR babysitting
+
+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 open github pull-request items.
+
+For each item, call babysit-agent-native-pull-request. That action fetches fresh
+GitHub and ai-services evidence and is the only place allowed to decide whether
+to post the bounded @builderio-bot feedback-fix request. It only acts on open
+non-draft PRs authored by builder-io-bot (including GitHub's bot login variants),
+and skips owner-managed Clips, Design, and Content work. It persists the latest
+feedback fingerprint and quiet window, so repeated scheduler ticks do not spam
+comments. A changed commit, new unresolved feedback, failing or pending CI, or
+merge conflict starts a new bounded request; twenty minutes without new work to
+address ends that babysitting window. The action never approves or merges.
+
+Preserve action errors and never claim that Builder fixed a PR unless fresh
+evidence confirms the resulting state.
 `,
   },
 ];
@@ -274,6 +299,19 @@ function workspaceOwnerEmail(): string | undefined {
   return email;
 }
 
+function defaultRepository(): string | null {
+  const repository = process.env.FACTORY_DEFAULT_REPOSITORY?.trim(); // guard:allow-env-credential - repository configuration, not a credential
+  if (!repository || /[\r\n]/.test(repository)) return null;
+  return repository;
+}
+
+function defaultGithubPollingEnabled(): 0 | 1 {
+  return process.env.FACTORY_ENABLE_GITHUB_POLLING?.trim().toLowerCase() === // guard:allow-env-credential - deployment feature flag, not a credential
+    "true"
+    ? 1
+    : 0;
+}
+
 function setFrontmatterField(
   content: string,
   key: string,
@@ -327,16 +365,47 @@ async function ensureOrganizationAutomations(
   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",
-    );
-  }
+  await Promise.all(
+    AUTOMATION_SEEDS.map(async (seed) => {
+      const path = `jobs/${seed.name}.md`;
+      const existing = await resourceGetByPath(owner, path);
+      if (!existing) {
+        await resourcePut(
+          owner,
+          path,
+          automationContent(ownerEmail, orgId, seed),
+          "text/markdown",
+        );
+        return;
+      }
+
+      // Earlier Factory versions created these rows without the metadata the
+      // list and action guards use. Patch only identity metadata and keep the
+      // user's prompt, model, schedule, and enabled state intact.
+      let repaired = existing.content;
+      repaired = setFrontmatterField(repaired, "triggerType", "schedule");
+      repaired = setFrontmatterField(repaired, "domain", "factory");
+      repaired = setFrontmatterField(repaired, "orgId", orgId);
+      repaired = setFrontmatterField(repaired, "createdBy", ownerEmail);
+      repaired = setFrontmatterField(repaired, "runAs", "creator");
+      if (repaired === existing.content) return;
+
+      const updated = await resourcePutIfCurrent({
+        owner,
+        path,
+        content: repaired,
+        mimeType: "text/markdown",
+        expectedId: existing.id,
+        expectedUpdatedAt: existing.updatedAt,
+        expectedContent: existing.content,
+      });
+      if (!updated) {
+        console.warn(
+          `[factory-scheduler-job] skipped metadata repair for ${path}: the resource changed concurrently`,
+        );
+      }
+    }),
+  );
 }
 
 async function ensureDefaultTriageConfig(
@@ -359,11 +428,11 @@ async function ensureDefaultTriageConfig(
     slackChannelId: DEFAULT_SLACK_CHANNEL_ID,
     slackChannelName: DEFAULT_SLACK_CHANNEL_NAME,
     pollingEnabled: 1,
-    githubPollingEnabled: 0,
+    githubPollingEnabled: defaultGithubPollingEnabled(),
     sentryPollingEnabled: 0,
     lastSlackTs: null,
     slackHistoryCursor: null,
-    repository: null,
+    repository: defaultRepository(),
     sentryOrgSlug: null,
     sentryProjectSlug: null,
     sentryEnvironment: null,

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

@@ -73,6 +73,11 @@ export interface GitHubMergeResult {
   message: string;
 }
 
+export interface GitHubComment {
+  id: number;
+  htmlUrl: string;
+}
+
 interface JsonResponse {
   ok: boolean;
   status: number;
@@ -361,6 +366,32 @@ export function createGitHubClient(options: GitHubClientOptions) {
       };
     },
 
+    async createIssueComment(
+      repository: GitHubRepositoryRef,
+      issueNumber: number,
+      body: string,
+    ): Promise<GitHubComment> {
+      if (!Number.isInteger(issueNumber) || issueNumber < 1) {
+        throw new Error("GitHub issue number must be a positive integer");
+      }
+      const trimmedBody = body.trim();
+      if (!trimmedBody) throw new Error("GitHub comment body is required");
+      const item = record(
+        await request<unknown>(
+          `${repositoryPath(repository)}/issues/${issueNumber}/comments`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ body: trimmedBody.slice(0, 65_536) }),
+          },
+        ),
+      );
+      return {
+        id: requiredNumber(item.id, "comment id"),
+        htmlUrl: requiredString(item.html_url, "comment URL"),
+      };
+    },
+
     async mergePullRequest(
       repository: GitHubRepositoryRef,
       pullRequestNumber: number,

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

@@ -1,5 +1,24 @@
 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]",
+  "github-actions",
+  "github-actions[bot]",
+  "dependabot[bot]",
+] as const;
+
 export interface ReviewCommentObservation {
   id: string;
   author: string;
@@ -30,6 +49,61 @@ export interface BabysitProposal {
   isClean: boolean;
 }
 
+export interface BuilderBotBabysitSignal {
+  author: string;
+  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;
+}): boolean {
+  return (
+    input.mergeable === false ||
+    input.mergeableState === "dirty" ||
+    input.mergeableState === "conflicting"
+  );
+}
+
+export function shouldBabysitBuilderBotPullRequest(
+  input: BuilderBotBabysitSignal,
+): boolean {
+  return (
+    isBuilderBotLogin(input.author) &&
+    (hasMergeConflict(input) || !input.snapshot.isClean)
+  );
+}
+
+export function babysitFingerprint(input: {
+  headSha: string;
+  mergeable: boolean | null;
+  mergeableState: string | null;
+  snapshot: BabysitProposal;
+  reviewStates?: readonly string[];
+}): string {
+  return JSON.stringify({
+    headSha: input.headSha,
+    mergeable: input.mergeable,
+    mergeableState: input.mergeableState,
+    unansweredComments: input.snapshot.unansweredComments.map((comment) => ({
+      id: comment.id,
+      body: comment.body,
+      isResolved: comment.isResolved ?? null,
+    })),
+    failingChecks: input.snapshot.failingChecks.map((check) => check.name),
+    pendingChecks: input.snapshot.pendingChecks.map((check) => check.name),
+    missingChangesetPackages: input.snapshot.missingChangesetPackages,
+    commentsTruncated: input.snapshot.commentsTruncated,
+    reviewStates: input.reviewStates ?? [],
+  });
+}
+
 const MISSING_CHANGESET_LINE = /^MISSING_CHANGESET_PACKAGES:\s*(.*)$/m;
 
 function parseMissingChangesetPackages(log: string | undefined): string[] {
@@ -71,7 +145,7 @@ export function reconcileBabysitState(input: BabysitInput): BabysitProposal {
       !botAuthors.has(comment.author),
   );
   const failingChecks = input.checks.filter(
-    (check) => check.state === "failed",
+    (check) => check.state === "failed" || check.state === "cancelled",
   );
   const pendingChecks = input.checks.filter(
     (check) => check.state === "queued" || check.state === "in_progress",