recappi 0.1.74 → 0.1.76

package/dist/index.js

@@ -1252,7 +1252,7 @@ function RecordingDetailView({
       scrollable ? " \xB7 \u2191\u2193 scroll" : "",
       ready ? " \xB7 " : "",
       `o open \xB7 d download \xB7 f finder`,
-      " \xB7 T re-transcribe \xB7 s re-summarize",
+      " \xB7 T re-transcribe \xB7 s re-summarize \xB7 e export",
       item.activeTranscriptId ? " \xB7 t full" : "",
       links.webUrl ? " \xB7 w web" : "",
       " \xB7 r refresh \xB7 esc back"
@@ -2005,6 +2005,9 @@ function AppShell({
   transcribeRecordingArtifact,
   onRetranscribe,
   onResummarize,
+  onSyncRecordingText,
+  onSyncRecordingAudio,
+  onExportRecording,
   initialView = "overview",
   openUrl: openUrl2,
   copyText: copyText2,
@@ -2458,6 +2461,54 @@ function AppShell({
     },
     [onResummarize, refresh, recordings, now, refetchTranscript]
   );
+  const syncedTextRef = useRef3(/* @__PURE__ */ new Set());
+  const syncRecordingText2 = useCallback(
+    async (recordingId, opts = {}) => {
+      if (!onSyncRecordingText) return;
+      if (opts.manual) setNotice("Syncing text locally\u2026");
+      try {
+        const data = await onSyncRecordingText(recordingId);
+        syncedTextRef.current.add(recordingId);
+        if (opts.manual) setNotice(`Text synced \xB7 ${data.sessionDir}`);
+      } catch (error51) {
+        if (opts.manual) setNotice(transcribeHandoffErrorCopy(error51));
+      }
+    },
+    [onSyncRecordingText]
+  );
+  const syncRecordingAudio2 = useCallback(
+    async (recordingId) => {
+      if (!onSyncRecordingAudio) {
+        setNotice("Audio sync is not available in this CLI session.");
+        return;
+      }
+      setNotice("Downloading audio\u2026");
+      try {
+        const data = await onSyncRecordingAudio(recordingId);
+        setNotice(`Audio saved \xB7 ${data.audioPath}`);
+      } catch (error51) {
+        setNotice(transcribeHandoffErrorCopy(error51));
+      }
+    },
+    [onSyncRecordingAudio]
+  );
+  const exportRecordingForAgent = useCallback(
+    async (recordingId) => {
+      if (!onExportRecording) {
+        setNotice("Export is not available in this CLI session.");
+        return;
+      }
+      setNotice("Exporting\u2026");
+      try {
+        const data = await onExportRecording(recordingId);
+        copyText2?.(data.textPath);
+        setNotice(`Exported \xB7 ${data.textPath} (path copied)`);
+      } catch (error51) {
+        setNotice(transcribeHandoffErrorCopy(error51));
+      }
+    },
+    [onExportRecording, copyText2]
+  );
   useEffect4(() => {
     if (liveRecord?.kind !== "stopped") return;
     const artifact = liveRecord.artifact;
@@ -2602,6 +2653,11 @@ function AppShell({
       cancelled = true;
     };
   }, [detailTranscriptId, fetchTranscript]);
+  const detailRecordingId = screen.kind === "recordingDetail" ? screen.recordingId : void 0;
+  useEffect4(() => {
+    if (!detailRecordingId || syncedTextRef.current.has(detailRecordingId)) return;
+    void syncRecordingText2(detailRecordingId);
+  }, [detailRecordingId, syncRecordingText2]);
   const setAudio = (recordingId, action) => setAudioCache((m) => new Map(m).set(recordingId, action));
   const runAudio = useCallback(
     async (recordingId, mode) => {
@@ -2708,6 +2764,7 @@ function AppShell({
       if (screen.kind === "recordingDetail") {
         const detailRec = recordings.find((r) => r.recordingId === screen.recordingId);
         if (detailRec?.activeTranscriptId) refetchTranscript(detailRec.activeTranscriptId);
+        void syncRecordingText2(screen.recordingId, { manual: true });
       }
       return;
     }
@@ -2750,10 +2807,13 @@ function AppShell({
       const links = rec ? resolveRecordingLinks(rec.recordingId, rec.origin) : {};
       if (input === "T" && rec) void retranscribeExistingRecording(rec.recordingId);
       else if ((input === "s" || input === "S") && rec) void resummarizeExistingRecording(rec.recordingId);
+      else if (input === "e" && rec) void exportRecordingForAgent(rec.recordingId);
       else if (input === "t" && rec?.activeTranscriptId) void openTranscript(rec.activeTranscriptId);
       else if (input === "o" && rec) void runAudio(rec.recordingId, "open");
-      else if (input === "d" && rec) void runAudio(rec.recordingId, "download");
-      else if (input === "f" && rec) void runAudio(rec.recordingId, "finder");
+      else if (input === "d" && rec) {
+        if (onSyncRecordingAudio) void syncRecordingAudio2(rec.recordingId);
+        else void runAudio(rec.recordingId, "download");
+      } else if (input === "f" && rec) void runAudio(rec.recordingId, "finder");
       else if (input === "w" && links.webUrl) openUrl2?.(links.webUrl);
       else if (input === "c" && links.webUrl) {
         copyText2?.(links.webUrl);
@@ -3001,6 +3061,9 @@ async function runDashboard(deps) {
       transcribeRecordingArtifact: deps.transcribeRecordingArtifact,
       onRetranscribe: deps.retranscribeRecording,
       onResummarize: deps.resummarizeRecording,
+      onSyncRecordingText: deps.syncRecordingText,
+      onSyncRecordingAudio: deps.syncRecordingAudio,
+      onExportRecording: deps.exportRecording,
       initialView: deps.initialView ?? "overview",
       openUrl,
       copyText
@@ -3028,7 +3091,7 @@ var init_tui = __esm({
 
 // src/cli.ts
 import { Command, CommanderError, InvalidArgumentError } from "commander/esm.mjs";
-import os5 from "os";
+import os6 from "os";
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -3796,10 +3859,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path6) {
-  if (!path6)
+function getElementAtPath(obj, path7) {
+  if (!path7)
     return obj;
-  return path6.reduce((acc, key) => acc?.[key], obj);
+  return path7.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -4208,11 +4271,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path6, issues) {
+function prefixIssues(path7, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path6);
+    iss.path.unshift(path7);
     return iss;
   });
 }
@@ -4359,16 +4422,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path6 = []) => {
+  const processError = (error52, path7 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path6, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -4395,17 +4458,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path6 = []) => {
+  const processError = (error52, path7 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
       } else {
-        const fullpath = [...path6, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -4437,8 +4500,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path6) {
+  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path7) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -17130,13 +17193,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path6 = ref.slice(1).split("/").filter(Boolean);
-  if (path6.length === 0) {
+  const path7 = ref.slice(1).split("/").filter(Boolean);
+  if (path7.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path6[0] === defsKey) {
-    const key = path6[1];
+  if (path7[0] === defsKey) {
+    const key = path7[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -18139,6 +18202,31 @@ var transcriptDataSchema = external_exports.object({
   segments: external_exports.array(transcriptSegmentSchema),
   summary: transcriptSummarySchema
 });
+var recordingExportDataSchema = external_exports.object({
+  origin: external_exports.string(),
+  recordingId: external_exports.string(),
+  exportDir: external_exports.string(),
+  textPath: external_exports.string(),
+  manifestPath: external_exports.string(),
+  remoteManifestPath: external_exports.string(),
+  sessionMetadataPath: external_exports.string(),
+  recordingJsonPath: external_exports.string(),
+  subscriptionPath: external_exports.string(),
+  subscriptionJsonPath: external_exports.string(),
+  audioPath: external_exports.string(),
+  transcriptId: external_exports.string().nullable().optional(),
+  transcriptPath: external_exports.string().optional(),
+  transcriptJsonPath: external_exports.string().optional(),
+  summaryPath: external_exports.string().optional(),
+  summaryJsonPath: external_exports.string().optional(),
+  actionItemsPath: external_exports.string().optional(),
+  summaryStatus: summaryStatusSchema.optional(),
+  audio: external_exports.object({
+    contentType: external_exports.string().optional(),
+    contentLength: external_exports.number().int().nonnegative().optional(),
+    reused: external_exports.boolean().optional()
+  }).optional()
+});
 var doctorCheckStatusSchema = external_exports.enum(["ok", "warn", "error"]);
 var doctorCheckSchema = external_exports.object({
   name: external_exports.string(),
@@ -19401,7 +19489,10 @@ var RecappiApiClient = class {
     const contentLength = numberHeader(response.headers.get("content-length"));
     const dir = opts.directory ?? await fs3.mkdtemp(path4.join(os4.tmpdir(), "recappi-cli-audio-"));
     if (opts.directory) await fs3.mkdir(dir, { recursive: true });
-    const filePath = path4.join(dir, recordingAudioFileName(recordingId, opts.title, contentType));
+    const filePath = path4.join(
+      dir,
+      recordingAudioFileName(recordingId, opts.title, contentType, opts.filenameStem)
+    );
     try {
       await pipeline(
         Readable.fromWeb(response.body),
@@ -19700,12 +19791,12 @@ var RecappiApiClient = class {
       } : {}
     };
   }
-  async getJson(path6) {
-    const response = await this.request("GET", path6);
+  async getJson(path7) {
+    const response = await this.request("GET", path7);
     return await parseJson(response);
   }
-  async postJson(path6, body) {
-    const response = await this.request("POST", path6, JSON.stringify(body), {
+  async postJson(path7, body) {
+    const response = await this.request("POST", path7, JSON.stringify(body), {
       headers: { "content-type": "application/json" }
     });
     return await parseJson(response);
@@ -19799,7 +19890,10 @@ function audioExtensionForContentType(contentType) {
       return "wav";
   }
 }
-function recordingAudioFileName(recordingId, title, contentType) {
+function recordingAudioFileName(recordingId, title, contentType, filenameStem) {
+  if (filenameStem && filenameStem.trim()) {
+    return `${truncateFileStem(safeFileStem(filenameStem), 96)}.${audioExtensionForContentType(contentType)}`;
+  }
   const idStem = truncateFileStem(safeFileStem(recordingId), 48);
   const titleStem = title ? truncateFileStem(safeFileStem(title), 80) : "";
   const stem = titleStem ? `${titleStem}-${idStem}` : idStem;
@@ -20093,7 +20187,7 @@ import { promises as fs4 } from "fs";
 import path5 from "path";
 function createRecordingAudioRuntime(client, deps = {}) {
   const downloadRecordingAudioFile = async (recordingId, opts) => {
-    const cached2 = await findReusableDownload(recordingId, deps);
+    const cached2 = opts?.directory ? null : await findReusableDownload(recordingId, deps);
     if (cached2) return cached2;
     const directory = opts?.directory ?? (deps.account ? defaultDownloadDirectory(deps) : void 0);
     const download = await client.downloadRecordingAudio(recordingId, {
@@ -20249,6 +20343,7 @@ var COMMON_TASKS = [
   { label: "Transcribe a local file", command: "recappi upload <file> --transcribe --wait" },
   { label: "Re-transcribe a recording", command: "recappi recordings retranscribe <recordingId> --wait" },
   { label: "Re-summarize a recording", command: "recappi recordings resummarize <recordingId>" },
+  { label: "Export recording bundle", command: "recappi recordings export <recordingId> --dir ./bundle" },
   { label: "List / find recordings", command: "recappi recordings list" },
   { label: "Read a transcript", command: "recappi transcript get <transcriptId>" },
   { label: "Download / open audio", command: "recappi audio <recordingId> --open" },
@@ -20355,7 +20450,24 @@ var COMMAND_METADATA = {
   "recordings get": {
     capabilities: ["Fetch one recording's metadata and status by id"],
     examples: [{ description: "Fetch one recording", command: "recappi recordings get <recordingId>" }],
-    relatedCommands: ["recordings list", "transcript get", "audio"]
+    relatedCommands: ["recordings list", "recordings export", "transcript get", "audio"]
+  },
+  "recordings export": {
+    capabilities: [
+      "Write a plain-text Markdown handoff file for agents",
+      "Export raw audio, transcript, summary, action items, subscription/account data, and JSON sidecars"
+    ],
+    examples: [
+      {
+        description: "Export a recording bundle into a chosen directory",
+        command: "recappi recordings export <recordingId> --dir ./recappi-export"
+      },
+      {
+        description: "Export and return machine-readable paths",
+        command: "recappi recordings export <recordingId> --json --compact"
+      }
+    ],
+    relatedCommands: ["recordings get", "transcript get", "audio", "account status"]
   },
   "recordings list": {
     capabilities: ["List recent recordings", "Search recordings and transcripts", "Find a recordingId"],
@@ -20363,7 +20475,7 @@ var COMMAND_METADATA = {
       { description: "List recent recordings", command: "recappi recordings list" },
       { description: "Search recordings and transcripts", command: "recappi recordings list --search <query>" }
     ],
-    relatedCommands: ["recordings get", "audio", "transcript get"]
+    relatedCommands: ["recordings get", "recordings export", "audio", "transcript get"]
   },
   "recordings retranscribe": {
     capabilities: ["Re-transcribe an existing recording", "Re-transcribe with new language/prompt/scene/model"],
@@ -20440,6 +20552,408 @@ ${lines.join("\n")}
 ` : "";
 }
 
+// src/export.ts
+import { promises as fs5 } from "fs";
+import os5 from "os";
+import path6 from "path";
+async function syncRecordingText(opts) {
+  const context = await loadRecordingBundleContext(opts);
+  const sessionDir = await resolveRecordingSessionDir(context.recording, opts);
+  return writeRecordingTextFiles(context, sessionDir, {
+    now: opts.now
+  });
+}
+async function syncRecordingAudio(opts) {
+  const context = await loadRecordingBundleContext(opts);
+  const sessionDir = await resolveRecordingSessionDir(context.recording, opts);
+  const audio = await downloadRecordingAudioToDir(context.recording, opts.recordingAudio, sessionDir);
+  const text = await writeRecordingTextFiles(context, sessionDir, {
+    now: opts.now,
+    uploadFilename: path6.basename(audio.localPath)
+  });
+  return { ...text, audioPath: audio.localPath, audio: audioMetadata(audio) };
+}
+async function exportRecording(opts) {
+  const context = await loadRecordingBundleContext(opts);
+  const exportDir = await resolveRecordingSessionDir(context.recording, opts);
+  const audio = await downloadRecordingAudioToDir(context.recording, opts.recordingAudio, exportDir);
+  const textFiles = await writeRecordingTextFiles(context, exportDir, {
+    now: opts.now,
+    uploadFilename: path6.basename(audio.localPath)
+  });
+  const { recording, subscription, transcript } = context;
+  const subscriptionPath = path6.join(exportDir, "subscription.md");
+  const subscriptionJsonPath = path6.join(exportDir, "subscription.json");
+  await fs5.writeFile(subscriptionPath, renderSubscriptionMarkdown(subscription), "utf8");
+  await writeJson(subscriptionJsonPath, subscription);
+  const textPath = path6.join(exportDir, "handoff.md");
+  const manifestPath = path6.join(exportDir, "manifest.json");
+  const data = recordingExportDataSchema.parse({
+    origin: recording.origin,
+    recordingId: recording.recordingId,
+    exportDir,
+    textPath,
+    manifestPath,
+    remoteManifestPath: textFiles.remoteManifestPath,
+    sessionMetadataPath: textFiles.sessionMetadataPath,
+    recordingJsonPath: textFiles.recordingJsonPath,
+    subscriptionPath,
+    subscriptionJsonPath,
+    audioPath: audio.localPath,
+    ...textFiles.transcriptId !== void 0 ? { transcriptId: textFiles.transcriptId } : {},
+    ...textFiles.transcriptPath ? { transcriptPath: textFiles.transcriptPath } : {},
+    ...textFiles.transcriptJsonPath ? { transcriptJsonPath: textFiles.transcriptJsonPath } : {},
+    ...textFiles.summaryPath ? { summaryPath: textFiles.summaryPath } : {},
+    ...textFiles.summaryJsonPath ? { summaryJsonPath: textFiles.summaryJsonPath } : {},
+    ...textFiles.actionItemsPath ? { actionItemsPath: textFiles.actionItemsPath } : {},
+    ...textFiles.summaryStatus ? { summaryStatus: textFiles.summaryStatus } : {},
+    audio: audioMetadata(audio)
+  });
+  await fs5.writeFile(
+    textPath,
+    renderHandoffMarkdown(recording, subscription, audio, data, transcript),
+    "utf8"
+  );
+  await writeJson(manifestPath, {
+    exportedAt: (opts.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+    command: "recordings export",
+    data
+  });
+  return data;
+}
+async function loadRecordingBundleContext(opts) {
+  const recording = await opts.client.getRecording(opts.recordingId);
+  const subscription = await opts.client.accountStatus();
+  const transcript = recording.activeTranscriptId ? await opts.client.getTranscript(recording.activeTranscriptId) : void 0;
+  return {
+    recording,
+    subscription,
+    ...transcript ? { transcript } : {},
+    transcriptId: transcript?.transcriptId ?? recording.activeTranscriptId ?? void 0
+  };
+}
+async function downloadRecordingAudioToDir(recording, recordingAudio, directory) {
+  return recordingAudio.downloadRecordingAudioFile(recording.recordingId, {
+    directory,
+    filenameStem: "recording",
+    title: recording.title ?? recording.summaryTitle ?? recording.recordingId
+  });
+}
+async function writeRecordingTextFiles(context, sessionDir, opts) {
+  const { recording, transcript, subscription } = context;
+  await fs5.mkdir(sessionDir, { recursive: true });
+  const recordingJsonPath = path6.join(sessionDir, "recording.json");
+  const sessionMetadataPath = path6.join(sessionDir, "session-metadata.json");
+  const remoteManifestPath = path6.join(sessionDir, "remote-session.json");
+  const existingManifest = await readJsonRecord(remoteManifestPath);
+  const uploadFilename = opts.uploadFilename ?? (typeof existingManifest?.uploadFilename === "string" ? existingManifest.uploadFilename : void 0);
+  await writeJson(recordingJsonPath, recording);
+  await writeJson(sessionMetadataPath, renderSessionMetadata(recording));
+  await writeJson(
+    remoteManifestPath,
+    renderRemoteSessionManifest(recording, uploadFilename, transcript, subscription, opts.now)
+  );
+  let transcriptPath;
+  let transcriptJsonPath;
+  let summaryPath;
+  let summaryJsonPath;
+  let actionItemsPath;
+  let summaryStatus;
+  if (transcript) {
+    transcriptPath = path6.join(sessionDir, "transcript.md");
+    transcriptJsonPath = path6.join(sessionDir, "transcript.json");
+    summaryPath = path6.join(sessionDir, "summary.md");
+    summaryJsonPath = path6.join(sessionDir, "summary.json");
+    actionItemsPath = path6.join(sessionDir, "action-items.md");
+    summaryStatus = transcript.summary.status;
+    await fs5.writeFile(transcriptPath, renderTranscriptMarkdown(transcript), "utf8");
+    await writeJson(transcriptJsonPath, transcript);
+    await writeJson(summaryJsonPath, transcript.summary);
+    await fs5.writeFile(summaryPath, renderSummaryMarkdown(recording, transcript), "utf8");
+    await writeOptionalText(actionItemsPath, renderActionItemsMarkdown(transcript.summary));
+  }
+  return {
+    recordingId: recording.recordingId,
+    sessionDir,
+    remoteManifestPath,
+    sessionMetadataPath,
+    recordingJsonPath,
+    ...context.transcriptId !== void 0 ? { transcriptId: context.transcriptId } : {},
+    ...transcriptPath ? { transcriptPath } : {},
+    ...transcriptJsonPath ? { transcriptJsonPath } : {},
+    ...summaryPath ? { summaryPath } : {},
+    ...summaryJsonPath ? { summaryJsonPath } : {},
+    ...actionItemsPath ? { actionItemsPath } : {},
+    ...summaryStatus ? { summaryStatus } : {}
+  };
+}
+async function resolveRecordingSessionDir(recording, opts) {
+  if (opts.directory) return path6.resolve(opts.directory);
+  const existing = await findExistingRecordingSessionDir(recording.recordingId, opts.homeDir, opts.env);
+  if (existing) return existing;
+  return createRecordingSessionDir(recording, opts.homeDir, opts.env);
+}
+async function findExistingRecordingSessionDir(recordingId, homeDir, env) {
+  const base = recordingSessionBaseDirectory(homeDir, env);
+  let entries;
+  try {
+    entries = await fs5.readdir(base, { withFileTypes: true });
+  } catch {
+    return void 0;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const dir = path6.join(base, entry.name);
+    const manifest = await readJsonRecord(path6.join(dir, "remote-session.json"));
+    if (manifest?.recordingId === recordingId) return dir;
+  }
+  return void 0;
+}
+async function createRecordingSessionDir(recording, homeDir, env) {
+  const base = recordingSessionBaseDirectory(homeDir, env);
+  await fs5.mkdir(base, { recursive: true });
+  const stem = formatSessionDirectoryDate(new Date(recording.createdAt));
+  let candidate = path6.join(base, stem);
+  let suffix = 2;
+  while (await pathExists(candidate)) {
+    candidate = path6.join(base, `${stem}-cloud-${suffix}`);
+    suffix += 1;
+  }
+  await fs5.mkdir(candidate, { recursive: true });
+  return candidate;
+}
+function recordingSessionBaseDirectory(homeDir = os5.homedir(), env = process.env) {
+  const explicit = env.RECAPPI_LOCAL_SESSIONS_DIR?.trim();
+  if (explicit) return explicit;
+  return path6.join(homeDir, "Documents", "Recappi Mini");
+}
+async function readJsonRecord(filePath) {
+  try {
+    const parsed = JSON.parse(await fs5.readFile(filePath, "utf8"));
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function pathExists(filePath) {
+  try {
+    await fs5.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function formatSessionDirectoryDate(date5) {
+  const year = date5.getFullYear();
+  const month = String(date5.getMonth() + 1).padStart(2, "0");
+  const day = String(date5.getDate()).padStart(2, "0");
+  const hour = String(date5.getHours()).padStart(2, "0");
+  const minute = String(date5.getMinutes()).padStart(2, "0");
+  const second = String(date5.getSeconds()).padStart(2, "0");
+  return `${year}-${month}-${day}_${hour}${minute}${second}`;
+}
+async function writeJson(filePath, value) {
+  await fs5.writeFile(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+async function writeOptionalText(filePath, value) {
+  if (value && value.trim()) {
+    await fs5.writeFile(filePath, value, "utf8");
+    return;
+  }
+  await fs5.rm(filePath, { force: true });
+}
+function renderHandoffMarkdown(recording, subscription, audio, data, transcript) {
+  const lines = [];
+  lines.push(`# ${recording.title ?? recording.summaryTitle ?? "Recappi Recording"}`);
+  lines.push("");
+  lines.push("## Files", "");
+  lines.push(`- Audio: ${audio.localPath}`);
+  lines.push(`- Subscription: ${data.subscriptionPath}`);
+  if (data.summaryPath) lines.push(`- Summary: ${data.summaryPath}`);
+  if (data.transcriptPath) lines.push(`- Transcript: ${data.transcriptPath}`);
+  if (data.actionItemsPath) lines.push(`- Action items: ${data.actionItemsPath}`);
+  lines.push(`- Remote session manifest: ${data.remoteManifestPath}`);
+  lines.push(`- Session metadata: ${data.sessionMetadataPath}`);
+  lines.push(`- Manifest: ${data.manifestPath}`);
+  lines.push("");
+  lines.push("## Recording", "");
+  lines.push(`- recordingId: ${recording.recordingId}`);
+  lines.push(`- status: ${recording.status}`);
+  if (recording.durationMs !== void 0 && recording.durationMs !== null) {
+    lines.push(`- duration: ${formatTimestamp(recording.durationMs)}`);
+  }
+  if (recording.sizeBytes !== void 0 && recording.sizeBytes !== null) {
+    lines.push(`- sizeBytes: ${recording.sizeBytes}`);
+  }
+  if (transcript) {
+    lines.push(`- transcriptId: ${transcript.transcriptId}`);
+    lines.push(`- summaryStatus: ${transcript.summary.status}`);
+  } else {
+    lines.push("- transcript: not available");
+  }
+  lines.push("");
+  lines.push("## Subscription", "");
+  appendSubscriptionLines(lines, subscription);
+  lines.push("");
+  if (transcript) {
+    lines.push(renderSummaryMarkdown(recording, transcript).trimEnd());
+    lines.push("");
+    lines.push(renderTranscriptMarkdown(transcript).trimEnd());
+    lines.push("");
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function renderSubscriptionMarkdown(subscription) {
+  const lines = ["# Subscription", ""];
+  appendSubscriptionLines(lines, subscription);
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function renderSessionMetadata(recording) {
+  const sourceTitle = recording.title ?? recording.summaryTitle ?? "Recappi Cloud";
+  return stripUndefined({
+    summaryTitle: recording.summaryTitle ?? recording.title ?? void 0,
+    sourceTitle,
+    sourceAppName: void 0,
+    sourceBundleID: void 0,
+    startedAt: new Date(recording.createdAt).toISOString(),
+    sceneTemplate: void 0,
+    extraPrompt: void 0,
+    includesMicrophoneAudio: void 0
+  });
+}
+function renderRemoteSessionManifest(recording, uploadFilename, transcript, subscription, now) {
+  return stripUndefined({
+    recordingId: recording.recordingId,
+    jobId: transcript?.jobId,
+    transcriptId: transcript?.transcriptId ?? recording.activeTranscriptId ?? void 0,
+    stage: transcript ? "done" : "synced",
+    errorMessage: void 0,
+    uploadFilename,
+    provider: transcript?.provider,
+    model: transcript?.model,
+    updatedAt: (now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+    accountUserId: subscription.userId,
+    accountBackendOrigin: subscription.origin
+  });
+}
+function stripUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function appendSubscriptionLines(lines, subscription) {
+  lines.push(`- origin: ${subscription.origin}`);
+  lines.push(`- loggedIn: ${subscription.loggedIn}`);
+  if (subscription.email) lines.push(`- email: ${subscription.email}`);
+  if (subscription.userId) lines.push(`- userId: ${subscription.userId}`);
+  if (subscription.billing) {
+    lines.push(`- plan: ${subscription.billing.tier}`);
+    lines.push(`- minutesUsed: ${subscription.billing.minutesUsed}`);
+    lines.push(`- minutesCap: ${subscription.billing.minutesCap ?? "unlimited"}`);
+    lines.push(`- batchMinutesUsed: ${subscription.billing.batchMinutesUsed}`);
+    lines.push(`- realtimeMinutesUsed: ${subscription.billing.realtimeMinutesUsed}`);
+    lines.push(`- storageBytes: ${subscription.billing.storageBytes}`);
+    lines.push(`- storageCapBytes: ${subscription.billing.storageCapBytes ?? "unlimited"}`);
+    lines.push(`- periodStart: ${subscription.billing.periodStart}`);
+    lines.push(`- periodEnd: ${subscription.billing.periodEnd}`);
+  }
+}
+function renderTranscriptMarkdown(transcript) {
+  return `# Transcript
+
+${renderTranscriptLines(transcript)}
+`;
+}
+function renderTranscriptLines(transcript) {
+  const lines = transcript.segments.map((segment) => {
+    const speaker = segment.speaker ? `${segment.speaker}: ` : "";
+    return `[${formatTimestamp(segment.startMs)}] ${speaker}${segment.text}`;
+  });
+  if (lines.length > 0) return lines.join("\n");
+  return transcript.text;
+}
+function renderSummaryMarkdown(recording, transcript) {
+  const summary = transcript.summary;
+  const lines = [];
+  lines.push(`# ${summary.title ?? recording.title ?? recording.summaryTitle ?? "Summary"}`);
+  lines.push("");
+  lines.push(`- recordingId: ${recording.recordingId}`);
+  lines.push(`- transcriptId: ${transcript.transcriptId}`);
+  lines.push(`- summaryStatus: ${summary.status}`);
+  if (summary.error) lines.push(`- error: ${summary.error}`);
+  lines.push("");
+  if (summary.tldr) {
+    lines.push("## TL;DR", "");
+    lines.push(summary.tldr, "");
+  }
+  appendStringList(lines, "Key Points", summary.keyPoints);
+  appendStringList(lines, "Topics", summary.topics);
+  appendStringList(lines, "Decisions", summary.decisions);
+  appendActionItems(lines, summary.actionItems);
+  appendTimeline(lines, summary.timeline);
+  appendQuotes(lines, summary.quotes);
+  if (lines[lines.length - 1] !== "") lines.push("");
+  return lines.join("\n");
+}
+function renderActionItemsMarkdown(summary) {
+  if (!summary.actionItems || summary.actionItems.length === 0) return null;
+  const lines = ["# Action Items", ""];
+  for (const item of summary.actionItems) {
+    lines.push(`- ${item.who ? `${item.who} - ` : ""}${item.what}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function appendStringList(lines, title, values) {
+  if (!values || values.length === 0) return;
+  lines.push(`## ${title}`, "");
+  for (const value of values) lines.push(`- ${value}`);
+  lines.push("");
+}
+function appendActionItems(lines, values) {
+  if (!values || values.length === 0) return;
+  lines.push("## Action Items", "");
+  for (const item of values) {
+    lines.push(`- ${item.who ? `${item.who}: ` : ""}${item.what}`);
+  }
+  lines.push("");
+}
+function appendTimeline(lines, values) {
+  if (!values || values.length === 0) return;
+  lines.push("## Timeline", "");
+  for (const item of values) {
+    lines.push(
+      `- ${formatTimestamp(item.startMs)}-${formatTimestamp(item.endMs)}: ${item.title} - ${item.summary}`
+    );
+  }
+  lines.push("");
+}
+function appendQuotes(lines, values) {
+  if (!values || values.length === 0) return;
+  lines.push("## Quotes", "");
+  for (const item of values) {
+    lines.push(`- ${item.speaker ? `${item.speaker}: ` : ""}"${item.text}"`);
+  }
+  lines.push("");
+}
+function audioMetadata(audio) {
+  return {
+    ...audio.contentType ? { contentType: audio.contentType } : {},
+    ...audio.contentLength !== void 0 ? { contentLength: audio.contentLength } : {},
+    reused: audio.reused
+  };
+}
+function formatTimestamp(ms) {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  const mm = String(minutes).padStart(2, "0");
+  const ss = String(seconds).padStart(2, "0");
+  return hours > 0 ? `${hours}:${mm}:${ss}` : `${mm}:${ss}`;
+}
+
 // src/progressStepper.ts
 var STEP_DEFS = [
   { key: "check", label: "Check" },
@@ -20934,6 +21448,28 @@ Next:
     }
     return;
   }
+  if (command === "recordings export" && isRecord4(data)) {
+    opts.stdout("Recording export ready\n");
+    printStringField(opts, data, "recordingId");
+    printStringField(opts, data, "exportDir");
+    printStringField(opts, data, "textPath");
+    printStringField(opts, data, "audioPath");
+    printStringField(opts, data, "transcriptPath");
+    printStringField(opts, data, "summaryPath");
+    printStringField(opts, data, "actionItemsPath");
+    printStringField(opts, data, "subscriptionPath");
+    printStringField(opts, data, "transcriptJsonPath");
+    printStringField(opts, data, "summaryJsonPath");
+    printStringField(opts, data, "subscriptionJsonPath");
+    printStringField(opts, data, "recordingJsonPath");
+    printStringField(opts, data, "remoteManifestPath");
+    printStringField(opts, data, "sessionMetadataPath");
+    printStringField(opts, data, "manifestPath");
+    if (typeof data.transcriptPath !== "string") {
+      opts.stdout("  transcript: no active transcript\n");
+    }
+    return;
+  }
   if (command === "recordings retranscribe" && isRecord4(data)) {
     opts.stdout("Transcription started\n");
     if (typeof data.recordingId === "string") opts.stdout(`  recordingId: ${data.recordingId}
@@ -21311,6 +21847,10 @@ function recordingTitle(item) {
 function numberText(value) {
   return typeof value === "number" && Number.isFinite(value) ? value.toLocaleString("en-US") : "0";
 }
+function printStringField(opts, data, field) {
+  if (typeof data[field] === "string") opts.stdout(`  ${field}: ${data[field]}
+`);
+}
 function formatDurationMs(ms) {
   return formatClock(ms / 1e3);
 }
@@ -21427,6 +21967,7 @@ var COMMAND_DATA_SCHEMAS = {
   upload: uploadBatchDataSchema,
   record: recordCommandDataSchema,
   "recordings get": recordingDataSchema,
+  "recordings export": recordingExportDataSchema,
   "recordings list": recordingListDataSchema,
   "recordings retranscribe": recordingTranscribeDataSchema,
   "recordings resummarize": recordingSummarizeDataSchema,
@@ -21465,11 +22006,11 @@ function buildSchemaDocument(program) {
     event: toJsonSchema(operationEventSchema)
   };
 }
-function walkCommands(command, path6, out) {
+function walkCommands(command, path7, out) {
   for (const sub of subcommandsOf(command)) {
     const name = sub.name();
     if (name === "help") continue;
-    const fullPath = [...path6, name];
+    const fullPath = [...path7, name];
     const children = subcommandsOf(sub).filter((child) => child.name() !== "help");
     if (children.length === 0) {
       out.push(leafCommandDoc(sub, fullPath.join(" ")));
@@ -21871,8 +22412,8 @@ function requestLaunchServicesSidecarShutdown(input) {
   } catch {
   }
 }
-function createFifo(path6) {
-  const result = spawnSync("mkfifo", [path6], { encoding: "utf8" });
+function createFifo(path7) {
+  const result = spawnSync("mkfifo", [path7], { encoding: "utf8" });
   if (result.status !== 0) {
     throw cliError("record.helper_unavailable", "Recappi recording helper could not start.", {
       hint: result.stderr || "Could not create the local recorder pipes. Try again."
@@ -22496,9 +23037,9 @@ function resolveSidecarCommand(opts) {
     hint: `No bundled helper is registered for ${platform}. Set ${SIDECAR_COMMAND_ENV} to a compatible helper when one is available.`
   });
 }
-function ensureBundledHelperExecutable(path6, opts = {}) {
-  if (process.platform === "darwin" && path6.endsWith(".app")) {
-    const stableApp = ensureStableDarwinHelperApp(path6, opts);
+function ensureBundledHelperExecutable(path7, opts = {}) {
+  if (process.platform === "darwin" && path7.endsWith(".app")) {
+    const stableApp = ensureStableDarwinHelperApp(path7, opts);
     const executable = darwinAppExecutablePath(stableApp);
     if (!existsSync(executable)) {
       throw cliError("record.helper_unavailable", "Recappi recording helper is not available.", {
@@ -22508,19 +23049,19 @@ function ensureBundledHelperExecutable(path6, opts = {}) {
     ensureExecutableMode(executable);
     return stableApp;
   }
-  if (process.platform === "win32") return path6;
-  ensureExecutableMode(path6);
-  return path6;
+  if (process.platform === "win32") return path7;
+  ensureExecutableMode(path7);
+  return path7;
 }
-function ensureExecutableMode(path6) {
-  const mode = statSync(path6).mode;
+function ensureExecutableMode(path7) {
+  const mode = statSync(path7).mode;
   if ((mode & 73) !== 0) return;
   try {
-    chmodSync(path6, mode | 493);
+    chmodSync(path7, mode | 493);
   } catch (error51) {
     const message = error51 instanceof Error ? error51.message : String(error51);
     throw cliError("record.helper_unavailable", "Recappi recording helper is not executable.", {
-      hint: `Could not make bundled helper executable at ${path6}: ${message}. Reinstall recappi, or set ${SIDECAR_COMMAND_ENV} to a compatible helper.`
+      hint: `Could not make bundled helper executable at ${path7}: ${message}. Reinstall recappi, or set ${SIDECAR_COMMAND_ENV} to a compatible helper.`
     });
   }
 }
@@ -22565,14 +23106,14 @@ function helperSourceSignature(sourceApp) {
     codeSignature: existsSync(signaturePath) ? fileDigest(signaturePath) : null
   });
 }
-function fileDigest(path6) {
+function fileDigest(path7) {
   const hash2 = createHash("sha256");
-  hash2.update(readFileSync2(path6));
+  hash2.update(readFileSync2(path7));
   return hash2.digest("hex");
 }
-function readTextIfExists(path6) {
+function readTextIfExists(path7) {
   try {
-    return readFileSync2(path6, "utf8");
+    return readFileSync2(path7, "utf8");
   } catch {
     return null;
   }
@@ -22935,6 +23476,26 @@ async function runCli(deps = {}) {
         },
         retranscribeRecording: (recordingId, options = {}) => client.transcribeRecording({ recordingId, ...options }),
         resummarizeRecording: (recordingId) => client.summarizeRecording({ recordingId }),
+        syncRecordingText: (recordingId) => syncRecordingText({
+          recordingId,
+          client,
+          env: deps.env,
+          homeDir: deps.homeDir
+        }),
+        syncRecordingAudio: (recordingId) => syncRecordingAudio({
+          recordingId,
+          client,
+          recordingAudio,
+          env: deps.env,
+          homeDir: deps.homeDir
+        }),
+        exportRecording: (recordingId) => exportRecording({
+          recordingId,
+          client,
+          recordingAudio,
+          env: deps.env,
+          homeDir: deps.homeDir
+        }),
         initialView: parsed.initialView
       });
       return 0;
@@ -22965,7 +23526,7 @@ async function runCli(deps = {}) {
       return 0;
     }
     if (parsed.kind === "auth-logout") {
-      const cleared = await clearAuthConfig(deps.homeDir ?? os5.homedir());
+      const cleared = await clearAuthConfig(deps.homeDir ?? os6.homedir());
       renderSuccess("auth logout", { loggedIn: false, origin: auth.origin, cleared }, render3);
       return 0;
     }
@@ -22976,7 +23537,7 @@ async function runCli(deps = {}) {
           hint: keychain.hint ?? "Run recappi auth login instead."
         });
       }
-      await saveAuthConfig(deps.homeDir ?? os5.homedir(), {
+      await saveAuthConfig(deps.homeDir ?? os6.homedir(), {
         origin: auth.origin,
         token: keychain.token
       });
@@ -23125,6 +23686,29 @@ async function runCli(deps = {}) {
       renderSuccess("recordings get", data, render3);
       return 0;
     }
+    if (parsed.kind === "recordings-export") {
+      const status = await client.authStatus();
+      if (!status.loggedIn || !status.userId) {
+        throw cliError("auth.not_logged_in", "Sign in before exporting a recording bundle.", {
+          hint: "Run recappi auth login, or import the Recappi Mini session with recappi auth import-macos."
+        });
+      }
+      const recordingAudio = createRecordingAudioRuntime(client, {
+        account: { backendOrigin: auth.origin, userId: status.userId },
+        env: deps.env,
+        homeDir: deps.homeDir
+      });
+      const data = await exportRecording({
+        recordingId: parsed.recordingId,
+        ...parsed.directory ? { directory: parsed.directory } : {},
+        client,
+        recordingAudio,
+        env: deps.env,
+        homeDir: deps.homeDir
+      });
+      renderSuccess("recordings export", data, render3);
+      return 0;
+    }
     if (parsed.kind === "recordings-retranscribe") {
       const eventMode = parsed.options.mode === "jsonl" ? "jsonl" : "human";
       const data = await client.transcribeRecording({
@@ -23480,6 +24064,20 @@ Agent mode:
       });
     }
   );
+  const recordingsExport = recordings.command("export <recordingId>").description("Export audio, transcript, summary, and subscription/account files for agents").option("--dir <dir>", "directory for exported files", parseStringOption("--dir")).addHelpText("after", commandMetadataHelpText("recordings export"));
+  addCommonOptions(recordingsExport);
+  recordingsExport.action(
+    (recordingId, _options, command) => {
+      const opts = command.opts();
+      onSelect({
+        kind: "recordings-export",
+        options: collectGlobalOptions(command),
+        commandName: "recordings export",
+        recordingId,
+        ...typeof opts.dir === "string" ? { directory: opts.dir } : {}
+      });
+    }
+  );
   const recordingsRetranscribe = recordings.command("retranscribe <recordingId>").description("Start a fresh transcription job for an existing recording").option("--language <lang>", "transcription language hint", parseStringOption("--language")).option("--provider <name>", "transcription provider", parseStringOption("--provider")).option("--model <name>", "transcription model", parseStringOption("--model")).option("--prompt <text>", "custom transcription prompt/context", parseStringOption("--prompt")).option("--scene <id>", "transcription scene preset", parseStringOption("--scene")).option("--wait", "wait for the transcription job to reach a terminal state").addHelpText("after", commandMetadataHelpText("recordings retranscribe"));
   addCommonOptions(recordingsRetranscribe);
   recordingsRetranscribe.action(
@@ -23654,7 +24252,8 @@ var VALUE_OPTIONS = /* @__PURE__ */ new Set([
   "--status",
   "--limit",
   "--cursor",
-  "--search"
+  "--search",
+  "--dir"
 ]);
 function hasCommandToken(argv) {
   return commandTokens(argv).length > 0;