@agent-native/core 0.109.1 → 0.109.3

package/corpus/core/src/server/http-response-telemetry.ts

@@ -1,18 +1,58 @@
-import { defineEventHandler, getHeader, getMethod } from "h3";
-import type { EventHandler, H3Event } from "h3";
+import { randomUUID } from "node:crypto";
 
+import {
+  getHeader,
+  getMethod,
+  getResponseStatus,
+  setResponseHeader,
+  setServerTiming,
+} from "h3";
+import type { H3Event } from "h3";
+
+import {
+  claimStartupDatabaseTelemetry,
+  createDatabaseRequestTelemetry,
+  enterDatabaseRequestTelemetry,
+  type DatabaseRequestTelemetry,
+} from "../db/request-telemetry.js";
 import { getDatabaseRuntimeFingerprint } from "../db/runtime-diagnostics.js";
 import { isMcpPublicPath } from "../mcp/route-paths.js";
 import { track } from "../tracking/index.js";
 import { getAppName } from "./app-name.js";
 
 const TELEMETRY_EVENT_NAME = "http.response";
+const REQUEST_ID_HEADER = "x-agent-native-request-id";
 const TRACKING_INGEST_PATHS = new Set([
   "/track",
   "/api/analytics/track",
   "/api/events/track",
   "/_agent-native/track",
 ]);
+const PROCESS_STATE_KEY = Symbol.for(
+  "@agent-native/core/http-response-telemetry.process-state",
+);
+type ProcessTelemetryState = { requestSequence: number };
+type GlobalWithProcessTelemetry = typeof globalThis & {
+  [PROCESS_STATE_KEY]?: ProcessTelemetryState;
+};
+const globalRef = globalThis as GlobalWithProcessTelemetry;
+const processState =
+  globalRef[PROCESS_STATE_KEY] ??
+  (globalRef[PROCESS_STATE_KEY] = { requestSequence: 0 });
+const REQUEST_TELEMETRY_KEY = Symbol.for(
+  "@agent-native/core/http-response-telemetry.request",
+);
+const installedApps = new WeakSet<object>();
+
+interface HttpRequestTelemetryState {
+  startedAt: number;
+  requestId: string;
+  processAgeAtStartMs: number;
+  requestSequence: number;
+  frameworkReadyWaitMs: number;
+  db: DatabaseRequestTelemetry;
+  startupDb?: DatabaseRequestTelemetry;
+}
 
 function envValue(key: string): string | undefined {
   const value = process.env[key]?.trim();
@@ -27,9 +67,9 @@ function boolEnv(key: string): boolean {
 
 function sampleRate(): number {
   const raw = envValue("AGENT_NATIVE_HTTP_TELEMETRY_SAMPLE_RATE");
-  if (!raw) return 1;
+  if (!raw) return 0.1;
   const parsed = Number.parseFloat(raw);
-  if (!Number.isFinite(parsed)) return 1;
+  if (!Number.isFinite(parsed)) return 0.1;
   return Math.max(0, Math.min(1, parsed));
 }
 
@@ -107,31 +147,63 @@ function organizationForHost(host: string | undefined): string | undefined {
     : undefined;
 }
 
-function shouldTrack(pathname: string, statusCode: number): boolean {
+function shouldTrack(
+  pathname: string,
+  statusCode: number,
+  state: HttpRequestTelemetryState,
+): boolean {
   if (shouldDisableTelemetry()) return false;
   if (TRACKING_INGEST_PATHS.has(pathname)) return false;
   if (pathname.startsWith("/api/analytics/replay")) return false;
   if (statusCode >= 500) return true;
+  if (
+    statusCode >= 400 &&
+    statusCode < 500 &&
+    /(?:^|\/)_agent-native\/actions(?:\/|$)/.test(pathname)
+  ) {
+    return true;
+  }
+  if (state.requestSequence === 1) return true;
+  if (state.startupDb) return true;
+  if (Date.now() - state.startedAt >= 1_000) return true;
+  if (state.db.errorCount > 0 || state.db.timeoutCount > 0) {
+    return true;
+  }
   const rate = sampleRate();
   if (rate <= 0) return false;
   if (rate >= 1) return true;
   return Math.random() < rate;
 }
 
-function responseStatusCode(event: H3Event): number {
+function responseStatusCode(event: H3Event, response?: Response): number {
   const raw =
+    response?.status ??
     (event.node?.res as any)?.statusCode ??
     (event.node?.res as any)?.status ??
-    (event as any).res?.status ??
+    getResponseStatus(event) ??
     200;
   const parsed = Number(raw);
   return Number.isFinite(parsed) ? parsed : 200;
 }
 
-function emitTelemetry(event: H3Event, startedAt: number): void {
-  const statusCode = responseStatusCode(event);
+function runtimeProvider(): string {
+  if (process.env.NETLIFY) return "netlify";
+  if (process.env.VERCEL) return "vercel";
+  if (process.env.AWS_LAMBDA_FUNCTION_NAME || process.env.LAMBDA_TASK_ROOT) {
+    return "aws-lambda";
+  }
+  if (process.env.CF_PAGES) return "cloudflare-pages";
+  return "node";
+}
+
+function emitTelemetry(
+  event: H3Event,
+  state: HttpRequestTelemetryState,
+  response?: Response,
+): void {
+  const statusCode = responseStatusCode(event, response);
   const pathname = requestPath(event);
-  if (!shouldTrack(pathname, statusCode)) return;
+  if (!shouldTrack(pathname, statusCode, state)) return;
 
   try {
     const host = hostForEvent(event);
@@ -146,7 +218,17 @@ function emitTelemetry(event: H3Event, startedAt: number): void {
       route_kind: routeKind(pathname),
       status_code: statusCode,
       status_class: statusClass(statusCode),
-      duration_ms: Math.max(0, Date.now() - startedAt),
+      duration_ms: Math.max(0, Date.now() - state.startedAt),
+      request_id: state.requestId,
+      measurement: "nitro_request",
+      cold_start: state.requestSequence === 1,
+      request_sequence: state.requestSequence,
+      process_age_ms: state.processAgeAtStartMs,
+      framework_ready_wait_ms: state.frameworkReadyWaitMs,
+      runtime_provider: runtimeProvider(),
+      function_name: envValue("AWS_LAMBDA_FUNCTION_NAME"),
+      function_memory_mb: envValue("AWS_LAMBDA_FUNCTION_MEMORY_SIZE"),
+      region: envValue("AWS_REGION") ?? envValue("VERCEL_REGION"),
       host,
       environment: envValue("NODE_ENV"),
       deploy_context: envValue("CONTEXT") ?? envValue("VERCEL_ENV"),
@@ -161,34 +243,154 @@ function emitTelemetry(event: H3Event, startedAt: number): void {
       db_url_hash: db.urlHash,
       db_neon_endpoint: db.neon?.endpointId,
       db_neon_pooled: db.neon?.pooled,
+      db_operation_count: state.db.operationCount,
+      db_query_count: state.db.queryCount,
+      db_connect_count: state.db.connectCount,
+      db_retry_count: state.db.retryCount,
+      db_error_count: state.db.errorCount,
+      db_timeout_count: state.db.timeoutCount,
+      db_operation_total_ms: Math.round(state.db.operationTotalMs),
+      db_operation_wall_ms: Math.round(state.db.operationWallMs),
+      db_query_total_ms: Math.round(state.db.queryTotalMs),
+      db_connect_total_ms: Math.round(state.db.connectTotalMs),
+      db_slowest_operation_ms: Math.round(state.db.slowestOperationMs),
+      startup_db_operation_count: state.startupDb?.operationCount,
+      startup_db_query_count: state.startupDb?.queryCount,
+      startup_db_connect_count: state.startupDb?.connectCount,
+      startup_db_retry_count: state.startupDb?.retryCount,
+      startup_db_error_count: state.startupDb?.errorCount,
+      startup_db_timeout_count: state.startupDb?.timeoutCount,
+      startup_db_operation_total_ms: state.startupDb
+        ? Math.round(state.startupDb.operationTotalMs)
+        : undefined,
+      startup_db_operation_wall_ms: state.startupDb
+        ? Math.round(state.startupDb.operationWallMs)
+        : undefined,
+      startup_db_query_total_ms: state.startupDb
+        ? Math.round(state.startupDb.queryTotalMs)
+        : undefined,
+      startup_db_connect_total_ms: state.startupDb
+        ? Math.round(state.startupDb.connectTotalMs)
+        : undefined,
+      startup_db_slowest_operation_ms: state.startupDb
+        ? Math.round(state.startupDb.slowestOperationMs)
+        : undefined,
     });
   } catch {
     // Response telemetry is best-effort. Never perturb request handling.
   }
 }
 
-export function createHttpResponseTelemetryMiddleware(): EventHandler {
-  return defineEventHandler((event) => {
-    const startedAt = Date.now();
-    const res = event.node?.res as
-      | {
-          once?: (event: "finish" | "close", cb: () => void) => void;
-          on?: (event: "finish" | "close", cb: () => void) => void;
-        }
-      | undefined;
-    let emitted = false;
-    const emitOnce = () => {
-      if (emitted) return;
-      emitted = true;
-      emitTelemetry(event, startedAt);
+function requestTelemetryState(
+  event: H3Event,
+): HttpRequestTelemetryState | undefined {
+  return (event.context as Record<PropertyKey, unknown>)[
+    REQUEST_TELEMETRY_KEY
+  ] as HttpRequestTelemetryState | undefined;
+}
+
+function appendServerTiming(
+  response: Response,
+  event: H3Event,
+  name: string,
+  durationMs: number,
+): void {
+  const duration = Math.max(0, Math.round(durationMs));
+  try {
+    response.headers.append("server-timing", `${name};dur=${duration}`);
+  } catch {
+    try {
+      setServerTiming(event, name, { dur: duration });
+    } catch {
+      // Some adapters finalize headers eagerly. Tracking still runs.
+    }
+  }
+}
+
+export function recordFrameworkReadyWait(
+  event: H3Event,
+  durationMs: number,
+): void {
+  const state = requestTelemetryState(event);
+  if (state) {
+    state.frameworkReadyWaitMs += Math.max(0, durationMs);
+    state.startupDb ??= claimStartupDatabaseTelemetry();
+  }
+}
+
+export function installHttpResponseTelemetryHooks(nitroApp: any): void {
+  if (!nitroApp || installedApps.has(nitroApp)) return;
+  const hooks = nitroApp.hooks;
+  if (!hooks?.hook) return;
+  installedApps.add(nitroApp);
+
+  hooks.hook("request", (event: H3Event) => {
+    const state: HttpRequestTelemetryState = {
+      startedAt: Date.now(),
+      requestId: randomUUID(),
+      processAgeAtStartMs: Math.max(0, Math.round(process.uptime() * 1_000)),
+      requestSequence: ++processState.requestSequence,
+      frameworkReadyWaitMs: 0,
+      db: createDatabaseRequestTelemetry(),
     };
+    (event.context as Record<PropertyKey, unknown>)[REQUEST_TELEMETRY_KEY] =
+      state;
+    enterDatabaseRequestTelemetry(state.db);
+  });
 
-    if (typeof res?.once === "function") {
-      res.once("finish", emitOnce);
-      res.once("close", emitOnce);
-    } else if (typeof res?.on === "function") {
-      res.on("finish", emitOnce);
-      res.on("close", emitOnce);
+  hooks.hook("response", (response: Response, event: H3Event) => {
+    const state = requestTelemetryState(event);
+    if (!state) return;
+
+    const durationMs = Math.max(0, Date.now() - state.startedAt);
+    try {
+      response.headers.set(REQUEST_ID_HEADER, state.requestId);
+    } catch {
+      try {
+        setResponseHeader(event, REQUEST_ID_HEADER, state.requestId);
+      } catch {
+        // Some adapters finalize headers eagerly. Tracking still has the id.
+      }
+    }
+    appendServerTiming(response, event, "app", durationMs);
+    if (state.frameworkReadyWaitMs > 0) {
+      appendServerTiming(
+        response,
+        event,
+        "startup",
+        state.frameworkReadyWaitMs,
+      );
     }
+    if (state.db.operationCount > 0) {
+      appendServerTiming(response, event, "db", state.db.operationWallMs);
+      appendServerTiming(
+        response,
+        event,
+        "db-connect",
+        state.db.connectTotalMs,
+      );
+      appendServerTiming(
+        response,
+        event,
+        "db-slowest",
+        state.db.slowestOperationMs,
+      );
+    }
+    if (state.startupDb && state.startupDb.operationCount > 0) {
+      appendServerTiming(
+        response,
+        event,
+        "startup-db",
+        state.startupDb.operationWallMs,
+      );
+      appendServerTiming(
+        response,
+        event,
+        "startup-db-connect",
+        state.startupDb.connectTotalMs,
+      );
+    }
+
+    emitTelemetry(event, state, response);
   });
 }

package/corpus/core/src/templates/workspace-core/.agents/skills/tracking/SKILL.md

@@ -138,6 +138,25 @@ Attribution parsing is fully defensive and never blocks signup — a missing/mal
 Other framework-level baseline events:
 
 - `session status` from `useSession()`, with `signed_in`
+- `action.response` from the browser action transport, with action name,
+  browser-perceived duration and TTFB, response status/outcome, response size
+  when known, and parsed `Server-Timing` phases for framework readiness and
+  database work. Its `request_id` joins the exact browser and server events.
+  This separates server time from CDN/network/body overhead.
+- `http.response` from Nitro request/response hooks, with normalized path,
+  status, request duration, first-request-in-isolate cold marker, process age,
+  framework readiness wait, deploy/runtime fingerprint, database
+  connection/query counts and timings, retries, timeouts, and failures. It also
+  emits `Server-Timing` for `app`, `startup`, `db`, `db-connect`, and
+  `db-slowest` plus an `X-Agent-Native-Request-Id` correlation header where
+  applicable. Query text and parameters are never captured.
+  Database activity that begins during the first two minutes of process/plugin
+  initialization is reported separately as `startup_db_*` on the first
+  framework request that passes the readiness gate.
+  Slow, cold-isolate, server failures, and 4xx action routes are always
+  retained; fast successful requests default to 10% sampling. Override with
+  `AGENT_NATIVE_HTTP_TELEMETRY_SAMPLE_RATE` on the server and
+  `VITE_AGENT_NATIVE_ACTION_TELEMETRY_SAMPLE_RATE` in the browser.
 - `signup` from Better Auth user creation, with `auth_provider`, `auth_user_id`, and first-touch referral attribution (`referral_source`, `referrer_user`, `referral_medium`, `referral_campaign`, `utm_*`, `first_touch_path`, `landing_referrer` — see "Referral / viral attribution" above)
 - `builder connect clicked` and `builder connect popup blocked` from browser Connect Builder CTAs
 - `builder connect started`, `builder connect succeeded`, `builder connect failed`, `builder disconnect succeeded`, and `builder disconnect failed` from the Builder connection routes, with LLM connection context when resolvable

package/corpus/templates/clips/.agents/skills/dictate/SKILL.md

@@ -1,9 +1,9 @@
 ---
 name: dictate
 description: >-
-  The Dictate tab in Clips — press-and-hold dictation history (Hold-Fn / Cmd+Shift+Space),
-  AI cleanup, and the desktop-app integration that captures the audio. Use when listing
-  past dictations, polishing dictation text, or wiring the desktop tray hand-off.
+  The Dictate tab in Clips — press-and-hold desktop dictation, mobile voice
+  dictation, history, AI cleanup, and native capture hand-offs. Use when
+  listing past dictations, polishing dictation text, or wiring native capture.
 ---
 
 # Dictate
@@ -25,7 +25,9 @@ The press-and-hold UX intentionally mirrors **Wispr Flow**. See `templates/clips
 
 ## Data model touched
 
-- **`dictations`** — `id`, `fullText`, `cleanedText`, `durationMs`, `audioUrl`, `source` (`hold-fn` | `hotkey` | `manual`), `createdAt`, `ownableColumns()`.
+- **`dictations`** — `id`, `fullText`, `cleanedText`, `durationMs`, `audioUrl`,
+  `source` (desktop shortcuts, `manual`, or `mobile`), `createdAt`,
+  `ownableColumns()`.
 
 `fullText` is the raw native transcript captured on-device (macOS Speech / Web Speech). `cleanedText` is the optional AI-polished version produced by the shared `cleanup-transcript` pipeline. UI shows `cleanedText ?? fullText`.
 
@@ -81,7 +83,28 @@ The press-and-hold flow is **owned by the desktop app** (`src-tauri/`). On Hold-
 3. The dictation row is created via the framework HTTP layer — the agent does not start/stop dictations.
 4. AI cleanup is a background pass via `cleanup-dictation`, not in the hot path — never block paste-on-release on a network round-trip.
 
-Agents must **never** wire dictation start/stop server-side. The native key listener is the only entry point.
+Agents must **never** wire dictation start/stop server-side. Desktop key
+listeners and the mobile capture UI own those user gestures.
+
+## Mobile dictation
+
+The Agent Native iOS/Android app exposes Dictate from native Home, deep links,
+and OS quick actions. Mobile is click-to-toggle rather than hold-to-talk:
+
+1. `expo-audio` records mic-only M4A and persists it under the app documents
+   directory before any network request.
+2. A durable capture-queue row protects the audio across interruptions, app
+   restarts, and upload failures.
+3. The named mobile voice client posts multipart audio to the authenticated
+   `/_agent-native/transcribe-voice` route. Provider keys never enter the app.
+4. The cleaned transcript is editable, copied to the OS clipboard, and saved
+   with `create-dictation --source=mobile`; edits use `update-dictation`.
+5. The audio also syncs to Clips through the resumable recording upload path so
+   a failed transcription never destroys the captured speech.
+
+Do not auto-send mobile dictation to an agent or another app. iOS/Android quick
+actions open capture; clipboard is the cross-app fallback until platform
+keyboard/accessibility insertion is enabled.
 
 ## UI conventions (don't break)
 

package/corpus/templates/clips/.agents/skills/meetings/SKILL.md

@@ -47,6 +47,13 @@ Meeting capture records **two streams** and tags transcript segments by source:
 
 Each transcript segment carries a `source: "mic" | "system"` tag, which we use to attribute action items to the right attendee. This is why **per-attendee action items only work reliably with mic + system capture** — mic-only recordings make remote attendees silent. Document this caveat whenever you surface action items.
 
+The iOS/Android companion is intentionally different: mobile background meeting
+capture is microphone-only because the operating systems do not expose another
+phone app's Zoom/Meet/Teams audio. It is appropriate for in-person rooms and for
+capturing audio played from a separate device. Mobile recordings still receive
+Clips transcription and summaries, but do not promise desktop-quality remote
+speaker attribution or per-attendee action items.
+
 ## Bidirectional recording ↔ meeting link
 
 A meeting can have an associated recording, and a recording can be linked back to a meeting:

package/corpus/templates/clips/.agents/skills/recording/SKILL.md

@@ -38,6 +38,27 @@ Some recordings are linked to a meeting — when `meeting_id` is non-null on the
    `processing` to `ready`. Do not wait for the upload/finalize response before
    opening the page.
 
+## Mobile companion lifecycle
+
+The Agent Native mobile app uses the same recording rows and binary upload
+routes with native capture primitives:
+
+1. Camera video/import uses `expo-camera` / the system photo picker; meeting
+   audio uses `expo-audio` with background recording enabled.
+2. The native file is copied into the documents directory and a typed
+   AsyncStorage capture job is written before upload starts.
+3. `create-recording` receives a stable client-generated id,
+   `sourceAppName: "Agent Native Mobile"`, and the container MIME type.
+4. Upload reads at most 3 MiB through an Expo FileHandle and persists the next
+   chunk index after every acknowledged POST. The 4 MiB server cap still
+   applies.
+5. Foreground/resume reconciliation polls `/api/uploads/:id/status`; retryable
+   failures back off and never discard the local file. Completion can post a
+   local notification and the recording appears in Clips everywhere.
+
+Mobile audio M4A is an MP4 container and uses the recording route's MP4 MIME
+alias. The bytes are not converted or loaded whole into JavaScript memory.
+
 ## Seekable playback (don't ship raw MediaRecorder output)
 
 Raw `MediaRecorder` files are not friendly to progressive HTTP playback, which
@@ -191,6 +212,8 @@ export function useRecorder() {
 - **Never** start a `MediaRecorder` without a user gesture (or a user-initiated `record-intent`).
 - **Never** re-prompt for permissions on pause/resume — reuse the stream.
 - **Never** fire the upload from the main thread if the chunks are large — prefer a web worker for anything longer than ~60s.
+- **Never** read a complete mobile recording into JavaScript memory. Use bounded
+  FileHandle reads and checkpoint every acknowledged chunk.
 - The `recordings` row must exist **before** the first chunk is sent.
 - On every lifecycle change, write `navigation` → `{ view: "record" }` → `{ view: "recording", recordingId }` so the agent can see what's happening.
 - All AI generated during/after recording goes through the agent chat — see `ai-video-tools`.

package/corpus/templates/clips/AGENTS.md

@@ -51,6 +51,16 @@ Detailed media, meeting, dictation, editing, and sharing rules live in
   `previewTruncated` is true, it may end mid-sentence and does not show where
   transcription ended. Call `get-recording-player-data` before judging
   completeness or quoting the full transcript.
+- Mobile captures originate in the Agent Native iOS/Android app. The phone
+  persists each audio/video file before network work, creates the recording
+  with `sourceAppName: "Agent Native Mobile"`, and resumes bounded chunk
+  uploads from its durable queue. Do not ask users to keep a capture screen
+  open or re-record after a transient upload failure; reconnect Clips and retry
+  the saved job from mobile Home.
+- Mobile meeting capture is microphone-only. It can record an in-person room or
+  audio playing from another device, but iOS and Android do not expose another
+  phone app's Zoom/Meet/Teams call audio to this flow. Do not claim mobile
+  attendee attribution has the desktop mic-plus-system-audio fidelity.
 - Dictation cleanup, Clip title/cleanup, and meeting summaries should pass
   bounded `voiceContext` to the shared cleanup/transcription path when active
   app context, learned vocabulary, user notes, or AGENTS.md preferences are

package/corpus/templates/clips/actions/create-dictation.ts

@@ -1,9 +1,10 @@
 /**
- * Create a dictation row from browser or desktop voice capture.
+ * Create a dictation row from browser, desktop, or mobile voice capture.
  */
 
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
+import { and, eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -11,18 +12,28 @@ import {
   getActiveOrganizationId,
   getCurrentOwnerEmail,
   nanoid,
+  ownerEmailMatches,
 } from "../server/lib/recordings.js";
 
 export default defineAction({
   description:
-    "Create a dictation history row from captured voice text. Used by browser Dictate and desktop voice capture.",
+    "Create a dictation history row from captured voice text. Used by browser, desktop, and mobile voice capture.",
   schema: z.object({
+    id: z.string().min(1).optional().describe("Stable client-generated id"),
     fullText: z.string().min(1).describe("Raw dictation text"),
     cleanedText: z.string().nullable().optional(),
     durationMs: z.coerce.number().int().min(0).optional(),
     audioUrl: z.string().url().nullable().optional(),
     source: z
-      .enum(["fn-hold", "cmd-shift-space", "manual", "other", "fn", "custom"])
+      .enum([
+        "fn-hold",
+        "cmd-shift-space",
+        "manual",
+        "mobile",
+        "other",
+        "fn",
+        "custom",
+      ])
       .default("manual"),
     targetApp: z.string().nullable().optional(),
     startedAt: z.string().datetime().optional(),
@@ -32,10 +43,24 @@ export default defineAction({
     const ownerEmail = getCurrentOwnerEmail();
     const orgId = await getActiveOrganizationId().catch(() => null);
     const now = new Date().toISOString();
-    const id = nanoid();
+    const id = args.id ?? nanoid();
     const fullText = args.fullText.trim();
     if (!fullText) throw new Error("Dictation text is required");
 
+    if (args.id) {
+      const [existing] = await db
+        .select()
+        .from(schema.dictations)
+        .where(
+          and(
+            eq(schema.dictations.id, id),
+            ownerEmailMatches(schema.dictations.ownerEmail, ownerEmail),
+          ),
+        )
+        .limit(1);
+      if (existing) return existing;
+    }
+
     await db.insert(schema.dictations).values({
       id,
       fullText,

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

@@ -1670,7 +1670,7 @@ export default defineAction({
         servedBytes = await verifyServedMediaUrl(upload.url);
       } catch (err) {
         const failureReason = err instanceof Error ? err.message : String(err);
-        return leaveRecordingProcessingForMediaVerification({
+        return await leaveRecordingProcessingForMediaVerification({
           id,
           ownerEmail,
           failureReason,

package/corpus/templates/clips/actions/get-recording-player-data.ts

@@ -29,6 +29,7 @@ import { and, asc, eq, or, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import { isMediaVerificationPending } from "../server/lib/media-verification-state.js";
 import { resolvePlayerVideoUrl } from "../server/lib/player-video-url.js";
 import {
   canOpenDirectRecordingPage,
@@ -178,12 +179,20 @@ export default defineAction({
       access.role === "owner" ||
       access.role === "admin" ||
       access.role === "editor";
-    const [cleanupStateRaw, builderCreditsRaw] = await Promise.all([
-      readAppState(`transcript-cleanup-${args.recordingId}`).catch(() => null),
-      canEditRecording
-        ? readAppState(CLIPS_BUILDER_CREDITS_STATE_KEY).catch(() => null)
-        : Promise.resolve(null),
-    ]);
+    const [cleanupStateRaw, builderCreditsRaw, verificationPending] =
+      await Promise.all([
+        readAppState(`transcript-cleanup-${args.recordingId}`).catch(
+          () => null,
+        ),
+        canEditRecording
+          ? readAppState(CLIPS_BUILDER_CREDITS_STATE_KEY).catch(() => null)
+          : Promise.resolve(null),
+        isMediaVerificationPending({
+          ownerEmail: rec.ownerEmail,
+          recordingId: args.recordingId,
+          recordingStatus: rec.status,
+        }),
+      ]);
     const cleanupState =
       cleanupStateRaw && typeof cleanupStateRaw === "object"
         ? (cleanupStateRaw as Record<string, unknown>)
@@ -326,6 +335,7 @@ export default defineAction({
         hasAudio: Boolean(rec.hasAudio),
         hasCamera: Boolean(rec.hasCamera),
         status: rec.status,
+        verificationPending,
         uploadProgress: rec.uploadProgress,
         failureReason: rec.failureReason,
         // Don't leak the password to clients (especially to MCP hosts that

package/corpus/templates/clips/actions/set-mobile-capture-state.ts

@@ -0,0 +1,40 @@
+import { defineAction } from "@agent-native/core/action";
+import { writeAppState } from "@agent-native/core/application-state";
+import { z } from "zod";
+
+export const MOBILE_CAPTURE_STATE_KEY = "mobile-capture-state";
+
+const mobileCaptureStateSchema = z
+  .object({
+    view: z.enum(["home", "dictate", "meeting", "video", "clips"]),
+    phase: z.enum([
+      "idle",
+      "ready",
+      "recording",
+      "paused",
+      "saving",
+      "processing",
+      "review",
+      "browsing",
+      "playing",
+      "error",
+    ]),
+    captureId: z.string().trim().min(1).max(200).optional(),
+    recordingId: z.string().trim().min(1).max(200).optional(),
+  })
+  .strict();
+
+export default defineAction({
+  description:
+    "Record the privacy-safe view and phase of the Agent Native mobile capture companion.",
+  agentTool: false,
+  schema: mobileCaptureStateSchema,
+  run: async (args) => {
+    const state = {
+      ...args,
+      updatedAt: new Date().toISOString(),
+    };
+    await writeAppState(MOBILE_CAPTURE_STATE_KEY, state);
+    return state;
+  },
+});

package/corpus/templates/clips/actions/update-dictation.ts

@@ -20,7 +20,15 @@ export default defineAction({
     fullText: z.string().optional(),
     cleanedText: z.string().nullable().optional(),
     source: z
-      .enum(["fn-hold", "cmd-shift-space", "manual", "other", "fn", "custom"])
+      .enum([
+        "fn-hold",
+        "cmd-shift-space",
+        "manual",
+        "mobile",
+        "other",
+        "fn",
+        "custom",
+      ])
       .optional(),
     targetApp: z.string().nullable().optional(),
   }),