@agent-native/core 0.168.7 → 0.168.9

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 8496
+- template files: 8502

package/corpus/templates/analytics/actions/mutate-dashboard.ts

@@ -49,6 +49,13 @@ const mutationTargetSchema = {
     .describe("Where in rowNumber to place the panel. Defaults to end."),
 };
 
+const insertPanelSchema = z
+  .record(z.string(), z.unknown())
+  .refine(
+    (panel) => typeof panel.id === "string" && panel.id.trim().length > 0,
+    { message: "panel.id must be a non-empty string" },
+  );
+
 const mutationOperationSchema = z.discriminatedUnion("op", [
   z.object({
     op: z.literal("movePanels"),
@@ -72,7 +79,7 @@ const mutationOperationSchema = z.discriminatedUnion("op", [
   }),
   z.object({
     op: z.literal("insertPanel"),
-    panel: z.record(z.string(), z.unknown()),
+    panel: insertPanelSchema,
     ...mutationTargetSchema,
   }),
   z.object({

package/corpus/templates/calendar/actions/delete-event.ts

@@ -5,6 +5,7 @@ import {
   normalizeGuestNotificationMessage,
   sendEventGuestNotificationNote,
 } from "../server/lib/event-guest-notifications.js";
+import { isGoogleNotFoundError } from "../server/lib/google-api.js";
 import * as googleCalendar from "../server/lib/google-calendar.js";
 import {
   cliBoolean,
@@ -71,25 +72,39 @@ export default defineAction({
         ? "none"
         : (args.sendUpdates ?? (shouldNotifyGuests ? "all" : "none")),
     };
-    const eventForNotification = shouldNotifyGuests
-      ? await googleCalendar.getEvent(googleEventId, {
-          ownerEmail,
-          accountEmail,
-        })
-      : undefined;
+    let eventForNotification;
+    try {
+      eventForNotification = shouldNotifyGuests
+        ? await googleCalendar.getEvent(googleEventId, {
+            ownerEmail,
+            accountEmail,
+          })
+        : undefined;
 
-    if (args.removeOnly) {
-      await googleCalendar.removeEventFromCalendar(
-        googleEventId,
-        { ownerEmail, accountEmail },
-        options,
-      );
-    } else {
-      await googleCalendar.deleteEvent(
-        googleEventId,
-        { ownerEmail, accountEmail },
-        options,
-      );
+      if (args.removeOnly) {
+        await googleCalendar.removeEventFromCalendar(
+          googleEventId,
+          { ownerEmail, accountEmail },
+          options,
+        );
+      } else {
+        await googleCalendar.deleteEvent(
+          googleEventId,
+          { ownerEmail, accountEmail },
+          options,
+        );
+      }
+    } catch (error) {
+      if (!isGoogleNotFoundError(error)) throw error;
+
+      return {
+        success: true,
+        alreadyAbsent: true,
+        id: `google-${googleEventId}`,
+        accountEmail,
+        scope: args.scope,
+        removedOnly: args.removeOnly ?? false,
+      };
     }
 
     const guestNotification =
@@ -105,6 +120,7 @@ export default defineAction({
 
     return {
       success: true,
+      alreadyAbsent: false,
       id: `google-${googleEventId}`,
       accountEmail,
       scope: args.scope,

package/corpus/templates/calendar/actions/delete-events.ts

@@ -10,6 +10,7 @@ import {
   type WeekdayName,
 } from "../server/lib/event-weekday.js";
 import { zonedDateTimeToUtcIso } from "../server/lib/find-time.js";
+import { isGoogleNotFoundError } from "../server/lib/google-api.js";
 import * as googleCalendar from "../server/lib/google-calendar.js";
 import type { CalendarEvent } from "../shared/api.js";
 import {
@@ -36,7 +37,7 @@ const MAX_MATCHED_EVENTS = 200;
  *  firing every delete at once and turning a clean batch into retries. */
 const DELETE_CONCURRENCY = 4;
 
-type Outcome = "deleted" | "matched" | "skipped" | "failed";
+type Outcome = "deleted" | "already_absent" | "matched" | "skipped" | "failed";
 
 interface EventResult {
   id: string;
@@ -449,6 +450,7 @@ export default defineAction({
         ...summaryBase,
         dryRun: true,
         deleted: 0,
+        alreadyAbsent: 0,
         failed: 0,
         skipped: results.length,
         events: [...targets.map((target) => target.display), ...results],
@@ -483,6 +485,13 @@ export default defineAction({
           }
           return { ...target.display, outcome: "deleted" };
         } catch (error) {
+          if (isGoogleNotFoundError(error)) {
+            return {
+              ...target.display,
+              outcome: "already_absent",
+              reason: "Already absent from Google Calendar",
+            };
+          }
           return {
             ...target.display,
             outcome: "failed",
@@ -498,6 +507,9 @@ export default defineAction({
       dryRun: false,
       deleted: deleteResults.filter((entry) => entry.outcome === "deleted")
         .length,
+      alreadyAbsent: deleteResults.filter(
+        (entry) => entry.outcome === "already_absent",
+      ).length,
       failed: deleteResults.filter((entry) => entry.outcome === "failed")
         .length,
       skipped: results.length,

package/corpus/templates/calendar/app/components/calendar/EventDetailPanel.tsx

@@ -35,6 +35,7 @@ import {
 } from "@/components/ui/tooltip";
 import { useUpdateEvent } from "@/hooks/use-events";
 import { useViewPreferences } from "@/hooks/use-view-preferences";
+import { getDisplayDateInTimezone } from "@/lib/calendar-timezone";
 import { getEditableEventTitle } from "@/lib/event-form-utils";
 import { isOutOfOfficeEvent } from "@/lib/out-of-office";
 import { cn } from "@/lib/utils";
@@ -447,15 +448,33 @@ export function EventDetailPanel({
                     ) : (
                       <>
                         <span className="text-foreground">
-                          {format(parseISO(event.start), "h:mm a")}
+                          {format(
+                            getDisplayDateInTimezone(
+                              event.start,
+                              event.startTimeZone ?? event.endTimeZone,
+                            ),
+                            "h:mm a",
+                          )}
                           {" → "}
-                          {format(parseISO(event.end), "h:mm a")}
+                          {format(
+                            getDisplayDateInTimezone(
+                              event.end,
+                              event.endTimeZone ?? event.startTimeZone,
+                            ),
+                            "h:mm a",
+                          )}
                         </span>
                         <span className="ml-2 text-muted-foreground/70">
                           {formatDuration(event.start, event.end)}
                         </span>
                         <div className="mt-0.5 text-muted-foreground">
-                          {format(parseISO(event.start), "EEE MMM d")}
+                          {format(
+                            getDisplayDateInTimezone(
+                              event.start,
+                              event.startTimeZone ?? event.endTimeZone,
+                            ),
+                            "EEE MMM d",
+                          )}
                         </div>
                       </>
                     )}

package/corpus/templates/calendar/app/lib/calendar-timezone.ts

@@ -118,6 +118,25 @@ export function getDateTimePartsInTimezone(
   return dateTimeParts(value, normalizeTimezone(timezone));
 }
 
+/**
+ * Build a local Date carrying an event's wall-clock fields so date-fns can
+ * format those fields without converting them through the browser timezone.
+ * The result is for display only; it must not be used for date arithmetic.
+ */
+export function getDisplayDateInTimezone(
+  value: Date | string,
+  timezone?: string | null,
+): Date {
+  const parsed = value instanceof Date ? value : new Date(value);
+  if (!timezone) return parsed;
+
+  const parts = getDateTimePartsInTimezone(value, timezone);
+  if (!parts) return parsed;
+
+  const [year, month, day] = parts.date.split("-").map(Number);
+  return new Date(year, month - 1, day, parts.hour, parts.minute, parts.second);
+}
+
 export function getDateKeyInTimezone(
   value: Date | string,
   timezone: string,

package/corpus/templates/calendar/server/lib/google-api.ts

@@ -113,6 +113,23 @@ export function createOAuth2Client(
 // Authenticated fetch helper
 // ---------------------------------------------------------------------------
 
+export class GoogleApiError extends Error {
+  readonly status: number;
+
+  constructor(status: number, message: string) {
+    super(`Google API error (${status}): ${message}`);
+    this.name = "GoogleApiError";
+    this.status = status;
+  }
+}
+
+export function isGoogleNotFoundError(error: unknown): boolean {
+  return (
+    (error instanceof GoogleApiError && error.status === 404) ||
+    (error instanceof Error && /^Google API error \(404\):/.test(error.message))
+  );
+}
+
 export async function googleFetch(
   url: string,
   accessToken: string,
@@ -133,7 +150,7 @@ export async function googleFetch(
       (data as any)?.error?.message ||
       (data as any)?.error_description ||
       res.statusText;
-    throw new Error(`Google API error (${res.status}): ${msg}`);
+    throw new GoogleApiError(res.status, msg);
   }
 
   return data;

package/corpus/templates/clips/actions/finalize-meeting.ts

@@ -27,6 +27,17 @@ import { loadAgentsMdContext } from "./lib/agents-md-context.js";
 // handles crashed processes without stealing an active text-model run.
 const PENDING_STALE_MS = 2 * 60 * 1000;
 
+export function skippedFinalizeResult(meetingId: string) {
+  return {
+    meetingId,
+    summaryMd: "",
+    bullets: [],
+    actionItems: [],
+    provider: null,
+    skipped: "no-transcript" as const,
+  };
+}
+
 function trimContextValue(value: string, maxChars: number): string {
   const trimmed = value.replace(/\0/g, "").trim();
   if (trimmed.length <= maxChars) return trimmed;
@@ -80,6 +91,11 @@ export default defineAction({
           updatedAt: nowIso,
         })
         .where(eq(schema.meetings.id, args.meetingId));
+      // The desktop stop path can finish before its final transcript flush
+      // lands. That is a completed recording without notes, not an action
+      // failure worth returning as HTTP 500; the explicit regenerate flow
+      // still receives the actionable error below.
+      if (!args.force) return skippedFinalizeResult(args.meetingId);
       throw new Error(
         `Cannot finalize meeting ${args.meetingId} — no transcript text available yet.`,
       );

package/corpus/templates/clips/actions/list-meetings.ts

@@ -372,6 +372,7 @@ export default defineAction({
               await recordCalendarFetchError(
                 account,
                 new Error("Token refresh failed"),
+                { needsReauth: true },
               ),
             );
             continue;

package/corpus/templates/clips/actions/sync-calendars.ts

@@ -23,6 +23,8 @@ import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import {
+  recordCalendarFetchError,
+  recordCalendarFetchSuccess,
   resolveCalendarAccessToken,
   shouldMarkNeedsReauth,
 } from "../server/lib/calendar-event-meetings.js";
@@ -98,24 +100,11 @@ export default defineAction({
         // sync error via shouldMarkNeedsReauth without flipping status.
         const accessToken = await resolveCalendarAccessToken(account);
         if (!accessToken) {
-          // Fix 10: isolate this account's needs-reauth write in its own
-          // try/catch so a downstream throw on a different account doesn't
-          // leave the flag unpersisted.
-          try {
-            await db
-              .update(schema.calendarAccounts)
-              .set({
-                status: "needs-reauth",
-                lastSyncError: "Token refresh failed — reconnect required.",
-                updatedAt: new Date().toISOString(),
-              })
-              .where(eq(schema.calendarAccounts.id, account.id));
-          } catch (writeErr: any) {
-            console.warn(
-              `[sync-calendars] failed to flag account ${account.id} as needs-reauth:`,
-              writeErr?.message ?? writeErr,
-            );
-          }
+          await recordCalendarFetchError(
+            account,
+            new Error("Token refresh failed"),
+            { needsReauth: true },
+          );
           errors.push({
             accountId: account.id,
             error: "needs-reauth",
@@ -206,18 +195,10 @@ export default defineAction({
           perAccountEvents += 1;
         }
 
-        // Fix 10: isolate the success-path status write so other accounts'
-        // needs-reauth flags can't be wiped by a later account-level throw.
+        // Keep the success write isolated and guarded so an in-flight sweep
+        // cannot overwrite a concurrent needs-reauth decision.
         try {
-          await db
-            .update(schema.calendarAccounts)
-            .set({
-              lastSyncedAt: new Date().toISOString(),
-              lastSyncError: null,
-              status: "connected",
-              updatedAt: new Date().toISOString(),
-            })
-            .where(eq(schema.calendarAccounts.id, account.id));
+          await recordCalendarFetchSuccess(account);
         } catch (writeErr: any) {
           console.warn(
             `[sync-calendars] failed to update account ${account.id} after success:`,

package/corpus/templates/clips/desktop/src/hooks/useMeetingTranscription.ts

@@ -4,6 +4,7 @@ import { open as openExternal } from "@tauri-apps/plugin-shell";
 import { useCallback, useEffect, useMemo, useRef } from "react";
 
 import { callAppBundleIdsForJoinUrl } from "../lib/meeting-call-app";
+import { stopMeetingBeforeTranscriptFlush } from "../lib/meeting-stop";
 import {
   appendFinalTranscript,
   onFinalTranscript,
@@ -195,18 +196,33 @@ export function useMeetingTranscription({
           }
         });
         await invoke("silence_detector_stop").catch(() => {});
-        if (reason !== "app-quit") {
-          await session.historyInFlight?.catch(() => {});
-        }
-        // Final flush waits for any in-flight flush first (flushTranscript's
-        // single-flight coalescing) then sends the definitive snapshot.
-        await flushTranscript().catch((err) => {
-          console.warn("[clips-popover] meeting transcript save failed:", err);
-        });
-        await callClipsAction("stop-meeting-recording", {
-          meetingId: session.meetingId,
-        }).catch((err) => {
-          console.warn("[clips-popover] stop meeting action failed:", err);
+        await stopMeetingBeforeTranscriptFlush({
+          // Stamp actualEnd as soon as capture is torn down. Transcript
+          // history and network flushes may be slow or unavailable, but they
+          // must not leave the meeting looking live in the meantime.
+          stopRecording: async () => {
+            await callClipsAction("stop-meeting-recording", {
+              meetingId: session.meetingId,
+            }).catch((err) => {
+              console.warn("[clips-popover] stop meeting action failed:", err);
+            });
+          },
+          waitForHistory: async () => {
+            if (reason !== "app-quit") {
+              await session.historyInFlight?.catch(() => {});
+            }
+          },
+          // Final flush waits for any in-flight flush first
+          // (flushTranscript's single-flight coalescing) and sends the
+          // definitive snapshot.
+          flushTranscript: async () => {
+            await flushTranscript().catch((err) => {
+              console.warn(
+                "[clips-popover] meeting transcript save failed:",
+                err,
+              );
+            });
+          },
         });
         if (session.lines.length) {
           const finalizePromise = callClipsAction("finalize-meeting", {

package/corpus/templates/clips/desktop/src/lib/meeting-stop.ts

@@ -0,0 +1,16 @@
+interface StopMeetingBeforeTranscriptFlushOptions {
+  stopRecording: () => Promise<void>;
+  waitForHistory: () => Promise<void>;
+  flushTranscript: () => Promise<void>;
+}
+
+/** Persist the terminal meeting state before waiting on transcript work. */
+export async function stopMeetingBeforeTranscriptFlush({
+  stopRecording,
+  waitForHistory,
+  flushTranscript,
+}: StopMeetingBeforeTranscriptFlushOptions): Promise<void> {
+  await stopRecording();
+  await waitForHistory();
+  await flushTranscript();
+}

package/corpus/templates/clips/server/lib/calendar-event-meetings.ts

@@ -23,6 +23,8 @@ import {
 
 export const CALENDAR_MEETING_ID_PREFIX = "gcal";
 
+const CALENDAR_REQUEST_SAFETY_MARGIN_MS = 60 * 1000;
+
 export interface CalendarAccountForEvents {
   id: string;
   provider: string;
@@ -74,8 +76,7 @@ export function shouldMarkNeedsReauth(message: string): boolean {
     lower.includes("google calendar event failed (401)") ||
     lower.includes("invalid_grant") ||
     lower.includes("invalid_token") ||
-    lower.includes("insufficient_scope") ||
-    lower.includes("token refresh failed")
+    lower.includes("insufficient_scope")
   );
 }
 
@@ -122,10 +123,16 @@ export async function resolveCalendarAccessToken(
     });
   } catch (err) {
     // Only a permanent failure (dead refresh token / bad OAuth client) means
-    // "needs-reauth" — collapse those to `null` as before. A transient
-    // failure (network error, 429, 5xx, timeout) is rethrown so callers can
-    // record it as a soft sync error without flipping account status.
+    // "needs-reauth" — collapse those to `null` as before. During the refresh
+    // buffer, a transient failure can safely reuse the still-valid token.
     if (isPermanentRefreshFailure(err)) return null;
+    if (
+      bundle?.accessToken &&
+      bundle.expiresAt &&
+      bundle.expiresAt > Date.now() + CALENDAR_REQUEST_SAFETY_MARGIN_MS
+    ) {
+      return bundle.accessToken;
+    }
     throw err;
   }
   if (!refreshed.access_token) return null;
@@ -158,13 +165,13 @@ export async function recordCalendarFetchSuccess(
     .set({
       lastSyncedAt: now,
       lastSyncError: null,
-      status: "connected",
       updatedAt: now,
     })
     .where(
       and(
         eq(schema.calendarAccounts.id, account.id),
         eq(schema.calendarAccounts.ownerEmail, account.ownerEmail),
+        eq(schema.calendarAccounts.status, "connected"),
       ),
     );
 }
@@ -172,10 +179,11 @@ export async function recordCalendarFetchSuccess(
 export async function recordCalendarFetchError(
   account: CalendarAccountForEvents,
   error: unknown,
+  options: { needsReauth?: boolean } = {},
 ): Promise<CalendarFetchError> {
   const message =
     error instanceof Error ? error.message : String(error || "Calendar failed");
-  const needsReauth = shouldMarkNeedsReauth(message);
+  const needsReauth = options.needsReauth ?? shouldMarkNeedsReauth(message);
   if (!account.ownerEmail) {
     return { accountId: account.id, error: message, needsReauth };
   }
@@ -183,7 +191,7 @@ export async function recordCalendarFetchError(
   await db
     .update(schema.calendarAccounts)
     .set({
-      status: needsReauth ? "needs-reauth" : "connected",
+      ...(needsReauth ? { status: "needs-reauth" as const } : {}),
       lastSyncError: needsReauth
         ? "Google Calendar needs to be reconnected."
         : message,
@@ -320,7 +328,9 @@ export async function fetchLiveCalendarEventFromId(virtualId: string) {
     return null;
   }
   if (!accessToken) {
-    await recordCalendarFetchError(account, new Error("Token refresh failed"));
+    await recordCalendarFetchError(account, new Error("Token refresh failed"), {
+      needsReauth: true,
+    });
     return null;
   }
 

package/corpus/templates/factory/.agents/skills/factory-graphs/SKILL.md

@@ -16,6 +16,11 @@ explains them, but never hides a topology change in prose. Until an execution
 binding is explicitly added, the blueprint must not be described as the runtime
 router.
 
+Runtime work — settings, inbox, rules, automations, and activity — is scoped by
+`factoryId`. Reusable agents stay workspace-wide; graph nodes may reference any
+workspace agent as blueprint only. Pass `factoryId` on triage, config, automation,
+and audit actions for the factory the user is viewing.
+
 ## Workflow
 
 1. Read `view-screen` to identify the selected Factory, tab, node, or edge.

package/corpus/templates/factory/AGENTS.md

@@ -21,22 +21,11 @@ decisions, feedback, agent runs, and provider audit records.
   reconciliation is not success; preserve typed failure or
   `reconciliation_required` state.
 - Deduplicate by Factory item and rule/run identity, not provider comment ID.
-- Slack clear bugs go through `start-builder-for-item` (👀 and a Slack user
-  mention for `/address-feedback`); never post Slack messages or `@handles`.
-  Group repeats into one Builder thread. GitHub/Sentry use the Builder run
-  API. Follow `review-latest-feedback` for full-thread evidence, existing
-  reaction and owner checks, answered-clarification priority, one-question
-  clarification limits, durable rechecks, and the required `@agent-native`
-  disposition after every actionable 👀. Clips, Design, and Content stay
-  owner-managed outside autonomous dispatch and PR governance.
-- PR governance follows `review-prs`: verify BuilderIO membership and complete
-  diff/review/check evidence; skip drafts/current approvals and never approve
-  external authors. Keep ultra-scary security, auth, tenant-isolation,
-  secrets, data-loss, execution, payment, and deployment risks manual.
-  Verified members may pass ordinary uncertain checks or review feedback, but
-  record exact states and never call them clean. Apply the Alice/Content,
-  Nick/Slides, Enzo/Factory, Sid/Design, and docs-only exceptions only after
-  membership and the ultra-scary gate. Never auto-merge.
+- Slack clear bugs go through `start-builder-for-item`; never post Slack
+  messages or `@handles`. GitHub/Sentry use the Builder run API. Read
+  `review-latest-feedback` for thread evidence and disposition rules.
+- PR governance follows `review-prs`: verify membership and evidence; skip
+  drafts and external authors; keep ultra-scary risks manual; never auto-merge.
 - Graph edits create immutable blueprint versions. AI proposes with `source=ai`;
   a person reviews and publishes through the same action surface.
 - Provider credentials belong to Dispatch/shared workspace integrations, never
@@ -46,16 +35,16 @@ decisions, feedback, agent runs, and provider audit records.
 
 ## Application state
 
-- `navigation.view` is `factory`, `agents`, or `factory-settings`.
-  Observation settings are workspace-scoped at `/factory-settings`.
-  `factoryId`, `factoryTab`, `factoryAuditRunId`, `factoryNodeId`, and
-  `factoryEdgeId` hold Factory context. Read `view-screen` first.
+- `navigation.view` is `factory` or `agents`. Runtime data is scoped by
+  `factoryId`; reusable agents stay workspace-wide. Read `view-screen` and
+  `factory-graphs` for tab and selection keys.
 
 ## Action contract
 
 | Action | Purpose |
 | --- | --- |
-| `list-triage-items` / `get-triage-item` | Inspect bounded queue evidence; scheduled reviewers pass `needsReview: true`, `source`, and `limit`. |
+| `list-triage-items` / `get-triage-item` | Inspect queue evidence; pass `factoryId`. |
+| `get-triage-config` / `save-triage-config` | Read or save observation settings for one factory. |
 | `poll-slack-channel` | Observe Slack history; never writes to Slack. |
 | `get-slack-feedback-context` | Read the bounded full Slack thread before classification. |
 | `poll-github-sources` / `poll-sentry-errors` | Observe bounded source queues. |
@@ -67,11 +56,12 @@ decisions, feedback, agent runs, and provider audit records.
 | `start-builder-for-item` | Govern clear-bug dispatch through Slack or Builder API, or record a skip reason. |
 | `govern-agent-native-pull-request` | Apply PR evidence and ownership gates. |
 | `list-factory-automations` / `save-factory-automation` / `run-factory-automation` | Inspect or edit org-owned automations. |
-| `list-factory-audit` | Inspect automation runs, evidence, decisions, and provider actions. |
+| `list-factory-audit` | Inspect runs, evidence, and provider actions for one factory. |
 | `get-factory-automation-health` | Inspect scheduler heartbeat and last error. |
 | `suggest-factory-rules` | Mine feedback into proposals. |
 | `reconcile-triage-run` | Persist callback/provider reconciliation. |
 | `list-factories` / `get-factory-graph` | Inspect definitions, versions, and metrics. |
+| `create-factory` | Create a factory from `/new-factory` with optional sources. |
 | `save-factory-graph` | Create/version a graph with inspected `expectedGraphVersion`; never starts provider work. |
 | graph history actions | Factory graph version history. |
 | `list-factory-comments` / `add-factory-comment` | Read or attach comments to a canvas, node, or edge. |

package/corpus/templates/factory/README.md

@@ -44,19 +44,22 @@ shared `app_secrets` rows must use the same
 encryption fallback). Never copy raw tokens between apps or add a second
 env-only read in a provider client.
 
-Factory's default observer still keeps organization-scoped source metadata -
-such as a Slack channel, repository, or Sentry project - for its normalized
-queue adapters. That metadata is not a credential or a per-factory integration
-setup. GitHub issue polling defaults to hourly; Slack and pull-request checks
-use shorter bounded cadences because those sources can need faster feedback.
-Every poll preserves errors for reconciliation.
+Factory's observer keeps **per-factory** source metadata — Slack channel,
+repository, Sentry project, and related polling settings — for its normalized
+queue adapters. Each factory has its own inbox, rules, automations, and activity.
+Reusable agents and workspace credentials stay shared. Each factory's observation
+settings live on its Settings tab in the factory detail view. That metadata is
+not a credential or a per-factory
+integration setup. GitHub issue polling defaults to hourly; Slack and
+pull-request checks use shorter bounded cadences because those sources can need
+faster feedback. Every poll preserves errors for reconciliation.
 
 Factory agents can discover connected provider APIs with
 `provider-api-catalog`, inspect their docs with `provider-api-docs`, and call
 them through `provider-api-request`. Scheduled Factory runs also receive the
 workspace's connected MCP tools, subject to the same workspace and request
-scope gates. The three normalized pollers are compatibility adapters for the
-default triage queue, not the agent's capability limit.
+scope gates. The three normalized pollers are compatibility adapters scoped by
+`factoryId`, not the agent's capability limit.
 
 The generic Slack bot is wired to Factory. Mention `@agent-native` in a feedback
 thread to inspect the linked item, explain its decision, tune a rule, or say