@agent-native/core 0.108.0 → 0.109.1

package/corpus/templates/analytics/.builder/skills/pylon/SKILL.md

@@ -7,49 +7,31 @@ description: >
 
 # Pylon Integration (Support)
 
-## Connection
-
-- **Base URL**: `https://api.usepylon.com`
-- **Auth**: `Authorization: Bearer $PYLON_API_KEY`
-- **Env vars**: `PYLON_API_KEY`
-- **Caching**: 10-minute in-memory cache, max 120 entries
-
-## Server Lib & API Routes
-
-- **File**: `server/lib/pylon.ts`
-
-### Exported Functions
-
-| Function              | Description                          |
-| --------------------- | ------------------------------------ |
-| `getAccounts(query?)` | List/search accounts                 |
-| `getAccount(id)`      | Get single account                   |
-| `getIssues(params?)`  | List issues (30-day window enforced) |
-| `getContacts(query?)` | Search contacts                      |
-
-### API Routes
-
-| Route                     | Description          |
-| ------------------------- | -------------------- |
-| `GET /api/pylon/issues`   | List support tickets |
-| `GET /api/pylon/accounts` | List accounts        |
-
-## Script Usage
-
-```bash
-# Open support tickets for a customer
-pnpm action pylon-issues --account="Example Corp" --state=open
-
-# All issues
-pnpm action pylon-issues --query=search_term
-
-# List accounts
-pnpm action pylon-issues --accounts
-```
+Pylon access uses the shared provider API runtime. Do not add a separate Pylon
+client. `/api/pylon/issues` remains only as a thin compatibility route for an
+existing dashboard and delegates to the same action/provider runtime.
+
+## Access Paths
+
+- Use `provider-api-catalog`, `provider-api-docs`, and
+  `provider-api-request` with provider `pylon` for bounded account, contact,
+  and issue queries.
+- Use a data program with `providerFetchAll("pylon", ...)` for reusable joins,
+  exhaustive support-ticket analysis, or dashboard sources. Existing risk
+  meeting programs demonstrate the HubSpot-to-Pylon domain join.
+- Stage large responses and reduce them with `query-staged-dataset` or
+  `run-code` before returning results to chat.
+- For issue corpora, prefer `POST /issues/search` with the created-at filter and
+  body cursor. The older `GET /issues` endpoint has a 30-day window and should
+  not be used for broad dashboard coverage.
+
+Authentication is resolved from the current viewer's scoped Pylon credential
+through the shared provider runtime.
 
 ## Key Patterns & Gotchas
 
-- `getIssues` enforces a max 30-day window via `start_time` and `end_time` query params (API requirement)
-- API returns `{ data: ... }` wrappers or raw arrays — code handles both defensively
-- Pylon API exists in this analytics app (`code/`) but the secrets `pylon.api_key` and `pylon.api_secret` referenced elsewhere are in secrets manager, not env vars
-- No Pylon data in BigQuery — must query the API directly
+- Confirm the current endpoint, time-window, filter, and cursor contract with
+  `provider-api-docs`; do not impose a fixed lookback window in a wrapper.
+- Report inspected issue/account counts, pagination coverage, failed pages, and
+  truncation. A sampled response cannot support an exhaustive absence claim.
+- Query Pylon directly unless the user explicitly asks for a warehouse copy.

package/corpus/templates/analytics/AGENTS.md

@@ -122,10 +122,11 @@ membership id when its native update status reports `update-available`.
   with captured errors, mint a temporary replay-context link, and inspect the
   timeline, page navigation, console diagnostics, failed network requests, and
   clicks when needed. The authenticated connector catalog is the fast fallback
-  and exposes only bounded, user/org-scoped read actions for incident triage:
+  and exposes only bounded, user/org-scoped read actions. Incident triage uses:
   `list-session-recordings`, `get-session-replay-summary`,
   `get-session-replay-timeline`, `query-agent-native-analytics`,
-  `list-error-issues`, and `get-error-issue`. Fetch the summary before the
+  `list-error-issues`, and `get-error-issue`. Cross-app Gong work also exposes
+  `account-deep-dive`, `gong-calls`, and `gong-native-insights`. Fetch the summary before the
   sanitized timeline; the timeline contains bounded page/click/error markers
   without raw replay events or storage references. Do not add replay blob or
   dashboard mutation actions to this catalog without an explicit security
@@ -137,8 +138,9 @@ membership id when its native update status reports `update-available`.
   issue id.
 - Analytics keeps its direct MCP surface explicitly curated, so external
   agents should use `ask_app` for multi-step investigation and changes. The
-  six incident reads above are bounded, user/org-scoped fallback tools for
-  callers that already know which lookup they need. Generic core
+  cataloged reads above are bounded, user/org-scoped fallback tools for callers
+  that already know which lookup they need. Sibling apps should invoke the exact
+  action directly when no Analytics reasoning loop is needed. Generic core
   `db-schema` / `db-query` remain in-app agent tools and are not exposed
   directly because broad SQL/schema access is too powerful to infer from
   read-only metadata. Writes remain `ask_app`-only. Use the explicit catalog
@@ -174,14 +176,17 @@ membership id when its native update status reports `update-available`.
   serialization traps. The script is constrained: only documented dashboard
   method calls with JSON-compatible arguments are parsed; variables, imports,
   loops, functions, network, filesystem, and DB access are not available.
-- Dashboard extension boxes use `chartType: "extension"` with
-  `config.extensionSlotId`. The stable per-box slot is
-  `analytics.dashboard.<dashboard-id>.panel.<panel-id>`. To add an extension,
-  create/choose it, call `add-extension-slot-target` with that slot id, then
-  `install-extension` with the same slot id. Installs are per-user; the
-  dashboard panel remains shared. Slot-backed extensions receive dashboard id,
-  name, description, current filters, and the panel id/title/slot id as context.
-  `config.extensionId` is legacy direct embedding for existing dashboards.
+- Dashboard extension boxes use `chartType: "extension"`. For ordinary requests
+  such as "put X in this dashboard," default to `config.extensionId`: the
+  author-selected extension is part of the shared dashboard, renders for every
+  viewer who can access it, and remains present in scheduled report captures.
+  Direct embeds receive dashboard id, name, description, current filters, and
+  panel context. Use `config.extensionSlotId` only when the user explicitly asks
+  for a personal/per-viewer widget slot. The stable per-box slot is
+  `analytics.dashboard.<dashboard-id>.panel.<panel-id>`; call
+  `add-extension-slot-target` and `install-extension` for it. Slot installs are
+  per-user, so different viewers can see different widgets and service-account
+  report captures may show the empty install affordance.
 - Dashboard saves keep bounded history in SQL. Use
   `list-dashboard-revisions` to inspect undo points and
   `restore-dashboard-revision` to restore one instead of hand-editing history
@@ -207,7 +212,11 @@ membership id when its native update status reports `update-available`.
   `update-extension` blocks full-body replacement unless
   `allowFullReplacement: true` is explicit, and that flag is reserved for a
   user-requested broad rewrite or a complete replacement body supplied by the
-  user. If a focused edit fails, do not retry unchanged arguments.
+  user. A request that combines a visual rewrite (for example compacting,
+  removing sections, renaming, or changing padding) with a data repair is still
+  a broad rewrite; after inspecting the current extension, set
+  `allowFullReplacement: true` for the complete replacement. If a focused edit
+  fails, do not retry unchanged arguments.
 - Use framework sharing and access helpers for dashboards, analyses, and saved
   resources.
 - Dashboard email reports live in SQL via the

package/corpus/templates/analytics/actions/account-deep-dive.ts

@@ -377,6 +377,7 @@ export default defineAction({
   }),
   http: { method: "GET" },
   readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
   run: async (args) => {
     const trimmedQuery = args.query.trim();
     const gaps: string[] = [];

package/corpus/templates/analytics/actions/configure-gong-native-insights.ts

@@ -0,0 +1,29 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { writeGongNativeInsightsPolicy } from "../server/lib/gong-native-policy";
+
+export default defineAction({
+  description:
+    "Enable or disable paid Gong native semantic operations for the current workspace. Enabling this permits individually authorized gong-native-insights calls to consume Gong credits; it does not send a Gong request by itself. Disable it to fail closed for every semantic request while keeping raw Gong evidence actions available.",
+  schema: z.object({
+    enabled: z
+      .boolean()
+      .describe(
+        "Whether this workspace may make paid Gong native semantic requests.",
+      ),
+  }),
+  http: { method: "POST" },
+  needsApproval: true,
+  toolCallable: false,
+  run: async ({ enabled }) => {
+    const policy = await writeGongNativeInsightsPolicy(enabled);
+    return {
+      ...policy,
+      creditRequests: 0,
+      guidance: enabled
+        ? "Gong native semantic requests are enabled for this scope. Each request still requires allowCreditRequest=true and independently consumes Gong credits."
+        : "Gong native semantic requests are disabled. Use gong-calls or the provider corpus evidence path.",
+    };
+  },
+});

package/corpus/templates/analytics/actions/content-calendar-schema.ts

@@ -4,10 +4,14 @@ import { z } from "zod";
 import { getContentCalendarSchema } from "../server/lib/notion";
 
 export default defineAction({
-  description: "Get the Notion content calendar database schema.",
-  schema: z.object({}),
+  description:
+    "Get a Notion content calendar database schema. Pass databaseId when discovery would be ambiguous.",
+  schema: z.object({
+    databaseId: z.string().optional(),
+  }),
   http: { method: "GET" },
-  run: async () => {
-    return await getContentCalendarSchema();
+  readOnly: true,
+  run: async ({ databaseId }) => {
+    return await getContentCalendarSchema(databaseId);
   },
 });

package/corpus/templates/analytics/actions/content-calendar.ts

@@ -7,11 +7,19 @@ export default defineAction({
   // Read-only provider query: safe to call from run-code `appAction` and
   // reusable across continuation retries (no re-fetch on resume).
   readOnly: true,
-  description: "Get all entries from the Notion content calendar.",
-  schema: z.object({}),
+  description:
+    "Get all entries from a Notion content calendar. Pass databaseId when a workspace has multiple matching databases; otherwise the action discovers the uniquely matching database by schema.",
+  schema: z.object({
+    databaseId: z
+      .string()
+      .optional()
+      .describe(
+        "Optional Notion database ID. Omit to discover a unique database with Topic, Status, and Publish Date properties.",
+      ),
+  }),
   http: { method: "GET" },
-  run: async () => {
-    const entries = await getContentCalendar();
+  run: async ({ databaseId }) => {
+    const entries = await getContentCalendar(databaseId);
     return { entries, total: Array.isArray(entries) ? entries.length : 0 };
   },
 });

package/corpus/templates/analytics/actions/dashboard-mutation-api.ts

@@ -132,7 +132,8 @@ export const DASHBOARD_MUTATION_EXAMPLES = [
   `dashboard.insertPanel({"id":"new-kpi","title":"New KPI","source":"first-party","chartType":"metric","width":1,"config":{"timeScope":"dashboard"},"sql":"SELECT COUNT(*) AS value FROM analytics_events WHERE event_date >= '{{dateStart}}' AND event_date < '{{dateEnd}}'"}).atTop();`,
   `dashboard.insertPanel({"id":"new-chart","title":"New Chart","source":"first-party","chartType":"line","width":1,"config":{"timeScope":"dashboard"},"sql":"SELECT event_date AS date, COUNT(*) AS value FROM analytics_events WHERE event_date >= '{{dateStart}}' AND event_date < '{{dateEnd}}' GROUP BY event_date ORDER BY event_date"}).nextTo("retention-over-time");`,
   `dashboard.insertPanel({"id":"row-chart","title":"Row Chart","source":"first-party","chartType":"bar","width":1,"config":{"timeScope":"dashboard"},"sql":"SELECT event_name AS name, COUNT(*) AS value FROM analytics_events WHERE event_date >= '{{dateStart}}' AND event_date < '{{dateEnd}}' GROUP BY event_name"}).atRow(2);`,
-  'dashboard.insertPanel({"id":"pipeline-widget","title":"Pipeline Widget","chartType":"extension","width":3,"config":{"extensionSlotId":"analytics.dashboard.<dashboard-id>.panel.pipeline-widget"}}).atBottom();',
+  'dashboard.insertPanel({"id":"pipeline-widget","title":"Pipeline Widget","chartType":"extension","width":3,"config":{"extensionId":"<extension-id>"}}).atBottom();',
+  'dashboard.insertPanel({"id":"personal-widget-slot","title":"Personal Widget Slot","chartType":"extension","width":3,"config":{"extensionSlotId":"analytics.dashboard.<dashboard-id>.panel.personal-widget-slot"}}).atBottom();',
 ] as const;
 
 export type DashboardMutationOperation =

package/corpus/templates/analytics/actions/gong-calls.ts

@@ -20,10 +20,12 @@ const DEFAULT_GONG_TRANSCRIPT_LIMIT = 3;
 const MAX_GONG_TRANSCRIPT_LIMIT = 50;
 const DEFAULT_TRANSCRIPT_MAX_CHARS = 8_000;
 const MAX_TRANSCRIPT_MAX_CHARS = 100_000;
+const MAX_AGGREGATE_TRANSCRIPT_CHARS = 60_000;
 const DEFAULT_TRANSCRIPT_SCAN_LIMIT = 50;
 const MAX_TRANSCRIPT_SCAN_LIMIT = 200;
 const DEFAULT_TRANSCRIPT_SEARCH_MAX_CHARS = MAX_TRANSCRIPT_MAX_CHARS;
 const TRANSCRIPT_BATCH_SIZE = 20;
+const TRANSCRIPT_BATCH_CONCURRENCY = 3;
 const MAX_TRANSCRIPT_MATCHES_PER_CALL = 5;
 const MATCH_SNIPPET_RADIUS = 240;
 
@@ -74,6 +76,20 @@ function normalizeBoundedInt(
   return Math.max(min, Math.min(max, Math.floor(value!)));
 }
 
+function boundedTranscriptExcerptChars(
+  requestedChars: number,
+  transcriptCount: number,
+): number {
+  if (transcriptCount <= 0) return requestedChars;
+  return Math.min(
+    requestedChars,
+    Math.max(
+      1_000,
+      Math.floor(MAX_AGGREGATE_TRANSCRIPT_CHARS / transcriptCount),
+    ),
+  );
+}
+
 function asRecord(value: unknown): Record<string, unknown> | null {
   return value && typeof value === "object"
     ? (value as Record<string, unknown>)
@@ -218,6 +234,36 @@ async function fetchTranscriptBatch(calls: GongCall[]): Promise<{
   }
 }
 
+async function fetchTranscriptBatches(calls: GongCall[]): Promise<
+  Array<{
+    calls: GongCall[];
+    result: Awaited<ReturnType<typeof fetchTranscriptBatch>>;
+  }>
+> {
+  const batches = chunkCalls(calls, TRANSCRIPT_BATCH_SIZE);
+  const results: Array<{
+    calls: GongCall[];
+    result: Awaited<ReturnType<typeof fetchTranscriptBatch>>;
+  }> = [];
+  for (
+    let index = 0;
+    index < batches.length;
+    index += TRANSCRIPT_BATCH_CONCURRENCY
+  ) {
+    results.push(
+      ...(await Promise.all(
+        batches
+          .slice(index, index + TRANSCRIPT_BATCH_CONCURRENCY)
+          .map(async (batch) => ({
+            calls: batch,
+            result: await fetchTranscriptBatch(batch),
+          })),
+      )),
+    );
+  }
+  return results;
+}
+
 async function searchTranscriptEvidence(
   calls: GongCall[],
   query: string,
@@ -234,8 +280,10 @@ async function searchTranscriptEvidence(
   let truncatedTranscripts = 0;
   const callsToScan = calls.slice(0, scanLimit);
 
-  for (const batch of chunkCalls(callsToScan, TRANSCRIPT_BATCH_SIZE)) {
-    const batchResult = await fetchTranscriptBatch(batch);
+  for (const {
+    calls: batch,
+    result: batchResult,
+  } of await fetchTranscriptBatches(callsToScan)) {
     errors.push(...batchResult.errors);
 
     for (const call of batch) {
@@ -374,8 +422,10 @@ async function loadTranscriptEvidence(
 ): Promise<TranscriptEvidence[]> {
   const evidence: TranscriptEvidence[] = [];
   const callsToLoad = calls.slice(0, limit);
-  for (const batch of chunkCalls(callsToLoad, TRANSCRIPT_BATCH_SIZE)) {
-    const batchResult = await fetchTranscriptBatch(batch);
+  for (const {
+    calls: batch,
+    result: batchResult,
+  } of await fetchTranscriptBatches(callsToLoad)) {
     const errorByCallId = new Map(
       batchResult.errors.map((error) => [error.callId, error.error]),
     );
@@ -411,19 +461,31 @@ async function loadTranscriptEvidence(
  * ISO string for the Gong window filters. Returns undefined for empty/invalid
  * input so the caller falls back to the `days` window.
  */
-function normalizeGongDate(value: string | undefined): string | undefined {
+function normalizeGongDate(
+  value: string | undefined,
+  boundary: "start" | "end" = "start",
+): string | undefined {
   if (!value || typeof value !== "string") return undefined;
-  const ms = Date.parse(value.trim());
+  const normalized = value.trim();
+  const dateOnly = /^\d{4}-\d{2}-\d{2}$/.test(normalized);
+  const ms = Date.parse(dateOnly ? `${normalized}T00:00:00.000Z` : normalized);
   if (Number.isNaN(ms)) return undefined;
-  return new Date(ms).toISOString();
+  const date = new Date(ms);
+  if (dateOnly && boundary === "end") date.setUTCDate(date.getUTCDate() + 1);
+  return date.toISOString();
 }
 
 export default defineAction({
   // Read-only provider query: safe to call from run-code `appAction` and
   // reusable across continuation retries (no re-fetch on resume).
   readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
+  // A bounded multi-call transcript review is intentionally larger than the
+  // shared 50K tool default. One batched result avoids 10+ one-call-at-a-time
+  // model round trips while still staying well below the model context limit.
+  maxResultChars: 100_000,
   description:
-    "Query Gong sales calls, transcripts, and users. Pass --users for user list, --transcript for one transcript, --company to search by company/domain/person/email. For bounded account-level transcript mention/search questions, set transcriptQuery to search matching transcripts server-side and return coverage counts plus snippets instead of large transcript blobs. For deal, customer, objection, next-step, or deep-dive analysis, set includeTranscripts=true only when you need broad qualitative context rather than a specific term search. For complete account/cohort coverage (call counts, broad cohorts, or when 'no calls mention X' must be defensible), use provider-api-catalog(provider='gong') and provider-corpus-job mode='batch-search' against /calls/transcript after call-id discovery; this action can still enumerate a bounded account/company window with exhaustive=true via after/before.",
+    "Query Gong sales calls, transcripts, and users. Pass --users for user list, --transcript for one transcript, --company to search by company/domain/person/email. For bounded account-level transcript mention/search questions, set transcriptQuery to search matching transcripts server-side and return coverage counts plus snippets instead of large transcript blobs. For deal, customer, objection, next-step, or deep-dive analysis, set includeTranscripts=true only when you need broad qualitative context rather than a specific term search. For an 'all calls' transcript review in a bounded account/date window, use exhaustive=true with after/before and includeTranscripts=true; the action batches transcript retrieval and reports complete/partial coverage instead of forcing one tool call per transcript. For very broad cohorts or defensible absence searches, use provider-api-catalog(provider='gong') and provider-corpus-job mode='batch-search' against /calls/transcript after call-id discovery.",
   schema: z.object({
     users: cliBoolean.optional().describe("Set to true to list Gong users"),
     transcript: z.string().optional().describe("Call ID to get transcript"),
@@ -470,7 +532,7 @@ export default defineAction({
       .max(MAX_TRANSCRIPT_MAX_CHARS)
       .optional()
       .describe(
-        "Maximum transcript characters to return per call (default 8000, max 100000). Use the default for analysis; raise it only when the user asks for more quoted detail.",
+        "Maximum transcript characters to return per call (default 8000, max 100000). Batched results also share a 60000-character aggregate excerpt budget. Use the default for analysis; raise it only when the user asks for more quoted detail.",
       ),
     transcriptQuery: z
       .string()
@@ -490,7 +552,7 @@ export default defineAction({
     exhaustive: cliBoolean
       .optional()
       .describe(
-        "Return EVERY matching call in the window instead of stopping at `limit` — use this for complete cohort/account coverage when 'how many' or absence matters (e.g. scanning all of an account's calls). Returns call metadata only (transcripts are never auto-loaded in this mode, so it stays fast and avoids context bloat); then pull transcripts deliberately with `--transcript=<callId>` or a run-code scan. Always bound it with `after`/`before` or a small `days`: an unbounded exhaustive scan pages the whole Gong org and can hit the function timeout.",
+        "Return EVERY matching call in the window instead of stopping at `limit` — use this for complete cohort/account coverage when 'how many' or absence matters. By default this is metadata-only. With includeTranscripts=true, transcripts are fetched in batches up to transcriptLimit (all matched calls by default when there are 50 or fewer) and explicit coverage is returned. Always bound it with after/before or a small days window: an unbounded exhaustive scan pages the whole Gong org and can hit the function timeout.",
       ),
     after: z
       .string()
@@ -532,21 +594,21 @@ export default defineAction({
       );
       const exhaustive = Boolean(args.exhaustive);
       const fromDateTime = normalizeGongDate(args.after);
-      const toDateTime = normalizeGongDate(args.before);
+      const toDateTime = normalizeGongDate(args.before, "end");
       const result = await searchCalls(args.company, days, limit, {
         exhaustive,
         ...(fromDateTime ? { fromDateTime } : {}),
         ...(toDateTime ? { toDateTime } : {}),
       });
-      // Exhaustive mode is a metadata-only discovery pass: never auto-load
-      // transcripts (that would bloat context and risk the function timeout).
-      // The agent pulls transcripts deliberately afterward (--transcript or a
-      // run-code scan over result.calls).
-      const shouldLoadTranscripts =
-        Boolean(args.includeTranscripts) && !exhaustive;
+      const shouldLoadTranscripts = Boolean(args.includeTranscripts);
       const transcriptLimit = normalizeBoundedInt(
         args.transcriptLimit,
-        DEFAULT_GONG_TRANSCRIPT_LIMIT,
+        exhaustive
+          ? Math.max(
+              1,
+              Math.min(result.calls.length, MAX_GONG_TRANSCRIPT_LIMIT),
+            )
+          : DEFAULT_GONG_TRANSCRIPT_LIMIT,
         1,
         MAX_GONG_TRANSCRIPT_LIMIT,
       );
@@ -557,6 +619,10 @@ export default defineAction({
         1_000,
         MAX_TRANSCRIPT_MAX_CHARS,
       );
+      const boundedTranscriptExcerptMaxChars = boundedTranscriptExcerptChars(
+        transcriptExcerptMaxChars,
+        Math.min(transcriptLimit, result.calls.length),
+      );
       const transcriptSearchMaxChars = normalizeBoundedInt(
         args.transcriptMaxChars,
         transcriptQuery
@@ -583,9 +649,16 @@ export default defineAction({
         ? await loadTranscriptEvidence(
             result.calls,
             transcriptLimit,
-            transcriptExcerptMaxChars,
+            boundedTranscriptExcerptMaxChars,
           )
         : undefined;
+      const transcriptErrors =
+        transcripts?.filter((transcript) => Boolean(transcript.error)) ?? [];
+      const transcriptCoverageComplete = Boolean(
+        transcripts &&
+        transcripts.length >= result.calls.length &&
+        transcriptErrors.length === 0,
+      );
 
       return {
         ...result,
@@ -611,15 +684,29 @@ export default defineAction({
             }
           : {}),
         ...(transcripts ? { transcripts } : {}),
+        ...(transcripts
+          ? {
+              transcriptCoverage: {
+                availableCalls: result.calls.length,
+                inspectedCalls: transcripts.length,
+                successfulCalls: transcripts.length - transcriptErrors.length,
+                errorCount: transcriptErrors.length,
+                coverageComplete: transcriptCoverageComplete,
+                scanLimited: transcripts.length < result.calls.length,
+              },
+            }
+          : {}),
         guidance: [
           transcriptSearch
             ? `Transcript search inspected ${transcriptSearch.inspectedCalls} of ${result.calls.length} matching call(s) for "${transcriptQuery}" and found ${transcriptSearch.matches.length} matching call(s). Use coverageComplete/errors before making absence claims; increase transcriptScanLimit or narrow the window if coverage is incomplete.`
             : "",
           exhaustive
-            ? `Exhaustive discovery: returned all ${result.calls.length} matching call(s) in the window (metadata only). To search transcript content for a term, pull transcripts with --transcript=<callId> or a run-code scan over these call IDs — do not conclude a term is absent from metadata alone.`
+            ? shouldLoadTranscripts
+              ? `Exhaustive discovery returned all ${result.calls.length} matching call(s) in the bounded window before loading transcripts.`
+              : `Exhaustive discovery: returned all ${result.calls.length} matching call(s) in the window (metadata only). Set includeTranscripts=true to fetch the bounded set in batches, or use a provider-corpus job for a broader transcript search.`
             : callLimitGuidance(result.limit, result.truncated),
           shouldLoadTranscripts
-            ? `Loaded transcript excerpts for ${transcripts?.length ?? 0} matching call(s). Ground qualitative claims in the transcript text and cite the inspected call count.`
+            ? `Loaded transcript excerpts for ${transcripts?.length ?? 0} of ${result.calls.length} matching call(s) in batches (${transcriptCoverageComplete ? "complete coverage" : "partial coverage"}). Ground qualitative claims in the transcript text and cite transcriptCoverage; do not fetch these calls again one at a time.`
             : exhaustive
               ? ""
               : "For deep-dive or qualitative analysis, call this action again with includeTranscripts=true before drawing conclusions from call content.",
@@ -651,6 +738,10 @@ export default defineAction({
         1_000,
         MAX_TRANSCRIPT_MAX_CHARS,
       );
+      const boundedTranscriptExcerptMaxChars = boundedTranscriptExcerptChars(
+        transcriptExcerptMaxChars,
+        Math.min(transcriptLimit, limited.calls.length),
+      );
       const transcriptSearchMaxChars = normalizeBoundedInt(
         args.transcriptMaxChars,
         transcriptQuery
@@ -677,7 +768,7 @@ export default defineAction({
         ? await loadTranscriptEvidence(
             limited.calls,
             transcriptLimit,
-            transcriptExcerptMaxChars,
+            boundedTranscriptExcerptMaxChars,
           )
         : undefined;