@agent-native/core-corpus 0.214.0 → 0.217.0

package/corpus/README.md

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

package/corpus/templates/analytics/.agents/skills/actions/references/action-fields.md

@@ -140,6 +140,6 @@ export default defineAction({
 
 When the gate is truthy and the call isn't yet approved, the loop emits an `approval_required` event and **stops the turn — `run()` never executes**. A predicate gates conditionally (e.g. only external recipients) and **fails closed**: a throw is treated as "approval required". It receives its own copy of the prepared snapshot of the validated arguments, defaults applied, and the approval binds to the snapshot's hash, so an approved call runs only with the arguments that were approved (a Date binds by its time). The human approves via the chat UI's Approve affordance, which re-issues the turn with the call's `approvalKey`, and only then does the action run.
 
-Approval is given in the app, so HTTP never grants it. The HTTP action route and the generated Workers entry run a gated call only for the proven app UI (a frontend call from the signed-in user, same origin, holding the short-lived UI capability; `isProvenUiRequest`, the proof `uiOnly` uses) or the app's MCP directory widget. Every other HTTP caller (bearer or API key, MCP OAuth token, org service token, A2A, extension iframe, mobile app) gets `409 approval_required`, and a service identity can never approve. The shared client presents the capability with every write from a signed-in session (minted once per user, reused for nine minutes, never for reads or public pages), so a gated button works on its first request. A call without proof gets `403 ui_capability_required`; the client then re-mints and retries once, which is only the fallback for an expired or rejected capability. Every surface evaluates the gate through `preparedCallNeedsApproval`, so a throwing predicate asks there too. A caller that must run unattended needs a different action, never a bypass of the gate.
+Approval is given in the app, so HTTP never grants it. The HTTP action route and the generated Workers entry run a gated call only for the proven app UI (a frontend call from the signed-in user, same origin, holding the short-lived UI capability; `isProvenUiRequest`, the proof `uiOnly` uses) or the app's MCP directory widget. Every other direct HTTP caller (bearer or API key, MCP OAuth token, org service token, extension iframe, or mobile app) gets `409 approval_required`, and a service identity can never approve. A2A tasks use their separate approval flow. The task pauses until its owner approves, then replays the approved tool call under its approval lease. The shared client presents the capability with every write from a signed-in session (minted once per user, reused for nine minutes, never for reads or public pages), so a gated button works on its first request. A call without proof gets `403 ui_capability_required`; the client then re-mints and retries once, which is only the fallback for an expired or rejected capability. The agent loop, plan mode registry, HTTP action route, generated Workers entry, and MCP dispatch evaluate the gate through `preparedCallNeedsApproval`, so a throwing predicate asks there too. The local `pnpm action ...` CLI calls `handler.run()` directly and does not evaluate `needsApproval`. Treat it as a local development tool, not an approval boundary. A caller that must run unattended needs a different action, never a bypass of the gate.
 
 **Keep approvals rare** — the default is off and almost every action should leave it off. The canonical example is Mail's `send-email` (`needsApproval: true`). See the `security` skill and the Human Approval doc.

package/corpus/templates/analytics/.agents/skills/session-replay/SKILL.md

@@ -302,7 +302,7 @@ agent answers about browser recordings in the Analytics template.
   exist only while the Sessions triage Lab is on.
 - Lab state never holds up the base list. The page waits for it only when the
   URL carries Lab-only conditions (did/didn't events, friction signals or
-  sorts, `slow`), with one wait for all of them, and for at most 5 s; a
+  sorts, `slow`, `unused`), with one wait for all of them, and for at most 5 s; a
   failed or hung read lists sessions without them and says so once, with a
   retry, rather than telling the user to turn on a Lab that may be on.
   Row speed hints load beside the list through `list-session-performance`,
@@ -313,6 +313,66 @@ agent answers about browser recordings in the Analytics template.
   `labStateError`, `frictionError`, and `performanceError` separately; its
   `fullPageAction` asks for both.
 
+## Made It, Didn't Use It
+
+- `OUTPUT_USE_RULES` in `shared/output-use.ts` is the one definition: per
+  app, the output type, the events that make one, and the events that use it,
+  each with a `qualifies` check on its properties. A use counts only for the
+  same `output_id` the making event carried, within `OUTPUT_USE_WINDOW_DAYS`
+  (7). Opening an output never counts; a use shows it to people or takes it out
+  of the app. Slides: `generation_completed` makes a deck;
+  `presentation_ended` with `slides_advanced` ≥ 1 and `duration_ms` ≥
+  `MIN_PRESENTATION_MS` (30 s), or `deck_exported` with `status: "completed"`
+  and `slide_count` ≥ 1, uses it. A missing or non-numeric property never
+  proves a use.
+- Adding an app means adding a rule whose used events need real use and whose
+  making event carries `output_id`. Until then the event catalog flags it: an
+  app with `makesOutputs` (it sent `generation_completed`) and empty
+  `usedItEvents` is a gap, and entries carry `outputRole`. Known holes:
+  shared-audience presentations carry no `output_id`, and HTML export has no
+  completion event.
+- `recordOutputOutcomes` runs in the ingest transaction under a savepoint in
+  every sink mode, so views never read raw events or BigQuery. Each
+  `analytics_output_outcomes` row keeps the earliest making, its session, and
+  the earliest qualifying use; the upsert merges batches in any order. A failed
+  outcome write records the batch's event-time span per tenant in
+  `analytics_output_outcome_gaps`, and so does `recordLostOutputBatch` when
+  ingest fails to store a batch at all (sink lookup, volume limit, raw insert,
+  index), since
+  the tracker does not resend it. An output whose window overlaps a gap is
+  `unmeasured`, never `unused`, since the lost batch could hold its use.
+  Outputs made before the tenant's coverage start are skipped. Before the
+  migration creates `analytics_output_outcome_coverage` (created last), ingest
+  stores events without outcomes, `unused` matches nothing, and coverage is
+  null.
+- `unused` on `list-session-recordings` matches recordings whose own
+  tenant's session made an output whose window has closed unused; a recording
+  shared from another tenant never matches, nor does one a gap overlaps (a
+  lost batch may have held an output it made). It returns the paginated shape
+  with `outputs` and `omittedOutputs` by recording id and
+  `outputCoverageStartedAt`. Statuses are `used`, `unused`, `open` (window
+  still open), and `unmeasured`; `url` is the recording's origin, its
+  `/<app>` workspace mount when its first or last page is under it, and the
+  rule's `outputPath`. Recorded URLs come from the uploader, so `url` is null
+  unless the recording's replay key lists that origin (a key that accepts any
+  origin links nothing) and both pages share it (a real recording never
+  leaves its tab's origin). The app checks access when it opens.
+- `getSessionRecordingOutputs` is the one reader. Per readable recording it
+  gives `[]` for none, null when they are unknown (a recording from another
+  tenant, since a share grants the recording, not its events, one whose
+  tenant has not started output tracking, or one a gap overlaps), and at most `MAX_OUTPUTS_PER_RECORDING`
+  outputs, ranked unused first in SQL so a matched row always lists what it
+  matched on; `omittedOutputs` counts the rest. Ids the viewer cannot read are
+  absent. `list-session-outputs` returns that shape and rejects a failed read.
+  `get-session-replay-summary` and `view-screen` on a replay both use
+  `withSessionsTriage`, which puts one recording's `outputs` (and
+  `omittedOutputs` when some were left out) beside its friction and speed, and
+  returns `outputsError` instead when the read fails or skips the recording.
+- All of it is behind the Sessions triage Lab (`outputs` in its 403). Rows
+  link the first unused output beside the replay link, never inside it, and
+  the replay header lists the recording's outputs with their status and says
+  how many more it left out.
+
 ## Agent Diagnostics Surface
 
 - `buildSessionReplayAgentContext` includes a `diagnostics` section: up to 50

package/corpus/templates/analytics/AGENTS.md

@@ -32,7 +32,7 @@ Use local docs only (no web research): `pnpm action docs-search --query "<topic>
 
 ## Sessions and state
 
-- `list-session-recordings` filters scoped replays. Use `paginated: true` for sorted pages with a real total and app counts. With the Sessions triage Lab, `didEvents` / `didNotEvents` filter tracked events and `slow` filters speed. Get names/counts from `list-session-event-names` and event health from `list-event-catalog`; Analytics' index covers sessions only since its coverage start. Never query BigQuery for these views.
+- `list-session-recordings` filters scoped replays. Use `paginated: true` for sorted pages with a real total and app counts. The Sessions triage Lab adds `didEvents`, `didNotEvents`, `slow`, and `unused` filters. Get names/counts from `list-session-event-names` and event health from `list-event-catalog`; Analytics' index covers sessions only since its coverage start. Never query BigQuery for these views.
 - `navigation` tracks dashboard, analysis, source, chart, and selection. `navigate` opens supported Analytics views, including `sessions`, `event-catalog`, `performance`, `monitoring`, and `agents`. Use `view-screen` when context is unclear.
 - Clicking a panel stages a chat context chip and sets `selected-object` with `type="dashboard-panel"`; read `dashboard-management` for dashboard overview/folder actions.
 

package/corpus/templates/analytics/CHANGELOG.md

@@ -12,6 +12,7 @@ time from the command menu (Cmd+K → "What's new") or from Settings.
 
 ### Fixed
 
+- Session replay quotas count the compressed size Analytics stores, so recordings from other sites no longer use up the daily limit early
 - Preserve unknown replay availability in partial journeys
 
 ## 2026-10-20
@@ -134,6 +135,7 @@ time from the command menu (Cmd+K → "What's new") or from Settings.
 
 ### Added
 
+- Sessions can find people who made a Slides deck but didn't present or export it within 7 days, and the event catalog flags apps with no "used it" event (Sessions triage Lab)
 - A Content dashboard lists every blog article with its author, pageviews, and search clicks, and says when a source failed or isn't set up instead of showing zero
 - Data sources has a Google Search Console card that shows the service account to grant and turns on daily collection
 - Analytics can collect daily GA4 pageviews and Search Console clicks and impressions for each blog article

package/corpus/templates/analytics/actions/get-session-replay-summary.ts

@@ -5,17 +5,9 @@ import {
 } from "@agent-native/core/server";
 import { z } from "zod";
 
-import { listRecordingFriction } from "../server/lib/session-friction.js";
-import {
-  getSessionRecordingPerformance,
-  getSessionReplaySummary,
-} from "../server/lib/session-replay.js";
-import {
-  isSessionsTriageLabEnabled,
-  sessionsTriageReadFailure,
-} from "../server/lib/sessions-triage-lab.js";
-
-const LOG_PREFIX = "[get-session-replay-summary]";
+import { withSessionsTriage } from "../server/lib/session-replay-triage.js";
+import { getSessionReplaySummary } from "../server/lib/session-replay.js";
+import { MAX_OUTPUTS_PER_RECORDING } from "../shared/output-use.js";
 
 function resolveScope() {
   const userEmail = getRequestUserEmail();
@@ -24,8 +16,7 @@ function resolveScope() {
 }
 
 export default defineAction({
-  description:
-    "Get a scoped summary for one first-party Analytics session replay recording. Does not return raw chunks or storage references. With the Sessions triage Lab on it adds `friction`, the object the replay page's Friction tab shows: score, every signal's count (a null part means not measured, not zero), agent failures grouped by cause, and linked Monitoring error issues (null means the links are unknown, [] means none). It also adds `performance`, the recording's speed summary (worst page-view vitals, slowRequests of 1 s or more, maxRequestMs, atLeast, incomplete; null when never measured), and `performanceCoverageStartedAt`. A Lab state, friction, or speed read that fails returns `labStateError`, `frictionError`, or `performanceError` instead.",
+  description: `Get a scoped summary for one first-party Analytics session replay recording. Does not return raw chunks or storage references. With the Sessions triage Lab on it adds \`friction\`, the object the replay page's Friction tab shows: score, every signal's count (a null part means not measured, not zero), agent failures grouped by cause, and linked Monitoring error issues (null means the links are unknown, [] means none). It also adds \`performance\`, the recording's speed summary (worst page-view vitals, slowRequests of 1 s or more, maxRequestMs, atLeast, incomplete; null when never measured), and \`performanceCoverageStartedAt\`. It also adds \`outputs\`, the outputs this session made (such as Slides decks) with status used, unused, open, or unmeasured and a url that opens each, at most ${MAX_OUTPUTS_PER_RECORDING} with unused ones first and \`omittedOutputs\` counting the rest, and \`outputCoverageStartedAt\`. null means they are unknown, not that nothing was made: the recording was shared from another org, whose outputs you cannot read, output tracking has not started for it, or a failed ingest overlapped it and may have dropped an output it made. A Lab state, friction, speed, or outputs read that fails returns \`labStateError\`, \`frictionError\`, \`performanceError\`, or \`outputsError\` instead.`,
   schema: z.object({
     recordingId: z.string().describe("The session_recordings id"),
   }),
@@ -36,57 +27,10 @@ export default defineAction({
   grounding: true,
   run: async (args) => {
     const scope = resolveScope();
-    const summary = await getSessionReplaySummary(args.recordingId, scope);
-    let labEnabled: boolean;
-    try {
-      labEnabled = await isSessionsTriageLabEnabled(
-        scope.userEmail,
-        scope.orgId,
-      );
-    } catch (error) {
-      return {
-        ...summary,
-        labStateError: sessionsTriageReadFailure("labState", LOG_PREFIX, error),
-      };
-    }
-    if (!labEnabled) return summary;
-    const [friction, speed] = await Promise.allSettled([
-      listRecordingFriction(scope, [summary.id]),
-      getSessionRecordingPerformance(scope, [summary.id]),
-    ]);
-    const recordingFriction =
-      friction.status === "fulfilled" ? friction.value[summary.id] : undefined;
-    const recordingSpeed =
-      speed.status === "fulfilled"
-        ? speed.value.performance[summary.id]
-        : undefined;
-    return {
-      ...summary,
-      ...(friction.status === "rejected"
-        ? {
-            frictionError: sessionsTriageReadFailure(
-              "friction",
-              LOG_PREFIX,
-              friction.reason,
-            ),
-          }
-        : recordingFriction
-          ? { friction: recordingFriction }
-          : { frictionError: "Friction read skipped this recording" }),
-      ...(speed.status === "rejected"
-        ? {
-            performanceError: sessionsTriageReadFailure(
-              "speed",
-              LOG_PREFIX,
-              speed.reason,
-            ),
-          }
-        : recordingSpeed !== undefined
-          ? {
-              performance: recordingSpeed,
-              performanceCoverageStartedAt: speed.value.coverageStartedAt,
-            }
-          : { performanceError: "Speed read skipped this recording" }),
-    };
+    return withSessionsTriage(
+      await getSessionReplaySummary(args.recordingId, scope),
+      scope,
+      "[get-session-replay-summary]",
+    );
   },
 });

package/corpus/templates/analytics/actions/list-event-catalog.ts

@@ -49,7 +49,7 @@ async function dataDictionaryDescriptions(
 
 export default defineAction({
   description:
-    "List the events Analytics has received, with each event's app, volume in the range, last-seen time, sample property keys, and Data Dictionary description. Flags apps that send only automatic events and events that stopped firing. Keeps the 1,000 most recently seen events, sorted by volume, and sets truncated when more exist; app flags still count every event in the range. Reads Analytics' own index; Postgres-only, never queries BigQuery. Requires the Sessions triage Lab.",
+    "List the events Analytics has received, with each event's app, volume in the range, last-seen time, sample property keys, and Data Dictionary description. Flags apps that send only automatic events and events that stopped firing. Each app has makesOutputs (it sent generation_completed in the range) and usedItEvents, the events that count as using its output for “made it, didn't use it”; an app that makes outputs with an empty usedItEvents is a catalog gap. Each entry's outputRole says whether that event marks making (made) or using (used) its app's output. Keeps the 1,000 most recently seen events, sorted by volume, and sets truncated when more exist; app flags still count every event in the range. Reads Analytics' own index; Postgres-only, never queries BigQuery. Requires the Sessions triage Lab.",
   schema: z.object({
     from: sessionEventBoundSchema
       .optional()

package/corpus/templates/analytics/actions/list-session-outputs.ts

@@ -0,0 +1,40 @@
+import { defineAction, fail } from "@agent-native/core/action";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { getSessionRecordingOutputs } from "../server/lib/output-outcomes.js";
+import { assertSessionsTriageLabEnabled } from "../server/lib/sessions-triage-lab.js";
+import {
+  MAX_OUTPUTS_PER_RECORDING,
+  OUTPUT_USE_WINDOW_DAYS,
+} from "../shared/output-use.js";
+import { SESSION_PAGE_SIZE } from "../shared/session-page.js";
+
+export default defineAction({
+  description: `The outputs each session recording's session made, such as Slides decks, for the rows of one list page or one replay: outputId, outputType, madeAt, useBy (madeAt plus ${OUTPUT_USE_WINDOW_DAYS} days), status, usedEvent and usedAt when used in time, and url (the app page that opens it, or null unless the recording's replay key lists its origin; the app checks access). Status is used (presented or exported within the window), unused (window closed with no use), open (window still open), or unmeasured (a failed write may have dropped a use). Each recording you can read gets its outputs ([] when it made none), or null when they are unknown: it was shared from another org, whose outputs you cannot read, output tracking has not started for it, or a failed ingest overlapped it and may have dropped an output it made. Ids you cannot read are absent. A recording lists at most ${MAX_OUTPUTS_PER_RECORDING}, unused first, and omittedOutputs counts the rest by recording id. Also returns coverageStartedAt: null means output tracking has not started for the viewer. Requires the Sessions triage Lab.`,
+  schema: z.object({
+    recordingIds: z
+      .array(z.string().min(1).max(200))
+      .max(SESSION_PAGE_SIZE)
+      .default([])
+      .describe(`Recording ids, at most ${SESSION_PAGE_SIZE}: one list page`),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
+  run: async ({ recordingIds }) => {
+    const userEmail = getRequestUserEmail();
+    if (!userEmail) {
+      fail("no authenticated user", {
+        errorCode: "unauthenticated",
+        statusCode: 401,
+      });
+    }
+    const orgId = getRequestOrgId() || null;
+    await assertSessionsTriageLabEnabled(userEmail, orgId, ["outputs"]);
+    return getSessionRecordingOutputs({ userEmail, orgId }, recordingIds);
+  },
+});

package/corpus/templates/analytics/actions/list-session-recordings.ts

@@ -15,6 +15,11 @@ import {
   assertSessionsTriageLabEnabled,
   type SessionsTriageLabFeature,
 } from "../server/lib/sessions-triage-lab.js";
+import {
+  MIN_PRESENTATION_MS,
+  OUTPUT_USE_APPS,
+  OUTPUT_USE_WINDOW_DAYS,
+} from "../shared/output-use.js";
 import { MAX_SESSION_EVENT_CONDITIONS } from "../shared/session-events.js";
 import {
   isSessionFrictionSort,
@@ -120,7 +125,7 @@ export default defineAction({
       .boolean()
       .optional()
       .describe(
-        "Return recordings, total count, and app counts rather than the legacy recordings array. Friction filters and sorts, `slow`, and `includePerformance` always return this shape.",
+        "Return recordings, total count, and app counts rather than the legacy recordings array. Friction filters and sorts, `slow`, `unused`, and `includePerformance` always return this shape.",
       ),
     status: z.enum(["active", "completed"]).optional(),
     didEvents: z
@@ -162,6 +167,12 @@ export default defineAction({
       .describe(
         "Attach each recording's speed summary as performance, plus performanceCoverageStartedAt: worst measured page-view vitals, slowRequests (null when no request was measured), maxRequestMs, atLeast (fields that hit the measurement ceiling, so each is a floor), and incomplete (some measurements failed to save, so it may be slower). performance is null when never measured. Requires the Sessions triage Lab.",
       ),
+    unused: z
+      .enum(OUTPUT_USE_APPS)
+      .optional()
+      .describe(
+        `"Made it, didn't use it": only sessions that made an output of this app and did not use it within ${OUTPUT_USE_WINDOW_DAYS} days. For slides, made = generation_completed for a deck; used = a presentation that moved forward at least one slide and lasted ${MIN_PRESENTATION_MS / 1000} s or more, or a completed export. Opening a deck, a quick present, or a copied share link is not use. Outputs made less than ${OUTPUT_USE_WINDOW_DAYS} days ago never match yet, nor does a session a failed ingest overlapped, whose outputs are unknown. The response adds \`outputs\` (each row's outputs by recording id, with outputId, madeAt, useBy, status used/unused/open/unmeasured, and a url that opens it) and \`outputCoverageStartedAt\`: null means output tracking has not started for the viewer, so read an empty result against it before calling it zero. Requires the Sessions triage Lab.`,
+      ),
     limit: z.coerce.number().int().min(1).max(100).optional().default(50),
   }),
   http: { method: "GET" },
@@ -180,6 +191,7 @@ export default defineAction({
     }
     if (frictionApplied || args.includeFriction) labFeatures.push("friction");
     if (args.slow || args.includePerformance) labFeatures.push("speed");
+    if (args.unused) labFeatures.push("outputs");
     if (labFeatures.length) {
       await assertSessionsTriageLabEnabled(
         scope.userEmail,
@@ -188,10 +200,11 @@ export default defineAction({
       );
     }
     const { includeFriction, ...filters } = args;
-    // The legacy array has no room for the friction or speed coverage start,
-    // and without it an empty match cannot be told apart from "not measured".
+    // The legacy array has no room for a coverage start, and without it an
+    // empty match cannot be told apart from "not measured".
     const coverageNeeded =
-      frictionApplied || Boolean(args.slow || args.includePerformance);
+      frictionApplied ||
+      Boolean(args.slow || args.includePerformance || args.unused);
     if (!args.paginated && !coverageNeeded) {
       const recordings = await listSessionRecordings(scope, filters);
       return includeFriction ? withFriction(scope, recordings) : recordings;

package/corpus/templates/analytics/actions/view-screen.ts

@@ -20,6 +20,7 @@ import { getErrorIssue, listErrorIssues } from "../server/lib/error-capture.js";
 import { listAnalyticsPublicKeys } from "../server/lib/first-party-analytics.js";
 import { openDashboard } from "../server/lib/open-dashboard";
 import { getSessionFrictionDetails } from "../server/lib/session-friction.js";
+import { withSessionsTriage } from "../server/lib/session-replay-triage.js";
 import {
   getSessionRecordingPerformance,
   getSessionReplaySummary,
@@ -38,6 +39,7 @@ import {
 } from "../server/lib/status-pages.js";
 import { getMonitor, listMonitors } from "../server/lib/uptime-monitors.js";
 import { isAnalyticsAskPath } from "../shared/ask-route";
+import { isOutputUseApp, UNUSED_OUTPUT_PARAM } from "../shared/output-use";
 import { sessionDateBound } from "../shared/session-date-bounds";
 import {
   readSessionEventFilters,
@@ -315,9 +317,10 @@ export default defineAction({
         const scope = { userEmail: email, orgId: getRequestOrgId() || null };
         try {
           if (nav?.recordingId) {
-            screen.sessionReplay = await getSessionReplaySummary(
-              nav.recordingId,
+            screen.sessionReplay = await withSessionsTriage(
+              await getSessionReplaySummary(nav.recordingId, scope),
               scope,
+              "[view-screen]",
             );
           } else {
             const params = url?.searchParams ?? {};
@@ -376,8 +379,11 @@ export default defineAction({
             const urlSlow = isSlowSessionFilter(params.slow)
               ? params.slow
               : undefined;
+            const urlUnused = isOutputUseApp(params[UNUSED_OUTPUT_PARAM])
+              ? params[UNUSED_OUTPUT_PARAM]
+              : undefined;
             // Match the page: event conditions, friction filters and sorts,
-            // the slow filter, and row friction and speed hints apply only
+            // the slow and unused filters, and row friction and speed hints apply only
             // with the Lab on. A failed Lab read is reported, and the base
             // list is still read without them.
             let triageLabEnabled = false;
@@ -406,6 +412,7 @@ export default defineAction({
               }
               if (urlFrictionSort) filters.sort = urlFrictionSort;
               if (urlSlow) filters.slow = urlSlow;
+              if (urlUnused) filters.unused = urlUnused;
             }
             const result = await listSessionRecordingsPage(scope, {
               ...filters,
@@ -452,6 +459,16 @@ export default defineAction({
                 ...(speed.status === "fulfilled"
                   ? { performance: speed.value.performance[recording.id] }
                   : {}),
+                ...(result.outputs
+                  ? {
+                      outputs: result.outputs[recording.id],
+                      ...(result.omittedOutputs?.[recording.id]
+                        ? {
+                            omittedOutputs: result.omittedOutputs[recording.id],
+                          }
+                        : {}),
+                    }
+                  : {}),
               }));
             }
             // The URL's sort and Lab conditions are not what was applied
@@ -471,6 +488,9 @@ export default defineAction({
                 filters.frictionSignals;
             }
             if (filters.slow) activeFilters.slow = filters.slow;
+            if (filters.unused) {
+              activeFilters[UNUSED_OUTPUT_PARAM] = filters.unused;
+            }
             if (Object.keys(activeFilters).length > 0) {
               screen.activeFilters = activeFilters;
             }
@@ -496,6 +516,9 @@ export default defineAction({
               ...(performanceCoverageStartedAt !== undefined
                 ? { performanceCoverageStartedAt }
                 : {}),
+              ...(result.outputCoverageStartedAt !== undefined
+                ? { outputCoverageStartedAt: result.outputCoverageStartedAt }
+                : {}),
               ...(urlHasEventConditions && !triageLabEnabled
                 ? { eventConditionsNotApplied: urlEventConditions }
                 : {}),
@@ -511,6 +534,9 @@ export default defineAction({
               ...(urlSlow && !triageLabEnabled
                 ? { slowFilterNotApplied: urlSlow }
                 : {}),
+              ...(urlUnused && !triageLabEnabled
+                ? { unusedFilterNotApplied: urlUnused }
+                : {}),
               truncated:
                 result.recordings.length <
                 Math.min(SESSION_PAGE_SIZE, Math.max(0, result.total - offset)),

package/corpus/templates/analytics/app/i18n/en-US.ts

@@ -1790,6 +1790,10 @@ export default {
     catalogOpenSessions: "Show sessions with {{event}}",
     catalogAutomatic: "Automatic",
     catalogStoppedFiring: "Stopped firing",
+    catalogMadeIt: "Made it",
+    catalogUsedIt: "Used it",
+    catalogNoUsedIt:
+      "“Made it, didn't use it” can't check outputs from {{apps}} because no “used it” event is defined.",
     catalogPropertyKeys: "Property keys",
     catalogMoreKeys: "+{{count}} more",
     catalogTruncated: "Showing only the {{count}} most recently seen events.",
@@ -1803,6 +1807,29 @@ export default {
     speedCoverageStarting: "Speed is measured for page views from now on.",
     speedFilterNeedsLab:
       "This link has a speed filter. Turn on the Sessions triage Lab in Settings to apply it.",
+    unusedOutputs: "Made it, didn't use it",
+    anyOutcome: "Any session",
+    unusedSlidesDecks: "Unused Slides decks",
+    unusedSlidesRule:
+      "Decks made at least {{days}} days ago that weren't presented past the first slide for {{seconds}} s or more, or exported, within {{days}} days. Opening a deck doesn't count.",
+    unusedFilterNeedsLab:
+      "This link has a “made it, didn't use it” filter. Turn on the Sessions triage Lab in Settings to apply it.",
+    outputCoverageSince:
+      "Outputs tracked since {{date}}; unused ones show {{days}} days after they're made.",
+    outputCoverageStarting:
+      "Outputs are tracked from now on; unused ones show {{days}} days after they're made.",
+    openDeck: "Open deck",
+    moreOutputs: "+{{count}} more",
+    deckCount: "{{count}} decks",
+    deckCountSingular: "{{count}} deck",
+    deckMadeOn: "Deck made {{date}}",
+    outputPresentedOn: "Presented {{date}}",
+    outputExportedOn: "Exported {{date}}",
+    outputUsedOn: "Used {{date}}",
+    outputUnused: "Not used within {{days}} days",
+    outputOpen: "Not used yet; counts as unused after {{date}}",
+    outputUnmeasured: "Not measured: some events failed to save",
+    outputsUnavailable: "Couldn't load outputs.",
     slowRequestCount: "{{count}} slow requests",
     slowRequestCountSingular: "{{count}} slow request",
     speedIncomplete: "Speed data incomplete",

package/corpus/templates/analytics/app/pages/sessions/EventCatalogPage.tsx

@@ -82,6 +82,9 @@ export default function EventCatalogPage() {
   const automaticOnlyApps = (data?.apps ?? []).filter(
     (item) => item.onlyAutomaticEvents,
   );
+  const noUsedItApps = (data?.apps ?? [])
+    .filter((item) => item.makesOutputs && !item.usedItEvents.length)
+    .map((item) => item.app || t("sessions.unknownApp"));
   const sessionsHref = `/sessions${
     range !== "30d" || app
       ? `?${new URLSearchParams({
@@ -190,7 +193,7 @@ export default function EventCatalogPage() {
           </Button>
         </div>
 
-        {automaticOnlyApps.length ? (
+        {automaticOnlyApps.length || noUsedItApps.length ? (
           <Alert role="status">
             <IconInfoCircle />
             <AlertDescription>
@@ -201,6 +204,13 @@ export default function EventCatalogPage() {
                   })}
                 </p>
               ))}
+              {noUsedItApps.length ? (
+                <p>
+                  {t("sessions.catalogNoUsedIt", {
+                    apps: noUsedItApps.join(", "),
+                  })}
+                </p>
+              ) : null}
             </AlertDescription>
           </Alert>
         ) : null}
@@ -283,6 +293,13 @@ function CatalogRow({
               {t("sessions.catalogStoppedFiring")}
             </Badge>
           ) : null}
+          {entry.outputRole ? (
+            <Badge variant="outline">
+              {entry.outputRole === "made"
+                ? t("sessions.catalogMadeIt")
+                : t("sessions.catalogUsedIt")}
+            </Badge>
+          ) : null}
         </span>
         {entry.description ? (
           <span className="line-clamp-2 block text-xs text-muted-foreground">

package/corpus/templates/analytics/app/pages/sessions/SessionDetailPage.tsx

@@ -128,6 +128,7 @@ import {
   SessionDevToolsPanel,
 } from "./SessionDevToolsPanel";
 import { SessionFrictionPanel } from "./SessionFriction";
+import { SessionOutputsButton } from "./SessionOutputs";
 import { SessionStartTime } from "./SessionStartTime";
 
 export {
@@ -343,7 +344,8 @@ export default function SessionDetailPage() {
         </div>
         {recording ? (
           <TooltipProvider>
-            <div className="flex shrink-0 items-center gap-2">
+            <div className="flex shrink-0 flex-wrap items-center gap-2">
+              <SessionOutputsButton recordingId={recording.id} />
               <CopySessionForAgentButton recordingId={recording.id} />
               <AskSessionPopover recording={recording} />
               <AgentToggleButton />