@agent-native/core 0.115.4 → 0.116.0

package/corpus/templates/clips/actions/export-to-brain.ts

@@ -18,6 +18,7 @@ import { and, asc, eq, gt, gte, isNull, lte, or, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import { writeBrainExportState } from "../server/lib/brain-export-state.js";
 import {
   getActiveOrganizationId,
   getCurrentOwnerEmail,
@@ -232,6 +233,11 @@ async function buildPayload(
       .orderBy(asc(schema.recordingTags.tag)),
   ]);
 
+  const summary = meeting?.summaryMd?.trim();
+  const captureText = summary
+    ? `Summary\n${summary}\n\nTranscript\n${transcriptText}`
+    : transcriptText;
+
   return {
     sourceKey: "clips",
     externalId: `clips:recording:${recording.id}`,
@@ -246,7 +252,7 @@ async function buildPayload(
       meeting?.scheduledStart ||
       recording.createdAt ||
       new Date().toISOString(),
-    transcript: transcriptText,
+    transcript: captureText,
     segments,
     sourceUrl: resolveSourceUrl(recording.id),
     tags: tags.map((row) => row.tag).filter(Boolean),
@@ -346,14 +352,17 @@ async function exportRecording(
   recording: Recording,
   transcript: RecordingTranscript,
   destination: BrainDestination,
+  attempt = 1,
 ): Promise<BrainExportResult> {
   const payload = await buildPayload(recording, transcript);
   if (!payload) {
-    return {
+    const result: BrainExportResult = {
       recordingId: recording.id,
       status: "skipped",
       reason: "empty-transcript",
     };
+    await persistBrainExportResult(result, attempt);
+    return result;
   }
 
   try {
@@ -370,7 +379,9 @@ async function exportRecording(
       },
       { maxRedirects: 0 },
     );
-    return interpretBrainResponse(recording.id, response);
+    const result = await interpretBrainResponse(recording.id, response);
+    await persistBrainExportResult(result, attempt);
+    return result;
   } catch (err) {
     const reason =
       (err as Error)?.name === "TimeoutError" ||
@@ -382,10 +393,65 @@ async function exportRecording(
       reason,
       error: (err as Error)?.message ?? String(err),
     });
-    return { recordingId: recording.id, status: "failed", reason };
+    const result: BrainExportResult = {
+      recordingId: recording.id,
+      status: "failed",
+      reason,
+    };
+    await persistBrainExportResult(result, attempt);
+    return result;
   }
 }
 
+async function persistBrainExportResult(
+  result: BrainExportResult,
+  attempts: number,
+): Promise<void> {
+  const updatedAt = new Date().toISOString();
+  await writeBrainExportState({
+    recordingId: result.recordingId,
+    status: result.status,
+    attempts,
+    updatedAt,
+    ...(result.status === "exported" ? { captureId: result.captureId } : {}),
+    ...(result.status === "quarantined"
+      ? {
+          sensitivityReceiptId: result.sensitivityReceiptId,
+          sensitivityDisposition: result.sensitivityDisposition,
+        }
+      : {}),
+    ...(result.status === "failed"
+      ? {
+          reason: result.reason,
+          nextAttemptAt: new Date(
+            Date.now() +
+              Math.min(15 * 60_000, 30_000 * 2 ** Math.max(0, attempts - 1)),
+          ).toISOString(),
+        }
+      : result.status === "skipped"
+        ? { reason: result.reason }
+        : {}),
+  });
+}
+
+async function persistRetryableBrainExportFailure(
+  recordingId: string,
+  reason: string,
+  attempts: number,
+): Promise<void> {
+  await writeBrainExportState({
+    recordingId,
+    status: "failed",
+    attempts,
+    reason,
+    updatedAt: new Date().toISOString(),
+    nextAttemptAt: new Date(
+      Date.now() +
+        Math.min(15 * 60_000, 30_000 * 2 ** Math.max(0, attempts - 1)),
+    ).toISOString(),
+  });
+}
+
 async function mapWithConcurrency<T, R>(
   values: T[],
   concurrency: number,
@@ -535,6 +601,7 @@ export default defineAction({
       .min(1)
       .max(8)
       .default(DEFAULT_CONCURRENCY),
+    retryAttempt: z.coerce.number().int().min(1).max(8).optional(),
     cursor: z
       .string()
       .min(1)
@@ -552,11 +619,17 @@ export default defineAction({
       );
       const destinationResult = await resolveBrainDestination();
       if (!destinationResult.destination) {
-        return {
+        const result: BrainExportResult = {
           recordingId: args.recordingId,
           status: "skipped" as const,
           reason: destinationResult.reason,
         };
+        await persistRetryableBrainExportFailure(
+          result.recordingId,
+          result.reason,
+          0,
+        );
+        return result;
       }
       const [transcript] = await getDb()
         .select()
@@ -564,16 +637,19 @@ export default defineAction({
         .where(eq(schema.recordingTranscripts.recordingId, args.recordingId))
         .limit(1);
       if (!transcript) {
-        return {
+        const result: BrainExportResult = {
           recordingId: args.recordingId,
           status: "skipped" as const,
           reason: "empty-transcript",
         };
+        await persistBrainExportResult(result, args.retryAttempt ?? 0);
+        return result;
       }
       return exportRecording(
         access.resource as Recording,
         transcript,
         destinationResult.destination,
+        args.retryAttempt ?? 1,
       );
     }
 

package/corpus/templates/clips/actions/request-transcript.ts

@@ -53,6 +53,7 @@ import { and, eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import { writeBrainExportState } from "../server/lib/brain-export-state.js";
 import { dispatchPostFinalizeJob } from "../server/lib/post-finalize-dispatch.js";
 import {
   getCurrentOwnerEmail,
@@ -66,7 +67,6 @@ import {
   parseTranscriptSegments,
 } from "../shared/transcript-segments.js";
 import cleanupTranscript from "./cleanup-transcript.js";
-import exportToBrain from "./export-to-brain.js";
 import { loadAgentsMdContext } from "./lib/agents-md-context.js";
 import {
   AudioOnlyExtractionError,
@@ -309,15 +309,26 @@ function scheduleAutoTranscriptRetry({
   });
 }
 
-function queueBrainExport(recordingId: string): void {
-  void Promise.resolve(exportToBrain.run({ recordingId })).catch(
-    (err: unknown) => {
-      console.warn(
-        `[clips] Brain export skipped for ${recordingId}:`,
-        (err as Error)?.message ?? String(err),
-      );
-    },
-  );
+async function queueBrainExport(recordingId: string): Promise<void> {
+  await writeBrainExportState({
+    recordingId,
+    status: "pending",
+    attempts: 0,
+    updatedAt: new Date().toISOString(),
+    nextAttemptAt: new Date(Date.now() + 60_000).toISOString(),
+  });
+  try {
+    await dispatchPostFinalizeJob({
+      recordingId,
+      kind: "brain-export",
+      requireAccepted: true,
+    });
+  } catch (error) {
+    console.warn(
+      `[clips] Brain export dispatch failed for ${recordingId}:`,
+      error instanceof Error ? error.message : String(error),
+    );
+  }
 }
 
 function verboseTranscriptErrors(): boolean {
@@ -542,7 +553,7 @@ export async function importLoomTranscriptForRecording({
           now,
         });
         await writeAppState("refresh-signal", { ts: Date.now() });
-        queueBrainExport(recordingId);
+        await queueBrainExport(recordingId);
         return {
           recordingId,
           status: "ready" as const,
@@ -955,7 +966,7 @@ async function completeReadyTranscript({
   // (`transcript-cleanup-${recordingId}`) before its next 2s tick lands —
   // otherwise the "Cleaning up…" badge can lag for one full poll interval.
   await writeAppState("refresh-signal", { ts: Date.now() });
-  queueBrainExport(recordingId);
+  await queueBrainExport(recordingId);
 
   return {
     recordingId,
@@ -1385,7 +1396,7 @@ const requestTranscriptAction = defineAction({
           now,
         });
         await writeAppState("refresh-signal", { ts: Date.now() });
-        queueBrainExport(args.recordingId);
+        await queueBrainExport(args.recordingId);
         await clearBuilderCreditsExhausted();
 
         // Re-read title fresh — `rec.title` was fetched before the 30+ s
@@ -1647,7 +1658,7 @@ const requestTranscriptAction = defineAction({
       });
 
       await writeAppState("refresh-signal", { ts: Date.now() });
-      queueBrainExport(args.recordingId);
+      await queueBrainExport(args.recordingId);
 
       // Generate transcript-backed metadata without replacing a human title or
       // description. The title action keeps any local heuristic replaceable

package/corpus/templates/clips/changelog/2026-07-22-clips-transcripts-now-retry-brain-export.md

@@ -0,0 +1,5 @@
+---
+type: improved
+---
+
+Ready clip transcripts now keep an export receipt and retry Brain delivery after temporary failures.

package/corpus/templates/clips/changelog/2026-07-22-german-umlauts-and-other-non-ascii-characters-now-paste-corr.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-22
+---
+
+German umlauts and other non-ASCII characters now paste correctly from macOS dictation

package/corpus/templates/clips/desktop/src-tauri/src/clips/mod.rs

@@ -1854,7 +1854,21 @@ mod tests {
 
     #[cfg(target_os = "macos")]
     mod macos_only {
-        use super::super::chunk_graphemes_by_utf16_units;
+        use super::super::{chunk_graphemes_by_utf16_units, utf8_pasteboard_command};
+        use std::ffi::OsStr;
+
+        #[test]
+        fn pasteboard_commands_force_utf8_for_gui_launches() {
+            let command = utf8_pasteboard_command("pbcopy");
+            let env_value = |key: &str| {
+                command
+                    .get_envs()
+                    .find(|(name, _)| *name == OsStr::new(key))
+                    .and_then(|(_, value)| value)
+            };
+            assert_eq!(env_value("LANG"), Some(OsStr::new("en_US.UTF-8")));
+            assert_eq!(env_value("LC_ALL"), Some(OsStr::new("en_US.UTF-8")));
+        }
 
         #[test]
         fn never_splits_a_zwj_family_emoji_across_chunks() {
@@ -1892,9 +1906,18 @@ mod tests {
     }
 }
 
+#[cfg(target_os = "macos")]
+fn utf8_pasteboard_command(program: &str) -> Command {
+    let mut command = Command::new(program);
+    command
+        .env("LANG", "en_US.UTF-8")
+        .env("LC_ALL", "en_US.UTF-8");
+    command
+}
+
 #[cfg(target_os = "macos")]
 fn write_clipboard(text: &str) -> Result<(), String> {
-    let mut child = Command::new("pbcopy")
+    let mut child = utf8_pasteboard_command("pbcopy")
         .stdin(Stdio::piped())
         .spawn()
         .map_err(|e| format!("pbcopy spawn: {e}"))?;
@@ -1926,7 +1949,7 @@ fn write_clipboard(_text: &str) -> Result<(), String> {
 /// content on the clipboard are not preserved by the later restore.
 #[cfg(target_os = "macos")]
 fn read_clipboard() -> Option<String> {
-    let out = Command::new("pbpaste").output().ok()?;
+    let out = utf8_pasteboard_command("pbpaste").output().ok()?;
     if !out.status.success() {
         return None;
     }

package/corpus/templates/clips/jobs/emit-netlify-brain-export-cron.ts

@@ -0,0 +1,118 @@
+#!/usr/bin/env tsx
+
+import { randomBytes } from "node:crypto";
+import { cpSync, existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const FUNCTIONS_DIR = path.join(ROOT, ".netlify", "functions-internal");
+const SERVER_DIR = path.join(FUNCTIONS_DIR, "server");
+export const SCHEDULED_NAME = "clips-brain-export-cron";
+export const WORKER_NAME = "clips-brain-export-sweep-background";
+export const ROUTE_PATH = "/api/clips/brain-export/run";
+export const SCHEDULE = "* * * * *";
+
+function ensureDir(dir: string) {
+  mkdirSync(dir, { recursive: true });
+}
+
+export function scheduledTriggerSource(token: string) {
+  return `const WORKER_PATH = "/.netlify/functions/${WORKER_NAME}";
+const CRON_TOKEN = ${JSON.stringify(token)};
+
+export default async function handler(request) {
+  const response = await fetch(new URL(WORKER_PATH, new URL(request.url).origin), {
+    method: "POST",
+    headers: { "content-type": "application/json", "x-agent-native-clips-brain-export-cron": CRON_TOKEN },
+    body: JSON.stringify({ scheduled: true }),
+  });
+  if (!response.ok && response.status !== 202) console.error("[clips-brain-export-cron] Background sweep trigger failed:", response.status);
+}
+
+export const config = {
+  name: "Clips Brain export cron trigger",
+  generator: "agent-native clips build",
+  schedule: ${JSON.stringify(SCHEDULE)},
+};
+`;
+}
+
+export function backgroundWorkerSource(token: string) {
+  return `globalThis.__AGENT_NATIVE_CLIPS_BRAIN_EXPORT_SCHEDULED_RUNTIME__ = true;
+const CRON_TOKEN = ${JSON.stringify(token)};
+const ROUTE_PATH = ${JSON.stringify(ROUTE_PATH)};
+let cachedHandler;
+
+function timingSafeEquals(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i += 1) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+
+export default async function handler(request, context) {
+  const token = request.headers.get("x-agent-native-clips-brain-export-cron") || "";
+  if (!timingSafeEquals(token, CRON_TOKEN)) return new Response("Unauthorized", { status: 401 });
+  cachedHandler ??= (await import("./main.mjs")).default;
+  const url = new URL(request.url);
+  url.pathname = ROUTE_PATH;
+  url.search = "";
+  return cachedHandler(new Request(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ scheduled: true }),
+  }), context);
+}
+
+export const config = {
+  name: "Clips Brain export background sweep",
+  generator: "agent-native clips build",
+  background: true,
+  nodeBundler: "none",
+  includedFiles: ["**"],
+  preferStatic: false,
+};
+`;
+}
+
+export function emitNetlifyBrainExportCron(
+  options: {
+    functionsDir?: string;
+    serverDir?: string;
+    token?: string;
+  } = {},
+) {
+  const functionsDir = options.functionsDir ?? FUNCTIONS_DIR;
+  const serverDir = options.serverDir ?? SERVER_DIR;
+  if (!existsSync(serverDir))
+    throw new Error(
+      "Expected Nitro Netlify server output before emitting Clips Brain export functions.",
+    );
+  const token = options.token ?? randomBytes(32).toString("hex");
+  const scheduledDir = path.join(functionsDir, SCHEDULED_NAME);
+  const workerDir = path.join(functionsDir, WORKER_NAME);
+  rmSync(scheduledDir, { recursive: true, force: true });
+  rmSync(workerDir, { recursive: true, force: true });
+  ensureDir(scheduledDir);
+  cpSync(serverDir, workerDir, { recursive: true });
+  rmSync(path.join(workerDir, "server.mjs"), { force: true });
+  writeFileSync(
+    path.join(scheduledDir, `${SCHEDULED_NAME}.mjs`),
+    scheduledTriggerSource(token),
+  );
+  writeFileSync(
+    path.join(workerDir, `${WORKER_NAME}.mjs`),
+    backgroundWorkerSource(token),
+  );
+}
+
+if (
+  process.argv[1] &&
+  path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+) {
+  emitNetlifyBrainExportCron();
+  console.log(
+    "[clips-brain-export-cron] Emitted scheduled export sweep and background worker.",
+  );
+}

package/corpus/templates/clips/netlify.toml

@@ -1,6 +1,6 @@
 [build]
 ignore = "node ./scripts/netlify-ignore-build.mjs clips"
-command = "export DATABASE_URL=${NETLIFY_DATABASE_URL:-$DATABASE_URL} && pnpm install && NITRO_PRESET=netlify pnpm --filter clips build"
+command = "export DATABASE_URL=${NETLIFY_DATABASE_URL:-$DATABASE_URL} && pnpm install && NITRO_PRESET=netlify pnpm --filter clips build && pnpm exec tsx templates/clips/jobs/emit-netlify-brain-export-cron.ts"
 publish = "templates/clips/dist"
 functions = "templates/clips/.netlify/functions-internal"
 
@@ -25,3 +25,6 @@ AGENT_NATIVE_SERVERLESS_FFMPEG_ARCH = "x64"
 # auto-continuation path can hand off before Netlify kills the function.
 [functions."*"]
 timeout = 75
+
+[functions.clips-brain-export-sweep-background]
+timeout = 120

package/corpus/templates/clips/scripts/configure-prod-brain-export.ts

@@ -0,0 +1,92 @@
+import { readFile } from "node:fs/promises";
+
+import { writeAppState } from "@agent-native/core/application-state";
+import { saveCredential } from "@agent-native/core/credentials";
+import { getDbExec } from "@agent-native/core/db";
+import { runWithRequestContext } from "@agent-native/core/server";
+
+const tokenFile = process.env.BRAIN_CLIPS_TOKEN_FILE;
+if (!tokenFile) throw new Error("BRAIN_CLIPS_TOKEN_FILE is required");
+const token = (await readFile(tokenFile, "utf8")).trim();
+if (!token.startsWith("brain_") || token.length < 32) {
+  throw new Error("The Brain ingest token is invalid");
+}
+
+const db = getDbExec();
+const { rows } = await db.execute({
+  sql: `SELECT id, owner_email, org_id, created_at
+    FROM recordings
+    WHERE status = ? AND trashed_at IS NULL AND created_at >= ?
+      AND EXISTS (
+        SELECT 1 FROM recording_transcripts
+        WHERE recording_transcripts.recording_id = recordings.id
+          AND recording_transcripts.status = ?
+          AND LENGTH(TRIM(COALESCE(recording_transcripts.full_text, ''))) > 0
+      )
+    ORDER BY created_at DESC
+    LIMIT ?`,
+  args: [
+    "ready",
+    new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString(),
+    "ready",
+    20,
+  ],
+});
+if (rows.length === 0)
+  throw new Error("No recent ready Clips recordings found");
+
+const recordings = rows as Array<{
+  id: string;
+  owner_email: string;
+  org_id?: string | null;
+}>;
+const ownerEmail = recordings[0]!.owner_email;
+const orgId = recordings[0]!.org_id?.trim();
+if (!ownerEmail || !orgId) {
+  throw new Error(
+    "Recent Clips recordings are missing owner or organization scope",
+  );
+}
+if (
+  recordings.some(
+    (recording) =>
+      recording.owner_email !== ownerEmail ||
+      recording.org_id?.trim() !== orgId,
+  )
+) {
+  throw new Error(
+    "Recent Clips recordings span multiple owners or organizations",
+  );
+}
+
+await saveCredential(
+  "BRAIN_INGEST_URL",
+  "https://brain.agent-native.com/api/_agent-native/brain/ingest",
+  { userEmail: ownerEmail, orgId, scope: "org" },
+);
+await saveCredential("BRAIN_INGEST_TOKEN", token, {
+  userEmail: ownerEmail,
+  orgId,
+  scope: "org",
+});
+
+await runWithRequestContext({ userEmail: ownerEmail, orgId }, async () => {
+  const now = new Date().toISOString();
+  for (const recording of recordings) {
+    await writeAppState(`clips-brain-export-${recording.id}`, {
+      recordingId: recording.id,
+      status: "pending",
+      attempts: 0,
+      updatedAt: now,
+      nextAttemptAt: now,
+    });
+  }
+});
+
+console.log(
+  JSON.stringify({
+    configured: true,
+    queued: recordings.length,
+    organizationScoped: true,
+  }),
+);