@agent-native/core 0.108.0 → 0.109.1

package/corpus/templates/analytics/changelog/2026-07-17-dashboard-extensions-show-a-loading-skeleton.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-17
+---
+
+Dashboard extensions now show a loading skeleton while their content loads.

package/corpus/templates/analytics/changelog/2026-07-17-errors-now-group-repeat-failures-consistently-and-keep-priva.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-17
+---
+
+Errors now group repeat failures consistently and keep private replay links protected

package/corpus/templates/analytics/changelog/2026-07-17-gong-transcript-reviews-now-batch-bounded-call-windows-for-f.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-17
+---
+
+Gong reviews now batch transcript evidence, use provider-native synthesis when connected, and support fast direct reads from sibling apps.

package/corpus/templates/analytics/changelog/2026-07-17-hubspot-deal-filters-now-run-in-hubspot-before-paging-result.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-17
+---
+
+HubSpot deal filters now run in HubSpot before paging results, avoiding full-corpus scans.

package/corpus/templates/analytics/changelog/2026-07-17-notion-content-calendars-now-discover-the-matching-database-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-17
+---
+
+Notion content calendars now discover the matching database by schema instead of relying on one workspace's database ID.

package/corpus/templates/analytics/changelog/2026-07-17-pylon-dashboard-reads-now-use-the-paginated-issue-search-api.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-17
+---
+
+Pylon dashboard reads now use the paginated issue search API while preserving existing dashboard compatibility.

package/corpus/templates/analytics/changelog/2026-07-17-slack-reads-no-longer-join-channels-and-report-pagination-coverage.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-17
+---
+
+Slack reads no longer join channels automatically, resolve message authors in bulk, and report pagination coverage explicitly.

package/corpus/templates/analytics/docs/schemas/first-party-analytics.md

@@ -117,20 +117,29 @@ event_name = '$ai_sentiment'
 
 Useful query fields live in `properties`:
 
-| Property                                         | Description                               |
-| ------------------------------------------------ | ----------------------------------------- |
-| `$ai_trace_id`, `run_id`                         | Agent run id                              |
-| `$ai_session_id`, `thread_id`                    | Chat/thread id, when available            |
-| `$ai_model`, `model`                             | Model used                                |
-| `$ai_provider`, `provider`                       | Engine/provider name                      |
-| `$ai_input_tokens`, `input_tokens`               | Input tokens                              |
-| `$ai_output_tokens`, `output_tokens`             | Output tokens                             |
-| `cache_read_tokens`, `cache_write_tokens`        | Prompt-cache token counts                 |
-| `$ai_total_cost_usd`, `cost_usd`                 | Estimated run cost in USD                 |
-| `cost_cents_x100`                                | Estimated run cost in centicents          |
-| `$ai_latency`, `duration_ms`                     | Run duration in seconds / milliseconds    |
-| `tool_calls`, `successful_tools`, `failed_tools` | Tool-call counts                          |
-| `$ai_is_error`, `status`, `$ai_error`            | Error status and message, when applicable |
+| Property                                         | Description                                                                                       |
+| ------------------------------------------------ | ------------------------------------------------------------------------------------------------- |
+| `$ai_trace_id`, `run_id`                         | Agent run id                                                                                      |
+| `$ai_session_id`, `thread_id`                    | Chat/thread id, when available                                                                    |
+| `$ai_model`, `model`                             | Model used                                                                                        |
+| `$ai_provider`, `provider`                       | Engine/provider name                                                                              |
+| `$ai_input_tokens`, `input_tokens`               | Input tokens                                                                                      |
+| `$ai_output_tokens`, `output_tokens`             | Output tokens                                                                                     |
+| `cache_read_tokens`, `cache_write_tokens`        | Prompt-cache token counts                                                                         |
+| `$ai_total_cost_usd`, `cost_usd`                 | Estimated run cost in USD                                                                         |
+| `cost_cents_x100`                                | Estimated run cost in centicents                                                                  |
+| `$ai_latency`, `duration_ms`                     | Run duration in seconds / milliseconds                                                            |
+| `tool_calls`, `successful_tools`, `failed_tools` | Complete tool-call counts                                                                         |
+| `tools`, `tools_truncated`                       | First 50 tool names, offsets, durations, statuses, and error classes, including interrupted calls |
+| `delegated`, `delegation_protocol`, `caller_app` | Delegated-run attribution                                                                         |
+| `a2a_task_id`, `parent_run_id`, `parent_turn_id` | Cross-app trace linkage, when available                                                           |
+| `$ai_is_error`, `status`, `$ai_error`            | Error status and message, when applicable                                                         |
+
+The `tools` array never includes tool arguments, results, or error messages.
+Use `tools_truncated` with the complete `tool_calls` count when a run exceeds
+the 50-entry detail cap.
+Failed runs still emit a generation row with zero or known usage so delegated
+timeouts and setup failures remain visible.
 
 Explicit thumbs feedback is content-free and uses these `$ai_feedback`
 properties:

package/corpus/templates/analytics/docs/schemas/tracked-events.md

@@ -29,7 +29,11 @@ Events tracked by application instrumentation and stored in the configured appli
   `$ai_model`, `$ai_provider`, `$ai_input_tokens`, `$ai_output_tokens`,
   `$ai_latency`, `$ai_total_cost_usd`, `run_id`, `thread_id`,
   `cost_cents_x100`, `duration_ms`, `tool_calls`, `status`, and error fields.
-  Prompt and response content are excluded by default.
+  A bounded `tools` array records only tool names, relative start times,
+  durations, statuses, and coarse error classes; interrupted tools and failed
+  runs remain visible, and `tools_truncated` marks runs above the 50-entry cap.
+  Delegated runs also include protocol, caller, task, parent-run, and
+  parent-turn linkage. Prompt, argument, result, and response content are excluded.
 
 ### Content Editing
 

package/corpus/templates/analytics/server/handlers/notion.ts

@@ -1,4 +1,9 @@
-import { defineEventHandler, getRouterParam, setResponseStatus } from "h3";
+import {
+  defineEventHandler,
+  getQuery,
+  getRouterParam,
+  setResponseStatus,
+} from "h3";
 
 import {
   requireCredential,
@@ -16,7 +21,10 @@ export const handleContentCalendar = defineEventHandler(async (event) => {
     const missing = await requireCredential(event, "NOTION_API_KEY", "Notion");
     if (missing) return missing;
     try {
-      const entries = await getContentCalendar();
+      const { databaseId } = getQuery(event);
+      const entries = await getContentCalendar(
+        databaseId as string | undefined,
+      );
       return { entries, total: entries.length };
     } catch (err: any) {
       console.error("Notion content-calendar error:", err.message);
@@ -32,7 +40,10 @@ export const handleContentCalendarSchema = defineEventHandler(async (event) => {
     const missing = await requireCredential(event, "NOTION_API_KEY", "Notion");
     if (missing) return missing;
     try {
-      const schema = await getContentCalendarSchema();
+      const { databaseId } = getQuery(event);
+      const schema = await getContentCalendarSchema(
+        databaseId as string | undefined,
+      );
       return { schema };
     } catch (err: any) {
       console.error("Notion schema error:", err.message);

package/corpus/templates/analytics/server/handlers/slack.ts

@@ -10,11 +10,11 @@ import {
   runApiHandlerWithContext,
 } from "../lib/credentials";
 import {
-  listChannels,
   getChannelHistory,
-  searchMessages,
-  resolveUsers,
   getTeamInfo,
+  listChannelsWithCoverage,
+  resolveUsersWithCoverage,
+  searchMessages,
   type Workspace,
   type SlackMessage,
 } from "../lib/slack";
@@ -49,12 +49,21 @@ export const handleSlackTeam = defineEventHandler((event) =>
 export const handleSlackChannels = defineEventHandler((event) =>
   runApiHandlerWithContext(event, async () => {
     try {
-      const { workspace: workspaceParam } = getQuery(event);
+      const { workspace: workspaceParam, cursor } = getQuery(event);
       const workspace = parseWorkspace(workspaceParam as string);
       const missing = await requireSlackCredential(event, workspace);
       if (missing) return missing;
-      const channels = await listChannels(workspace);
-      return { channels, total: channels.length };
+      const result = await listChannelsWithCoverage(
+        workspace,
+        cursor as string | undefined,
+      );
+      return {
+        channels: result.channels,
+        total: result.total,
+        truncated: result.truncated,
+        pagination: result.pagination,
+        coverage: result.coverage,
+      };
     } catch (err: any) {
       console.error("Slack channels error:", err.message);
       setResponseStatus(event, 500);
@@ -112,15 +121,33 @@ export const handleSlackHistory = defineEventHandler((event) =>
       const userIds = result.messages
         .map((m) => m.user)
         .filter((id): id is string => !!id);
-      const users = await resolveUsers(workspace, userIds, result.messages);
+      const resolution = await resolveUsersWithCoverage(
+        workspace,
+        userIds,
+        result.messages,
+      );
 
       const enrichedMessages = enrichMessages(result.messages);
 
       return {
         messages: enrichedMessages,
-        users,
+        users: resolution.users,
         has_more: result.has_more,
         next_cursor: result.next_cursor,
+        truncated: result.truncated,
+        pagination: result.pagination,
+        coverage: {
+          ...result.coverage,
+          coverage_complete:
+            result.coverage.coverage_complete &&
+            resolution.coverage.coverage_complete,
+          truncated: result.coverage.truncated || resolution.coverage.truncated,
+          truncation_reasons: [
+            ...result.coverage.truncation_reasons,
+            ...resolution.coverage.truncation_reasons,
+          ],
+          authors: resolution.coverage,
+        },
       };
     } catch (err: any) {
       console.error("Slack history error:", err.message);
@@ -165,29 +192,45 @@ export const handleSlackMultiHistory = defineEventHandler((event) =>
         ? JSON.parse(cursorsParam as string)
         : {};
 
-      // Fetch pageSize messages from each channel in parallel
-      const results = await Promise.all(
-        channelIds.map((id) =>
-          getChannelHistory(workspace, id, pageSize, cursors[id]),
+      // Fetch pageSize messages from each channel in parallel while preserving
+      // partial results when the bot is not invited to one of the channels.
+      const channelResults = await Promise.allSettled(
+        channelIds.map((channelId) =>
+          getChannelHistory(workspace, channelId, pageSize, cursors[channelId]),
         ),
       );
+      const successfulResults = channelResults.flatMap((entry, index) =>
+        entry.status === "fulfilled"
+          ? [{ channelId: channelIds[index], result: entry.value }]
+          : [],
+      );
+      const failedChannelIds = channelResults.flatMap((entry, index) =>
+        entry.status === "rejected" ? [channelIds[index]] : [],
+      );
 
       // Tag messages with channel name and merge
-      const allMessages: (SlackMessage & { channel_name: string })[] = [];
+      const allMessages: (SlackMessage & {
+        channel_id: string;
+        channel_name: string;
+      })[] = [];
       const perChannelHasMore: Record<string, boolean> = {};
       const nextCursors: Record<string, string> = {};
 
-      results.forEach((result, idx) => {
-        const chId = channelIds[idx];
-        const chName = channelNamesList[idx] || chId;
-        perChannelHasMore[chId] = result.has_more;
-        if (result.next_cursor) {
-          nextCursors[chId] = result.next_cursor;
-        }
-        for (const m of result.messages) {
-          allMessages.push({ ...m, channel_name: chName });
+      successfulResults.forEach(({ channelId, result }) => {
+        const chName =
+          channelNamesList[channelIds.indexOf(channelId)] || channelId;
+        perChannelHasMore[channelId] = result.has_more;
+        for (const message of result.messages) {
+          allMessages.push({
+            ...message,
+            channel_id: channelId,
+            channel_name: chName,
+          });
         }
       });
+      failedChannelIds.forEach((channelId) => {
+        perChannelHasMore[channelId] = true;
+      });
 
       // Sort merged by timestamp (newest first)
       allMessages.sort((a, b) => parseFloat(b.ts) - parseFloat(a.ts));
@@ -195,26 +238,112 @@ export const handleSlackMultiHistory = defineEventHandler((event) =>
       // Take top pageSize
       const pageMessages = allMessages.slice(0, pageSize);
 
+      const emittedByChannel = new Map<string, SlackMessage[]>();
+      for (const message of pageMessages) {
+        const emitted = emittedByChannel.get(message.channel_id) ?? [];
+        emitted.push(message);
+        emittedByChannel.set(message.channel_id, emitted);
+      }
+      for (const channelId of channelIds) {
+        const emitted = emittedByChannel.get(channelId);
+        const nextCursor = emitted?.[emitted.length - 1]?.ts;
+        if (nextCursor) nextCursors[channelId] = nextCursor;
+        else if (cursors[channelId])
+          nextCursors[channelId] = cursors[channelId];
+      }
+
       // Enrich text from blocks
-      const enrichedMessages = enrichMessages(pageMessages);
+      const enrichedMessages = pageMessages.map((message) => {
+        const enriched = enrichMessages([message])[0] ?? message;
+        const { channel_id: _channelId, ...rest } = enriched as typeof message;
+        return rest;
+      });
 
       // Resolve users
       const userIds = enrichedMessages
         .map((m) => m.user)
         .filter((id): id is string => !!id);
-      const users = await resolveUsers(workspace, userIds, enrichedMessages);
+      const resolution = await resolveUsersWithCoverage(
+        workspace,
+        userIds,
+        enrichedMessages,
+      );
 
       // has_more is true if any channel has more messages
+      const providerTruncated = successfulResults.some(
+        ({ result }) => result.truncated,
+      );
+      const mergedResultTruncated = allMessages.length > pageSize;
       const hasMore =
-        Object.values(perChannelHasMore).some(Boolean) ||
-        allMessages.length > pageSize;
+        providerTruncated ||
+        mergedResultTruncated ||
+        failedChannelIds.length > 0;
+      const truncationReasons = [
+        ...(providerTruncated ? ["provider_has_more"] : []),
+        ...(mergedResultTruncated ? ["merged_result_limit"] : []),
+        ...failedChannelIds.map(
+          (channelId) => `channel_fetch_failed:${channelId}`,
+        ),
+      ];
+      const channelPagination = Object.fromEntries(
+        channelResults.map((entry, index) => [
+          channelIds[index],
+          entry.status === "fulfilled"
+            ? entry.value.pagination
+            : {
+                cursor_type: "latest_ts" as const,
+                ...(cursors[channelIds[index]]
+                  ? { request_cursor: cursors[channelIds[index]] }
+                  : {}),
+              },
+        ]),
+      );
+      const channelCoverage = Object.fromEntries(
+        channelResults.map((entry, index) => [
+          channelIds[index],
+          entry.status === "fulfilled"
+            ? entry.value.coverage
+            : {
+                requested: pageSize,
+                fetched: 0,
+                returned: 0,
+                pages_fetched: 0,
+                coverage_complete: false,
+                truncated: true,
+                truncation_reasons: [
+                  `channel_fetch_failed:${channelIds[index]}`,
+                ],
+              },
+        ]),
+      );
 
       return {
         messages: enrichedMessages,
-        users,
+        users: resolution.users,
         has_more: hasMore,
         next_cursors: nextCursors,
         total: allMessages.length,
+        truncated: hasMore,
+        pagination: {
+          cursor_type: "per_channel_latest_ts",
+          request_cursors: cursors,
+          next_cursors: nextCursors,
+          channels: channelPagination,
+        },
+        coverage: {
+          requested: channelIds.length * pageSize,
+          fetched: allMessages.length,
+          returned: enrichedMessages.length,
+          pages_fetched: successfulResults.length,
+          coverage_complete: !hasMore && resolution.coverage.coverage_complete,
+          truncated: hasMore || resolution.coverage.truncated,
+          truncation_reasons: [
+            ...truncationReasons,
+            ...resolution.coverage.truncation_reasons,
+          ],
+          channels: channelCoverage,
+          authors: resolution.coverage,
+        },
       };
     } catch (err: any) {
       console.error("Slack multi-history error:", err.message);
@@ -242,9 +371,33 @@ export const handleSlackSearch = defineEventHandler((event) =>
       const userIds = result.messages
         .map((m) => m.user)
         .filter((id): id is string => !!id);
-      const users = await resolveUsers(workspace, userIds, result.messages);
+      const resolution = await resolveUsersWithCoverage(
+        workspace,
+        userIds,
+        result.messages,
+      );
 
-      return { messages: result.messages, users, total: result.total };
+      return {
+        messages: result.messages,
+        users: resolution.users,
+        total: result.total,
+        unsupported: result.unsupported,
+        guidance: result.guidance,
+        truncated: result.truncated,
+        pagination: result.pagination,
+        coverage: {
+          ...result.coverage,
+          coverage_complete:
+            result.coverage.coverage_complete &&
+            resolution.coverage.coverage_complete,
+          truncated: result.coverage.truncated || resolution.coverage.truncated,
+          truncation_reasons: [
+            ...result.coverage.truncation_reasons,
+            ...resolution.coverage.truncation_reasons,
+          ],
+          authors: resolution.coverage,
+        },
+      };
     } catch (err: any) {
       console.error("Slack search error:", err.message);
       setResponseStatus(event, 500);

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

@@ -1,6 +1,6 @@
 import {
   claimAnalyticsAlertRuleEvaluation,
-  ensureDefaultHttp5xxSpikeAlertRules,
+  ensureDefaultAnalyticsAlertRules,
   evaluateAndNotifyAnalyticsAlertRule,
   listEnabledAnalyticsAlertRules,
   markAnalyticsAlertRuleError,
@@ -45,8 +45,8 @@ export async function runAnalyticsAlertsOnce(
 
   try {
     const sweepLimit = maxRulesPerSweep(options.limit);
-    await ensureDefaultHttp5xxSpikeAlertRules().catch((err) => {
-      console.error("[analytics-alerts] Default 5xx alert seed failed:", err);
+    await ensureDefaultAnalyticsAlertRules().catch((err) => {
+      console.error("[analytics-alerts] Default alert seed failed:", err);
     });
     let rules: Awaited<ReturnType<typeof listEnabledAnalyticsAlertRules>>;
     try {

package/corpus/templates/analytics/server/lib/agent-chat-plan-mode.ts

@@ -43,14 +43,9 @@ export const INITIAL_TOOL_NAMES = [
   "query-staged-dataset",
   "list-staged-datasets",
   "account-deep-dive",
-  "hubspot-deals",
-  "hubspot-records",
-  "hubspot-pipelines",
   "gong-calls",
+  "gong-native-insights",
   "github-repo-files",
-  "jira-search",
-  "slack-messages",
-  "sentry",
   "list-data-dictionary",
   "navigate",
 ];
@@ -66,6 +61,7 @@ export const PLAN_MODE_ACT_ONLY_TOOLS = new Set([
   "hubspot-records",
   "hubspot-pipelines",
   "gong-calls",
+  "gong-native-insights",
   "github-repo-files",
   "jira-search",
   "slack-messages",