@agent-native/core-corpus 0.206.0 → 0.206.1-nightly-20261009183700

package/corpus/README.md

@@ -32,4 +32,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core-corpus/corpu
 
 ## Generated Counts
 
-- template files: 11704
+- template files: 11719

package/corpus/templates/analytics/.agents/skills/onboarding-journeys/SKILL.md

@@ -47,6 +47,25 @@ only to the Design input, set `referenceOnly: true`, and omit the cohort metric
 fields. This annotation is for visual references and is not emitted by
 `get-onboarding-journey`.
 
+Saved outputs require source-confirmed completion events. Clips uses
+`recording_ready`; `recording_started`, transcript-only `recording_completed`,
+and `clip_viewed` are not saved outputs. Slides uses explicit
+`generation_completed`; `generation_request_accepted`,
+`generation_outcome_unresolved`, `generation_failed`, `generation_stuck`,
+`generation_cancelled`, and `generation_abandoned` remain distinct attempt
+steps. An unresolved event can carry `persisted_output: true`, but it still does
+not substitute for `generation_completed`. `deck_edited`, `output_viewed`, and
+current deck state also cannot substitute for that event. A missing terminal
+event stays absent. Generation and recording starts remain attempt steps, and
+retry attempts that reuse a deck's output ID remain separate by their exact
+attempt ID. A sessionless Clips completion or Slides lifecycle event is
+attached only when its exact output and attempt pair maps to one distinct
+eligible onboarding session (`recording_started` for Clips;
+`generation_started`, `generation_request_accepted`, or `output_viewed` for
+Slides); missing or ambiguous
+matches stay unattributed. Output and attempt IDs are never included in the
+returned tree.
+
 The journey projection also retains `integration_setup_exposed`,
 `integration_method_clicked`, and `integration_method_outcome` as separate
 `integration:<flow>:...` steps. These record setup exposure, the selected
@@ -145,9 +164,10 @@ chunk. Fix failures or report them; do not paint over a missing frame.
 the PNG. Every visible iframe must have a corresponding recorded child document
 by the requested replay time. If the child document is missing, the frame is
 listed as a failure with code `replay_iframe_content_unavailable` and counts in
-`diagnostics`. If unsupported 3D projection, rounded ancestor clipping, CSS
-clip paths, masks, or visibility-altering filters prevent the audit from
-verifying visibility, the frame is listed with code
+`diagnostics`. If unsupported 3D projection, rounded ancestor clipping,
+unsupported CSS `clip-path` shapes, unrecognized legacy CSS `clip` values,
+masks, or visibility-altering filters prevent the audit from verifying
+visibility, the frame is listed with code
 `replay_iframe_visibility_unverifiable`; do not treat uncertainty as either
 missing content or a successful audit. The check covers every visible iframe
 because replay can omit its original source attribute while rebuilding an

package/corpus/templates/analytics/CHANGELOG.md

@@ -15,6 +15,8 @@ time from the command menu (Cmd+K → "What's new") or from Settings.
 
 - Journey captures now flag visible previews missing from the recording instead of saving blank screenshots
 - Journey recordings flag iframe content when clipping, masks, or filters make its visibility uncertain.
+- Onboarding journeys count saved clips and completed deck generations as outputs while showing Slides attempt outcomes separately
+- Session recordings keep their full history and performance insights across browser session changes and large replays.
 - Large onboarding journeys keep their step counts when follow-up coverage exceeds query limits
 
 ## 2026-10-08

package/corpus/templates/analytics/actions/get-onboarding-journey.ts

@@ -34,7 +34,7 @@ const isoDate = z
 
 export default defineAction({
   description:
-    'Build the onboarding journey tree for a date window: per-session step sequences (signup, onboarding questions, setup method, app entry, first action, first output) folded into a prefix tree. format "tree" returns { window, app, rootN, coverage, nodes } for sessions that entered onboarding, plus standaloneSetup for Home chat integration events in sessions without onboarding; its root and percentages have a separate denominator. Each node has n, pctOfRoot, pctOfParent, dropoffN/dropoffPct (last observed step, not a confirmed exit), deeperN (sessions with a later observed step omitted below this node), and example sessions with recordingId, a recording-start-relative offsetMs, and viewport. Both formats include followUp counts of sessions with and without any later native Analytics event in the same session after each terminal selected step, observed before one frozen observationCutoff. followUp.rightCensoredAtWindowEnd is true: no later event means none was recorded within that bounded window, not abandonment or churn. If the event read may be incomplete, the aggregate query truncates or exceeds the SQL size or parser-token limit, or cohort coverage mismatches, followUp.status is incomplete, incompleteReason names the cause, and its cohort counts and duration are null. format "summary" returns the same tree counts as indented outlines with no examples. Check each tree\'s coverage.truncated first: true means its event sample, requested depth, or node list cut that tree; notes explain why. Use it to plan onboarding storyboards or see each cohort\'s last recorded selected step. For a standalone storyboard, pass standaloneSetup as the top-level tree to journey:capture.',
+    'Build a per-session onboarding journey tree from signup through the first saved output. Clips uses recording_ready; Slides uses explicit generation_completed; Design uses generation_completed or design_output_created. Generation and recording starts are attempt steps, not outputs. Slides request acceptance and failed, stuck, cancelled, abandoned, or unresolved outcomes are separate attempt steps; unresolved remains unresolved even when persisted_output is true, and a missing terminal event stays absent. Edits and views do not establish a saved output. A saved output or Slides attempt event without a session is attached only when its exact output/attempt pair matches exactly one onboarding cohort session; otherwise it stays unattributed. Output and attempt IDs are never returned. format "tree" returns { window, app, rootN, coverage, nodes } for sessions that entered onboarding, plus standaloneSetup for Home chat integration events in sessions without onboarding; its root and percentages have a separate denominator. Each node has n, pctOfRoot, pctOfParent, dropoffN/dropoffPct (last observed step, not a confirmed exit), deeperN (sessions with a later observed step omitted below this node), and example sessions with recordingId, a recording-start-relative offsetMs, and viewport. Both formats include followUp counts of sessions with and without any later native Analytics event in the same session after each terminal selected step, observed before one frozen observationCutoff. followUp.rightCensoredAtWindowEnd is true: no later event means none was recorded within that bounded window, not abandonment or churn. If the event read may be incomplete, the aggregate query truncates or exceeds the SQL size or parser-token limit, or cohort coverage mismatches, followUp.status is incomplete, incompleteReason names the cause, and its cohort counts and duration are null. format "summary" returns the same counts as indented outlines with no examples. Check each tree\'s coverage.truncated first: true means its event sample, requested depth, or node list cut that tree; notes explain why. Use it to plan onboarding storyboards or see each cohort\'s last recorded selected step. For a standalone storyboard, pass standaloneSetup as the top-level tree to journey:capture.',
   schema: z.object({
     dateFrom: isoDate.describe(
       "Inclusive UTC start date, YYYY-MM-DD. Sessions that began earlier appear mid-journey, so start a day before the period you care about.",

package/corpus/templates/analytics/agent-native.json

@@ -7,6 +7,13 @@
     }
   },
   "doctor": {
-    "failOnBuild": false
+    "failOnBuild": false,
+    "dbToolScopingDenylist": {
+      "bigquery_cache": "provider cache, not a user-facing resource",
+      "dashboard_name_locks": "internal dashboard-name serialization rows, never exposed to raw DB tools",
+      "dashboard_views": "view telemetry, scoped by dashboard or action",
+      "first_party_analytics_cache": "internal query cache, accessed through scoped analytics queries",
+      "session_recording_session_associations": "child rows are scoped through authorized session recordings"
+    }
   }
 }

package/corpus/templates/analytics/changelog/2026-10-09-journey-screenshots-account-for-legacy-clipping-when-checkin.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-09
+---
+
+Journey screenshots account for legacy clipping when checking embedded replay content.

package/corpus/templates/analytics/changelog/2026-10-09-onboarding-journeys-count-saved-clips-and-completed-deck-gen.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-09
+---
+
+Onboarding journeys count saved clips and completed deck generations as outputs while showing Slides attempt outcomes separately

package/corpus/templates/analytics/changelog/2026-10-09-session-recordings-keep-their-full-history-and-performance-i.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-09
+---
+
+Session recordings keep their full history and performance insights across browser session changes and large replays.

package/corpus/templates/analytics/scripts/journey-capture-iframe-audit.ts

@@ -413,6 +413,79 @@ export function auditReplayIframeContent({
     },
   ];
 
+  const [legacyClipPolygon]: [
+    (value: string, geometry: BoxGeometry) => Point[] | null,
+  ] = [
+    (value, geometry) => {
+      const match = value.trim().match(/^rect\((.*)\)$/i);
+      if (!match) return null;
+
+      const values = match[1]!
+        .trim()
+        .split(/\s*,\s*|\s+/)
+        .filter(Boolean);
+      if (values.length !== 4) return null;
+      type Offset = { kind: "auto" } | { kind: "value"; value: number };
+      const [parseOffset]: [(token: string) => Offset | null] = [
+        (token) => {
+          if (token.toLowerCase() === "auto") return { kind: "auto" };
+          const number = token.match(/^(-?(?:\d+(?:\.\d*)?|\.\d+))(px)?$/i);
+          if (!number) return null;
+          const amount = Number(number[1]);
+          if (!Number.isFinite(amount) || (!number[2] && amount !== 0)) {
+            return null;
+          }
+          return { kind: "value", value: amount };
+        },
+      ];
+      const offsets = values.map(parseOffset);
+      if (offsets.some((offset) => offset === null)) return null;
+      const [topOffset, rightOffset, bottomOffset, leftOffset] = offsets as [
+        Offset,
+        Offset,
+        Offset,
+        Offset,
+      ];
+      const [resolveOffset]: [
+        (offset: Offset, automatic: number | null) => number | null,
+      ] = [
+        (offset, automatic) =>
+          offset.kind === "auto" ? automatic : offset.value,
+      ];
+      const top = topOffset.kind === "auto" ? 0 : topOffset.value;
+      const left = leftOffset.kind === "auto" ? 0 : leftOffset.value;
+      const right = resolveOffset(
+        rightOffset,
+        geometry.uncertain ? null : geometry.width,
+      );
+      const bottom = resolveOffset(
+        bottomOffset,
+        geometry.uncertain ? null : geometry.height,
+      );
+      if (
+        (right !== null && right <= left) ||
+        (bottom !== null && bottom <= top)
+      ) {
+        return [];
+      }
+      if (
+        geometry.uncertain ||
+        right === null ||
+        bottom === null ||
+        geometry.width <= 0 ||
+        geometry.height <= 0
+      ) {
+        return null;
+      }
+      return [
+        { x: left, y: top },
+        { x: right, y: top },
+        { x: right, y: bottom },
+        { x: left, y: bottom },
+      ];
+    },
+  ];
+
   const [polygonMayOverlapLocalRects]: [
     (
       polygon: Point[],
@@ -771,16 +844,17 @@ export function auditReplayIframeContent({
 
       for (let current: Element | null = frame; current; ) {
         const styles = view.getComputedStyle(current);
+        const boxless = styles.display === "contents";
         if (
           styles.display === "none" ||
           styles.contentVisibility === "hidden" ||
-          (styles.opacity !== "" && Number(styles.opacity) === 0)
+          (!boxless && styles.opacity !== "" && Number(styles.opacity) === 0)
         ) {
           rendered = false;
           break;
         }
         const filter = styles.getPropertyValue("filter") || styles.filter;
-        if (filter && filter !== "none") {
+        if (!boxless && filter && filter !== "none") {
           if (
             /(?:^|\s)opacity\(\s*(?:0+(?:\.0*)?|\.0+)%?\s*\)(?:\s|$)/i.test(
               filter,
@@ -791,24 +865,46 @@ export function auditReplayIframeContent({
           }
           visibilityUncertain = true;
         }
-        const hasUnsupportedMask = [
-          "mask-image",
-          "-webkit-mask-image",
-          "mask-border-source",
-          "-webkit-mask-box-image-source",
-        ].some((property) => {
-          const value =
-            styles.getPropertyValue(property) ||
-            (current as HTMLElement).style?.getPropertyValue(property);
-          return value !== undefined && value !== "" && value !== "none";
-        });
+        const legacyClip =
+          styles.getPropertyValue("clip") ||
+          (current as HTMLElement).style?.getPropertyValue("clip");
+        if (
+          legacyClip &&
+          legacyClip !== "auto" &&
+          !boxless &&
+          (styles.position === "absolute" || styles.position === "fixed")
+        ) {
+          const geometry = geometryFor(current, view);
+          const clipPolygon = legacyClipPolygon(legacyClip, geometry);
+          if (clipPolygon) {
+            visiblePolygon = intersectPolygons(
+              visiblePolygon,
+              clipPolygon.map((point) => pointToScreen(geometry, point)),
+            );
+          } else {
+            visibilityUncertain = true;
+          }
+        }
+        const hasUnsupportedMask =
+          !boxless &&
+          [
+            "mask-image",
+            "-webkit-mask-image",
+            "mask-border-source",
+            "-webkit-mask-box-image-source",
+          ].some((property) => {
+            const value =
+              styles.getPropertyValue(property) ||
+              (current as HTMLElement).style?.getPropertyValue(property);
+            return value !== undefined && value !== "" && value !== "none";
+          });
         if (hasUnsupportedMask) visibilityUncertain = true;
         const clipPath =
           styles.getPropertyValue("clip-path") ||
           styles.getPropertyValue("-webkit-clip-path") ||
           (current as HTMLElement).style?.getPropertyValue("clip-path") ||
           (current as HTMLElement).style?.getPropertyValue("-webkit-clip-path");
-        if (clipPath && clipPath !== "none") {
+        if (!boxless && clipPath && clipPath !== "none") {
           const geometry = geometryFor(current, view);
           const clippedByShape = insetClipPolygon(clipPath, geometry);
           if (clippedByShape) {

package/corpus/templates/analytics/server/db/index.ts

@@ -1,5 +1,6 @@
 import { registerDataProgramsShareable } from "@agent-native/core/data-programs";
 import { createGetDb } from "@agent-native/core/db";
+import { registerIdentityColumns } from "@agent-native/core/org";
 import { registerShareableResource } from "@agent-native/core/sharing";
 
 import {
@@ -15,6 +16,24 @@ export { schema };
 
 registerDataProgramsShareable();
 
+registerIdentityColumns([
+  {
+    table: "session_recordings",
+    column: "session_id",
+    emailChange: "retain",
+    offboard: "retain",
+    reason:
+      "Legacy last-known session pointer for recordings predating association history.",
+  },
+  {
+    table: "session_recording_session_associations",
+    column: "session_id",
+    emailChange: "retain",
+    offboard: "retain",
+    reason: "Observed session ids preserve replay association history.",
+  },
+]);
+
 registerShareableResource({
   type: "dashboard",
   resourceTable: schema.dashboards,

package/corpus/templates/analytics/server/db/schema.ts

@@ -786,6 +786,25 @@ export const sessionRecordingShares = createSharesTable(
   "session_recording_shares",
 );
 
+export const sessionRecordingSessionAssociations = table(
+  "session_recording_session_associations",
+  {
+    id: text("id").primaryKey(),
+    recordingId: text("recording_id")
+      .notNull()
+      .references(() => sessionRecordings.id, { onDelete: "cascade" }),
+    sessionId: text("session_id").notNull(),
+  },
+  (association) => ({
+    recordingSessionUnique: uniqueIndex(
+      "session_recording_session_associations_recording_session_idx",
+    ).on(association.recordingId, association.sessionId),
+    sessionRecordingIdx: index(
+      "session_recording_session_associations_session_recording_idx",
+    ).on(association.sessionId, association.recordingId),
+  }),
+);
+
 export const sessionReplayChunks = table(
   "session_replay_chunks",
   {

package/corpus/templates/analytics/server/jobs/analytics-alerts.ts

@@ -1,14 +1,23 @@
+import { runWithRequestContext } from "@agent-native/core/server";
+
 import {
   claimAnalyticsAlertRuleEvaluation,
   ensureDefaultAnalyticsAlertRules,
   evaluateAndNotifyAnalyticsAlertRule,
+  evaluateBigQueryAnalyticsAlertBatch,
+  isBigQueryAnalyticsAlertBatchEligible,
   listEnabledAnalyticsAlertRules,
   markAnalyticsAlertRuleError,
+  prioritizeBigQueryAnalyticsAlertRules,
+  type AnalyticsAlertRule,
+  type AnalyticsAlertEvaluation,
 } from "../lib/analytics-alerts";
+import { getFirstPartyAnalyticsBackend } from "../lib/first-party-analytics-backend.js";
 
 let running = false;
 let listRulesFailureLogged = false;
 const DEFAULT_MAX_RULES_PER_SWEEP = 100;
+const MAX_BIGQUERY_RULES_PER_BATCH = 3;
 
 function maxRulesPerSweep(input?: number): number {
   if (input) return Math.max(1, Math.min(500, Math.floor(input)));
@@ -64,22 +73,127 @@ export async function runAnalyticsAlertsOnce(
     listRulesFailureLogged = false;
     remaining = rules.length >= sweepLimit ? 1 : 0;
 
-    for (const rule of rules) {
+    async function failRule(rule: AnalyticsAlertRule, err: unknown) {
+      failed++;
+      try {
+        await markAnalyticsAlertRuleError(rule.id, err);
+      } catch (statusError) {
+        console.error(
+          `[analytics-alerts] Failed to mark rule ${rule.id} error:`,
+          statusError,
+        );
+      }
+      console.error(
+        `[analytics-alerts] Rule ${rule.id} (${rule.name}) failed:`,
+        err,
+      );
+    }
+
+    async function claimRule(rule: AnalyticsAlertRule): Promise<boolean> {
       try {
         const claimed = await claimAnalyticsAlertRuleEvaluation(rule);
-        if (!claimed) continue;
-        processed++;
-        const result = await evaluateAndNotifyAnalyticsAlertRule(rule);
+        if (claimed) processed++;
+        return claimed;
+      } catch (err) {
+        await failRule(rule, err);
+        return false;
+      }
+    }
+
+    const batches = new Map<string, AnalyticsAlertRule[]>();
+    const individualRules: AnalyticsAlertRule[] = [];
+    for (const rule of rules) {
+      try {
+        if (!isBigQueryAnalyticsAlertBatchEligible(rule)) {
+          individualRules.push(rule);
+          continue;
+        }
+        const backend = await runWithRequestContext(
+          {
+            userEmail: rule.ownerEmail,
+            ...(rule.orgId !== null ? { orgId: rule.orgId } : {}),
+          },
+          () =>
+            getFirstPartyAnalyticsBackend({
+              userEmail: rule.ownerEmail,
+              orgId: rule.orgId,
+            }),
+        );
+        if (backend.sink !== "bigquery") {
+          individualRules.push(rule);
+          continue;
+        }
+        const key = JSON.stringify([rule.ownerEmail, rule.orgId]);
+        const batch = batches.get(key);
+        if (batch) batch.push(rule);
+        else batches.set(key, [rule]);
+      } catch (err) {
+        if (await claimRule(rule)) await failRule(rule, err);
+      }
+    }
+
+    async function notifyRule(
+      rule: AnalyticsAlertRule,
+      now: Date,
+      evaluation?: AnalyticsAlertEvaluation,
+    ) {
+      try {
+        const result = await evaluateAndNotifyAnalyticsAlertRule(
+          rule,
+          now,
+          evaluation,
+        );
         if (result.status === "triggered") triggered++;
+        if (result.status === "error") failed++;
       } catch (err) {
-        failed++;
-        await markAnalyticsAlertRuleError(rule.id, err).catch(() => {});
-        console.error(
-          `[analytics-alerts] Rule ${rule.id} (${rule.name}) failed:`,
-          err,
+        await failRule(rule, err);
+      }
+    }
+
+    for (const rules of batches.values()) {
+      const scopedRules = prioritizeBigQueryAnalyticsAlertRules(rules);
+      for (
+        let offset = 0;
+        offset < scopedRules.length;
+        offset += MAX_BIGQUERY_RULES_PER_BATCH
+      ) {
+        const plannedBatch = scopedRules.slice(
+          offset,
+          offset + MAX_BIGQUERY_RULES_PER_BATCH,
         );
+        const batch: AnalyticsAlertRule[] = [];
+        for (const rule of plannedBatch) {
+          if (await claimRule(rule)) batch.push(rule);
+        }
+        if (!batch.length) continue;
+        const now = new Date();
+        let evaluations: Awaited<
+          ReturnType<typeof evaluateBigQueryAnalyticsAlertBatch>
+        >;
+        try {
+          evaluations = await evaluateBigQueryAnalyticsAlertBatch(batch, now);
+        } catch (err) {
+          for (const rule of batch) await failRule(rule, err);
+          continue;
+        }
+        for (const rule of batch) {
+          const result = evaluations.get(rule.id);
+          if (!result) {
+            await failRule(
+              rule,
+              new Error(`Missing analytics alert batch result: ${rule.id}`),
+            );
+          } else if ("error" in result) {
+            await failRule(rule, result.error);
+          } else {
+            await notifyRule(rule, now, result.evaluation);
+          }
+        }
       }
     }
+    for (const rule of individualRules) {
+      if (await claimRule(rule)) await notifyRule(rule, new Date());
+    }
   } finally {
     running = false;
   }