listener-ai 2.5.1 → 2.6.0

package/README.md

@@ -41,6 +41,11 @@ listener config set notionDatabaseId <your-id>
 ```bash
 listener recording.mp3                # Transcribe to default output dir
 listener recording.m4a --output ./    # Transcribe to current directory
+listener transcript recording.wav     # Print transcript to stdout (no summary)
+listener transcript recording.wav -o out.txt
+                                      # Write transcript to a file
+listener transcript recording.wav --prompt "Translate to English while transcribing"
+                                      # Override the default transcription instruction
 listener config list                  # Show all config values (secrets masked)
 listener config get <key>             # Print one config value
 listener config set <key> <value>     # Set a config value

package/dist/cli.js

@@ -67,7 +67,9 @@ const VERSION = (() => {
         return 'unknown';
     }
 })();
-const USAGE_TEXT = 'Usage: listener <file> [--output <dir>]    Transcribe an audio file\n' +
+const USAGE_TEXT = 'Usage: listener <file> [--output <dir>]    Transcribe an audio file into a meeting note\n' +
+    '       listener transcript <file> [--output <path>] [--prompt <text>]\n' +
+    '                                           Transcribe to plain text only (no summary)\n' +
     '       listener list [--limit <n>]         List past transcriptions\n' +
     '       listener show <ref>                 Print summary to stdout\n' +
     '       listener export <ref> [<path>] [--json] [--transcript]\n' +
@@ -85,7 +87,10 @@ const USAGE_TEXT = 'Usage: listener <file> [--output <dir>]    Transcribe an aud
     '<ref> is a number from `listener list` or a folder name.\n' +
     '\n' +
     'Options:\n' +
-    '  --output <dir>   Parent directory for the output folder\n' +
+    '  --output, -o <path>\n' +
+    '                   Parent directory for the output folder (transcribe);\n' +
+    '                   destination file or directory (transcript)\n' +
+    '  --prompt <text>  Override the default transcription instruction (transcript)\n' +
     '  --limit <n>      Max results (0 = all, default: 20)\n' +
     '  --json           Export as JSON instead of markdown\n' +
     '  --transcript     Include transcript body (export: append; search: widen scope)\n' +
@@ -426,6 +431,8 @@ async function handleExport(args) {
                 /* ignore */
             }
         }
+        const liveNotes = (0, outputService_1.parseLiveNotesField)(meta.liveNotes);
+        const highlights = (0, outputService_1.parseHighlightsField)(meta.highlights);
         const obj = {
             title: meta.title || '',
             transcribedAt: meta.transcribedAt || '',
@@ -433,6 +440,8 @@ async function handleExport(args) {
             keyPoints: meta.keyPoints || [],
             actionItems: meta.actionItems || [],
             customFields,
+            ...(liveNotes ? { liveNotes } : {}),
+            ...(highlights ? { highlights } : {}),
         };
         if (includeTranscript) {
             obj.transcript = meta.transcript || '';
@@ -662,6 +671,101 @@ async function handleAsk(args) {
         }
     }
 }
+async function handleTranscript(args) {
+    let filePath;
+    let outputArg;
+    let promptText;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if ((a === '--output' || a === '-o') && i + 1 < args.length) {
+            outputArg = args[++i];
+            continue;
+        }
+        if (a === '--prompt' && i + 1 < args.length) {
+            promptText = args[++i];
+            continue;
+        }
+        if (a.startsWith('-')) {
+            process.stderr.write(`Error: Unknown option: ${a}\n`);
+            process.exit(1);
+        }
+        if (filePath) {
+            process.stderr.write(`Error: Unexpected argument: ${a}\n`);
+            process.exit(1);
+        }
+        filePath = a;
+    }
+    if (!filePath) {
+        process.stderr.write('Error: No audio file specified. Usage: listener transcript <file> [--output <path>] [--prompt <text>]\n');
+        process.exit(1);
+    }
+    filePath = path.resolve(filePath);
+    if (!fs.existsSync(filePath)) {
+        process.stderr.write(`Error: File not found: ${filePath}\n`);
+        process.exit(1);
+    }
+    const ext = path.extname(filePath).toLowerCase();
+    if (!SUPPORTED_EXTENSIONS.has(ext)) {
+        process.stderr.write(`Error: Unsupported file type: ${ext}\n`);
+        process.stderr.write(`Supported formats: ${[...SUPPORTED_EXTENSIONS].join(', ')}\n`);
+        process.exit(1);
+    }
+    const dataPath = (0, dataPath_1.getDataPath)();
+    const config = new configService_1.ConfigService(dataPath);
+    const apiKey = config.getGeminiApiKey();
+    if (!apiKey) {
+        process.stderr.write('Error: Gemini API key not found.\n' +
+            'Set GEMINI_API_KEY env var or configure via the Listener.AI app.\n');
+        process.exit(1);
+    }
+    // Resolve --output before the expensive transcription so we fail fast on a
+    // bad path. Existing directory => <dir>/<basename>.transcript.md.
+    // Anything else => the path itself, treated as a file.
+    let outputPath;
+    if (outputArg) {
+        const resolved = path.resolve(outputArg);
+        let isDir = false;
+        try {
+            isDir = fs.statSync(resolved).isDirectory();
+        }
+        catch {
+            // ENOENT or similar: treat as a file path, validated below.
+        }
+        if (isDir) {
+            outputPath = path.join(resolved, `${path.basename(filePath, ext)}.transcript.md`);
+        }
+        else {
+            outputPath = resolved;
+            const parent = path.dirname(outputPath);
+            if (!fs.existsSync(parent)) {
+                process.stderr.write(`Error: Output directory does not exist: ${parent}\n`);
+                process.exit(1);
+            }
+        }
+    }
+    const gemini = new geminiService_1.GeminiService({
+        apiKey,
+        dataPath,
+        knownWords: config.getKnownWords(),
+        proModel: config.getGeminiModel(),
+        flashModel: config.getGeminiFlashModel(),
+    });
+    process.stderr.write(`Processing: ${filePath}\n`);
+    const result = await gemini.transcribeAudio(filePath, (_percent, message) => {
+        process.stderr.write(`  ${message}\n`);
+    }, undefined, undefined, { transcriptOnly: true, transcriptionPrompt: promptText });
+    if (outputPath) {
+        fs.writeFileSync(outputPath, result.transcript, 'utf-8');
+        process.stderr.write('Done.\n');
+        process.stdout.write(`${outputPath}\n`);
+    }
+    else {
+        // Wait for the OS to drain the write before returning, so multi-MB
+        // transcripts piped to a slow consumer are not truncated on process exit.
+        const out = result.transcript.endsWith('\n') ? result.transcript : `${result.transcript}\n`;
+        await new Promise((resolve) => process.stdout.write(out, () => resolve()));
+    }
+}
 async function main() {
     const args = process.argv.slice(2);
     if (args.includes('--version') || args.includes('-V')) {
@@ -702,11 +806,15 @@ async function main() {
         await handleAsk(args.slice(1));
         return;
     }
+    if (args[0] === 'transcript') {
+        await handleTranscript(args.slice(1));
+        return;
+    }
     // Parse arguments
     let filePath;
     let outputDir;
     for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--output' && i + 1 < args.length) {
+        if ((args[i] === '--output' || args[i] === '-o') && i + 1 < args.length) {
             outputDir = args[++i];
         }
         else if (args[i].startsWith('-')) {

package/dist/geminiService.js

@@ -36,9 +36,104 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GeminiService = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
 const genai_1 = require("@google/genai");
 const audioFormats_1 = require("./audioFormats");
+const outputService_1 = require("./outputService");
 const ffmpegManager_1 = require("./services/ffmpegManager");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+// Append a section to the summary prompt instructing Gemini to enrich each
+// user-flagged moment with a subtitle + categorized bullets, returned as a
+// `highlights` array on the JSON response. Returns '' when there's nothing to
+// enrich -- prompt stays untouched in that case so we don't pay for empty
+// instructions.
+function buildHighlightsPromptBlock(notes) {
+    if (notes.length === 0)
+        return '';
+    const lines = notes.map((n) => `- offsetMs=${n.offsetMs}, timestamp=${(0, outputService_1.formatOffsetTimestamp)(n.offsetMs)}, userText=${JSON.stringify(n.text)}`);
+    return `In addition, the user flagged the following moments during the meeting. For each note, produce a structured analysis tied to that moment in the transcript:
+
+${lines.join('\n')}
+
+For every flagged moment above, write one entry in a JSON array named "highlights". Each entry must include:
+- "offsetMs": the exact integer from the input
+- "userText": the user's typed text, copied verbatim
+- "subtitle": a short topic label in Korean (3-7 words) summarising what was being discussed at that timestamp
+- "bullets": 2-5 short Korean bullet strings categorising the discussion at that point. Prefix each bullet with one of these categories when applicable, omitting categories that don't fit: "결정 사항:", "주요 인사이트:", "실행 항목:", "식별된 리스크:". If none of the categories fit, just write the bullet without a prefix.
+
+Use the transcript as the ground truth -- if the user's typed text doesn't clearly match anything in the transcript, fall back to the meeting content nearest the given timestamp. Return the highlights array as an additional key alongside the other fields in the JSON.`;
+}
+function mergeHighlights(liveNotes, raw) {
+    if (!liveNotes || liveNotes.length === 0)
+        return undefined;
+    // Index Gemini's returned highlights by offsetMs so we can attach
+    // enrichment to the matching user note. Treat anything malformed as
+    // "no enrichment for that note" -- the bare offset+userText still
+    // round-trips so the user's data is never lost.
+    const byOffset = new Map();
+    if (Array.isArray(raw)) {
+        for (const item of raw) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const offsetMs = Number(item.offsetMs);
+            if (!Number.isFinite(offsetMs))
+                continue;
+            const subtitleRaw = item.subtitle;
+            const bulletsRaw = item.bullets;
+            const subtitle = typeof subtitleRaw === 'string' && subtitleRaw.trim().length > 0
+                ? subtitleRaw.trim()
+                : undefined;
+            const bullets = Array.isArray(bulletsRaw)
+                ? bulletsRaw.map((b) => (typeof b === 'string' ? b.trim() : '')).filter((b) => b.length > 0)
+                : undefined;
+            byOffset.set(offsetMs, {
+                subtitle,
+                bullets: bullets && bullets.length > 0 ? bullets : undefined,
+            });
+        }
+    }
+    return liveNotes.map((note) => {
+        const enrichment = byOffset.get(note.offsetMs);
+        return {
+            offsetMs: note.offsetMs,
+            userText: note.text,
+            subtitle: enrichment?.subtitle,
+            bullets: enrichment?.bullets,
+        };
+    });
+}
+function transcriptOnlyResult(transcript) {
+    return {
+        transcript,
+        summary: '',
+        keyPoints: [],
+        actionItems: [],
+        emoji: '',
+    };
+}
+const DEFAULT_TRANSCRIPT_PROMPT = `Please transcribe this audio recording with proper speaker identification.
+
+Format requirements:
+1. IDENTIFY different speakers and label them as 참가자1, 참가자2, etc.
+2. Each speaker's turn MUST start on a NEW LINE
+3. Format: 참가자X: [what they said]
+4. Add a blank line between different speakers
+
+Example format:
+참가자1: 안녕하세요, 오늘 회의를 시작하겠습니다.
+
+참가자2: 네, 준비됐습니다.
+
+참가자1: 첫 번째 안건은...
+
+IMPORTANT:
+- You MUST identify and differentiate between speakers
+- Each speaker turn MUST start on a new line
+- Add blank line between different speakers
+- DO NOT include timestamps
+- Keep the transcription in the original spoken language
+- Return ONLY the transcription text, no JSON formatting`;
 class GeminiService {
     // Get FFmpeg path for this service
     async getFFmpegPath() {
@@ -63,7 +158,7 @@ class GeminiService {
         const wordList = this.knownWords.map((w) => `- ${w}`).join('\n');
         return `The following proper nouns, names, and terms may appear in the audio. Transcribe them exactly as spelled:\n${wordList}\n\n`;
     }
-    async transcribeAudio(audioFilePath, progressCallback, summaryPrompt) {
+    async transcribeAudio(audioFilePath, progressCallback, summaryPrompt, liveNotes, options = {}) {
         // Integration-test escape hatch: avoid the real Gemini call so tests can
         // exercise the surrounding pipeline (CLI parsing, IPC, ffmpeg, save) for
         // free and offline. Gated on NODE_ENV=test so a stray LISTENER_TEST_MODE
@@ -71,6 +166,9 @@ class GeminiService {
         if (process.env.LISTENER_TEST_MODE && process.env.NODE_ENV === 'test') {
             if (progressCallback)
                 progressCallback(100, 'Stubbed transcription');
+            if (options.transcriptOnly) {
+                return transcriptOnlyResult('Stubbed transcript.');
+            }
             return {
                 transcript: 'Stubbed transcript.',
                 summary: 'Stubbed summary.',
@@ -84,20 +182,20 @@ class GeminiService {
             // Check file size
             const stats = fs.statSync(audioFilePath);
             const fileSizeInMB = stats.size / (1024 * 1024);
-            console.log(`Audio file size: ${fileSizeInMB.toFixed(2)} MB`);
+            console.error(`Audio file size: ${fileSizeInMB.toFixed(2)} MB`);
             if (progressCallback) {
                 progressCallback(15, `Processing ${fileSizeInMB.toFixed(1)} MB audio file...`);
             }
             // Get audio duration using ffmpeg
             const duration = await this.getAudioDuration(audioFilePath);
-            console.log(`Audio duration: ${duration} seconds`);
+            console.error(`Audio duration: ${duration} seconds`);
             // If duration is 0, log a warning but continue processing
             if (duration === 0) {
                 console.warn('WARNING: Could not determine audio duration. Will process as single file without segmentation.');
             }
             // Always use the two-step approach for consistency
-            console.log('Using two-step transcription approach...');
-            return await this.transcribeWithTwoSteps(audioFilePath, duration, progressCallback, summaryPrompt);
+            console.error('Using two-step transcription approach...');
+            return await this.transcribeWithTwoSteps(audioFilePath, duration, progressCallback, summaryPrompt, liveNotes, options);
         }
         catch (error) {
             console.error('Error transcribing audio:', error);
@@ -116,21 +214,24 @@ class GeminiService {
             throw new Error(`Failed to transcribe audio: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    // Get audio duration using ffprobe
+    // Get audio duration using ffmpeg
     async getAudioDuration(audioFilePath) {
-        const { exec } = require('child_process');
-        const { promisify } = require('util');
-        const execAsync = promisify(exec);
         try {
             const ffmpegPath = await this.getFFmpegPath();
             // Use ffmpeg with -f null to get file info including duration
             // This will output file info to stderr which we can parse
-            const ffmpegCommand = `"${ffmpegPath}" -i "${audioFilePath}" -f null -`;
-            console.log('Running ffmpeg command for duration:', ffmpegCommand);
-            const { stderr } = await execAsync(ffmpegCommand).catch((e) => {
+            console.error('Running ffmpeg for duration:', ffmpegPath, audioFilePath);
+            const { stderr } = await execFileAsync(ffmpegPath, [
+                '-i',
+                audioFilePath,
+                '-f',
+                'null',
+                '-',
+            ]).catch((error) => {
+                const execError = error;
                 // FFmpeg exits with non-zero code when output is null, but still provides info in stderr
                 // This is expected behavior, so we return the error object which contains stdout/stderr
-                return { stdout: e.stdout || '', stderr: e.stderr || '' };
+                return { stdout: execError.stdout || '', stderr: execError.stderr || '' };
             });
             // Extract duration from stderr (where ffmpeg outputs file info)
             const durationMatch = stderr?.match(/Duration: (\d{2}):(\d{2}):(\d{2}\.\d{2})/);
@@ -139,7 +240,7 @@ class GeminiService {
                 const minutes = Number.parseInt(durationMatch[2]);
                 const seconds = Number.parseFloat(durationMatch[3]);
                 const totalSeconds = hours * 3600 + minutes * 60 + seconds;
-                console.log(`FFmpeg extracted duration: ${totalSeconds} seconds`);
+                console.error(`FFmpeg extracted duration: ${totalSeconds} seconds`);
                 return totalSeconds;
             }
             // Alternative regex pattern for different duration formats
@@ -149,7 +250,7 @@ class GeminiService {
                 const minutes = Number.parseInt(altDurationMatch[2]);
                 const seconds = Number.parseInt(altDurationMatch[3]);
                 const totalSeconds = hours * 3600 + minutes * 60 + seconds;
-                console.log(`FFmpeg extracted duration (alt format): ${totalSeconds} seconds`);
+                console.error(`FFmpeg extracted duration (alt format): ${totalSeconds} seconds`);
                 return totalSeconds;
             }
             // Default to 0 if we can't determine duration
@@ -164,9 +265,6 @@ class GeminiService {
     }
     // Split audio file into segments
     async splitAudioIntoSegments(audioFilePath, segmentDuration = 300) {
-        const { exec } = require('child_process');
-        const { promisify } = require('util');
-        const execAsync = promisify(exec);
         const outputDir = path.dirname(audioFilePath);
         const baseName = path.basename(audioFilePath, path.extname(audioFilePath));
         const ext = path.extname(audioFilePath);
@@ -175,14 +273,24 @@ class GeminiService {
         const ffmpegPath = await this.getFFmpegPath();
         try {
             // Split audio into segments
-            await execAsync(`"${ffmpegPath}" -i "${audioFilePath}" -f segment -segment_time ${segmentDuration} -c copy "${segmentPath}"`);
+            await execFileAsync(ffmpegPath, [
+                '-i',
+                audioFilePath,
+                '-f',
+                'segment',
+                '-segment_time',
+                String(segmentDuration),
+                '-c',
+                'copy',
+                segmentPath,
+            ]);
             // Find all created segment files
             const segmentFiles = fs
                 .readdirSync(outputDir)
                 .filter((file) => file.startsWith(`${baseName}_segment_`) && file.endsWith(ext))
                 .map((file) => path.join(outputDir, file))
                 .sort();
-            console.log(`Split audio into ${segmentFiles.length} segments`);
+            console.error(`Split audio into ${segmentFiles.length} segments`);
             return segmentFiles;
         }
         catch (error) {
@@ -228,25 +336,31 @@ class GeminiService {
         }
     }
     // Two-step transcription approach for all audio files
-    async transcribeWithTwoSteps(audioFilePath, duration, progressCallback, customSummaryPrompt) {
+    async transcribeWithTwoSteps(audioFilePath, duration, progressCallback, customSummaryPrompt, liveNotes, options = {}) {
         try {
             let fullTranscript = '';
             // Step 1: Get transcript
             if (duration > 300) {
                 // Use segmented approach for long audio
-                console.log('Audio is longer than 5 minutes, using segmented transcription...');
-                fullTranscript = await this.getSegmentedTranscript(audioFilePath, duration, progressCallback);
+                console.error('Audio is longer than 5 minutes, using segmented transcription...');
+                fullTranscript = await this.getSegmentedTranscript(audioFilePath, duration, progressCallback, options.transcriptionPrompt);
             }
             else {
                 // Get transcript for short audio
-                console.log('Transcribing short audio...');
-                fullTranscript = await this.getShortAudioTranscript(audioFilePath, progressCallback);
+                console.error('Transcribing short audio...');
+                fullTranscript = await this.getShortAudioTranscript(audioFilePath, progressCallback, options.transcriptionPrompt);
+            }
+            if (options.transcriptOnly) {
+                if (progressCallback) {
+                    progressCallback(100, 'Transcript ready');
+                }
+                return transcriptOnlyResult(fullTranscript);
             }
             // Step 2: Generate summary, key points, action items from transcript
             if (progressCallback) {
                 progressCallback(85, 'Generating summary and key points...');
             }
-            const summaryPrompt = customSummaryPrompt ||
+            const basePrompt = customSummaryPrompt ||
                 `Based on this meeting transcript, provide:
 
 1. A concise meeting title in Korean (10-20 characters that captures the main topic)
@@ -263,6 +377,9 @@ Return as JSON:
   "actionItems": ["action 1", "action 2"],
   "emoji": "📝"
 }`;
+            const enrichableNotes = (liveNotes ?? []).filter((n) => (n.text ?? '').trim().length > 0);
+            const highlightsBlock = buildHighlightsPromptBlock(enrichableNotes);
+            const summaryPrompt = highlightsBlock ? `${basePrompt}\n\n${highlightsBlock}` : basePrompt;
             const summaryResult = await this.ai.models.generateContent({
                 model: this.proModel,
                 contents: [{ role: 'user', parts: [{ text: summaryPrompt }, { text: fullTranscript }] }],
@@ -286,11 +403,14 @@ Return as JSON:
                 'keyPoints',
                 'actionItems',
                 'emoji',
+                'highlights',
             ]);
             const customFields = {};
+            let rawHighlights;
             try {
                 const parsed = JSON.parse(summaryText);
                 summaryData = parsed;
+                rawHighlights = parsed.highlights;
                 // Extract custom fields (any keys not in the known set)
                 for (const [key, value] of Object.entries(parsed)) {
                     if (!KNOWN_KEYS.has(key)) {
@@ -306,6 +426,7 @@ Return as JSON:
                     summaryData.summary = summaryMatch[1].replace(/\\n/g, '\n');
                 }
             }
+            const highlights = mergeHighlights(liveNotes, rawHighlights);
             if (progressCallback) {
                 progressCallback(95, 'Finalizing results...');
             }
@@ -317,6 +438,7 @@ Return as JSON:
                 emoji: summaryData.emoji,
                 suggestedTitle: summaryData.suggestedTitle,
                 customFields: Object.keys(customFields).length > 0 ? customFields : undefined,
+                highlights,
             };
         }
         catch (error) {
@@ -325,7 +447,7 @@ Return as JSON:
         }
     }
     // Get transcript for short audio files
-    async getShortAudioTranscript(audioFilePath, progressCallback) {
+    async getShortAudioTranscript(audioFilePath, progressCallback, customPrompt) {
         try {
             const stats = fs.statSync(audioFilePath);
             const fileSizeInMB = stats.size / (1024 * 1024);
@@ -335,7 +457,7 @@ Return as JSON:
             // Use Files API for files over 20MB
             let fileUri = null;
             if (fileSizeInMB > 20) {
-                console.log('File is over 20MB, using Files API for upload...');
+                console.error('File is over 20MB, using Files API for upload...');
                 if (progressCallback) {
                     progressCallback(25, 'Uploading large file to Gemini...');
                 }
@@ -349,7 +471,7 @@ Return as JSON:
                 let file = await this.ai.files.get({ name: uploadResult.name || '' });
                 let retries = 0;
                 while (file.state === 'PROCESSING' && retries < 30) {
-                    console.log(`Waiting for file to be processed... (attempt ${retries + 1}/30)`);
+                    console.error(`Waiting for file to be processed... (attempt ${retries + 1}/30)`);
                     await new Promise((resolve) => setTimeout(resolve, 2000));
                     file = await this.ai.files.get({ name: uploadResult.name || '' });
                     retries++;
@@ -361,28 +483,7 @@ Return as JSON:
             if (progressCallback) {
                 progressCallback(50, 'Transcribing audio...');
             }
-            const transcriptPrompt = `${this.buildGlossaryBlock()}Please transcribe this audio recording with proper speaker identification.
-
-Format requirements:
-1. IDENTIFY different speakers and label them as 참가자1, 참가자2, etc.
-2. Each speaker's turn MUST start on a NEW LINE
-3. Format: 참가자X: [what they said]
-4. Add a blank line between different speakers
-
-Example format:
-참가자1: 안녕하세요, 오늘 회의를 시작하겠습니다.
-
-참가자2: 네, 준비됐습니다.
-
-참가자1: 첫 번째 안건은...
-
-IMPORTANT:
-- You MUST identify and differentiate between speakers
-- Each speaker turn MUST start on a new line
-- Add blank line between different speakers
-- DO NOT include timestamps
-- Keep the transcription in the original spoken language
-- Return ONLY the transcription text, no JSON formatting`;
+            const transcriptPrompt = `${this.buildGlossaryBlock()}${customPrompt ?? DEFAULT_TRANSCRIPT_PROMPT}`;
             let result;
             if (fileUri) {
                 const mimeType = (0, audioFormats_1.mimeTypeForExtension)(path.extname(audioFilePath));
@@ -453,38 +554,19 @@ IMPORTANT:
         return `[Segment ${segmentIndex + 1}: ${this.formatTime(segmentStartTime)} ~ ${this.formatTime(segmentEndTime)}]\n\n`;
     }
     // Create prompt for segment transcription
-    createSegmentPrompt(segmentIndex, totalSegments) {
-        return `${this.buildGlossaryBlock()}Please transcribe audio segment ${segmentIndex + 1} of ${totalSegments} with proper speaker identification.
-
-Format requirements:
-1. IDENTIFY different speakers and label them as 참가자1, 참가자2, etc.
-2. Each speaker's turn MUST start on a NEW LINE
-3. Format: 참가자X: [what they said]
-4. Add a blank line between different speakers
-
-Example format:
-참가자1: 안녕하세요, 오늘 회의를 시작하겠습니다.
-
-참가자2: 네, 준비됐습니다.
-
-참가자1: 첫 번째 안건은...
-
-IMPORTANT:
-- You MUST identify and differentiate between speakers
-- Each speaker turn MUST start on a new line
-- Add blank line between different speakers
-- DO NOT include timestamps
-- Keep the transcription in the original spoken language
-- Return ONLY the transcription text, no JSON formatting`;
+    createSegmentPrompt(segmentIndex, totalSegments, customPrompt) {
+        const positional = `[Audio segment ${segmentIndex + 1} of ${totalSegments}]\n\n`;
+        const body = customPrompt ?? DEFAULT_TRANSCRIPT_PROMPT;
+        return `${this.buildGlossaryBlock()}${positional}${body}`;
     }
     // Transcribe a single segment with retry logic
-    async transcribeSingleSegment(segmentFile, segmentIndex, totalSegments, segmentStartTime, segmentEndTime) {
+    async transcribeSingleSegment(segmentFile, segmentIndex, totalSegments, segmentStartTime, segmentEndTime, customPrompt) {
         const maxRetries = 3;
         let lastError = null;
-        const segmentPrompt = this.createSegmentPrompt(segmentIndex, totalSegments);
+        const segmentPrompt = this.createSegmentPrompt(segmentIndex, totalSegments, customPrompt);
         for (let attempt = 1; attempt <= maxRetries; attempt++) {
             try {
-                console.log(`Starting transcription for segment ${segmentIndex + 1}/${totalSegments} (attempt ${attempt}/${maxRetries})...`);
+                console.error(`Starting transcription for segment ${segmentIndex + 1}/${totalSegments} (attempt ${attempt}/${maxRetries})...`);
                 const audioData = fs.readFileSync(segmentFile);
                 const base64Audio = audioData.toString('base64');
                 const mimeType = (0, audioFormats_1.mimeTypeForExtension)(path.extname(segmentFile));
@@ -510,7 +592,7 @@ IMPORTANT:
                     },
                 });
                 const transcript = result.text || '';
-                console.log(`Completed transcription for segment ${segmentIndex + 1}/${totalSegments}`);
+                console.error(`Completed transcription for segment ${segmentIndex + 1}/${totalSegments}`);
                 // Add segment time range header
                 const segmentHeader = this.createSegmentHeader(segmentIndex, segmentStartTime, segmentEndTime);
                 return {
@@ -524,7 +606,7 @@ IMPORTANT:
                 if (attempt < maxRetries) {
                     // Wait before retry with exponential backoff
                     const retryDelay = Math.min(1000 * 2 ** (attempt - 1), 10000); // Max 10 seconds
-                    console.log(`Retrying segment ${segmentIndex + 1} in ${retryDelay}ms...`);
+                    console.error(`Retrying segment ${segmentIndex + 1} in ${retryDelay}ms...`);
                     await new Promise((resolve) => setTimeout(resolve, retryDelay));
                 }
             }
@@ -537,7 +619,7 @@ IMPORTANT:
         };
     }
     // Get segmented transcript (renamed from transcribeAudioSegmented)
-    async getSegmentedTranscript(audioFilePath, duration, progressCallback) {
+    async getSegmentedTranscript(audioFilePath, duration, progressCallback, customPrompt) {
         try {
             // Split audio into 5-minute segments
             const segmentFiles = await this.splitAudioIntoSegments(audioFilePath, 300);
@@ -548,7 +630,7 @@ IMPORTANT:
             const transcriptionPromises = segmentFiles.map(async (segmentFile, i) => {
                 const segmentStartTime = i * 300; // 5 minutes in seconds
                 const segmentEndTime = Math.min(segmentStartTime + 300, duration);
-                return this.transcribeSingleSegment(segmentFile, i, segmentFiles.length, segmentStartTime, segmentEndTime);
+                return this.transcribeSingleSegment(segmentFile, i, segmentFiles.length, segmentStartTime, segmentEndTime, customPrompt);
             });
             // Track progress of concurrent transcriptions
             let completedCount = 0;

package/dist/main.js

@@ -424,7 +424,7 @@ electron_1.app.whenReady().then(() => {
                     },
                 },
                 {
-                    label: 'Check for Updates...',
+                    label: autoUpdaterService_1.autoUpdaterService.getManualUpdateLabel(),
                     click: () => {
                         autoUpdaterService_1.autoUpdaterService.checkForUpdatesManually();
                     },
@@ -439,7 +439,7 @@ electron_1.app.whenReady().then(() => {
                 { role: 'about' },
                 { type: 'separator' },
                 {
-                    label: 'Check for Updates...',
+                    label: autoUpdaterService_1.autoUpdaterService.getManualUpdateLabel(),
                     click: () => {
                         autoUpdaterService_1.autoUpdaterService.checkForUpdatesManually();
                     },
@@ -1001,7 +1001,7 @@ electron_1.ipcMain.on('recording-chunk', (_event, data) => {
         console.error('Invalid chunk payload:', error);
     }
 });
-electron_1.ipcMain.handle('stop-recording', async () => {
+electron_1.ipcMain.handle('stop-recording', async (_, opts) => {
     try {
         finalizeRecordingSession();
         const result = await audioRecorder.stopRecording();
@@ -1014,6 +1014,18 @@ electron_1.ipcMain.handle('stop-recording', async () => {
                 // Silently skip if ffmpeg isn't available — file still plays, transcription
                 // pipeline is unaffected.
                 await remuxRecordingHeader(result.filePath);
+                // Persist live notes alongside the audio so they survive even if the
+                // user transcribes later (auto-mode off). transcribe-audio falls back
+                // to this when its own arg is missing.
+                const liveNotes = sanitizeLiveNotes(opts?.liveNotes);
+                if (liveNotes && liveNotes.length > 0) {
+                    try {
+                        await metadataService_1.metadataService.saveMetadata(result.filePath, { liveNotes });
+                    }
+                    catch (err) {
+                        console.error('Failed to persist live notes to metadata:', err);
+                    }
+                }
             }
         }
         return result;
@@ -1108,6 +1120,31 @@ function isContainedTranscriptionPath(folderPath) {
     const resolved = path.resolve(folderPath);
     return resolved === root || resolved.startsWith(root + path.sep);
 }
+// Validate + normalize the renderer's live-notes payload before it touches disk.
+// Renderer state is untrusted (compromised content scripts, future agent flows)
+// so this enforces shape + caps text length to keep summary.md/Notion sane.
+const LIVE_NOTE_MAX_TEXT = 2000;
+const LIVE_NOTE_MAX_COUNT = 500;
+function sanitizeLiveNotes(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const out = [];
+    for (const item of raw) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const offsetMs = Number(item.offsetMs);
+        const text = item.text;
+        if (!Number.isFinite(offsetMs))
+            continue;
+        out.push({
+            offsetMs: Math.max(0, Math.floor(offsetMs)),
+            text: typeof text === 'string' ? text.slice(0, LIVE_NOTE_MAX_TEXT) : '',
+        });
+        if (out.length >= LIVE_NOTE_MAX_COUNT)
+            break;
+    }
+    return out.length > 0 ? out : undefined;
+}
 // Tell the renderer the config has changed out-of-band so it can re-read and
 // re-render its UI state (toggle checkboxes etc.). Used by the agent flow.
 function broadcastConfigChanged() {
@@ -1182,9 +1219,24 @@ electron_1.ipcMain.handle('get-meeting-status', async () => {
     };
 });
 // Transcription handler
-electron_1.ipcMain.handle('transcribe-audio', async (_, filePath) => {
+electron_1.ipcMain.handle('transcribe-audio', async (_, filePath, liveNotesRaw) => {
     try {
         console.log('Transcription requested for:', filePath);
+        let liveNotes = sanitizeLiveNotes(liveNotesRaw);
+        if (!liveNotes || liveNotes.length === 0) {
+            // Fall back to whatever stop-recording persisted -- covers the
+            // record-now-transcribe-later flow when auto-mode is off.
+            try {
+                const existing = await metadataService_1.metadataService.getMetadata(filePath);
+                const fromMetadata = sanitizeLiveNotes(existing?.liveNotes);
+                if (fromMetadata && fromMetadata.length > 0) {
+                    liveNotes = fromMetadata;
+                }
+            }
+            catch (err) {
+                console.warn('Failed to read live notes from metadata:', err);
+            }
+        }
         // Send progress update
         if (mainWindow) {
             mainWindow.webContents.send('transcription-progress', {
@@ -1216,9 +1268,14 @@ electron_1.ipcMain.handle('transcribe-audio', async (_, filePath) => {
             }
         };
         const summaryPrompt = configService.getSummaryPrompt();
-        const result = await geminiService.transcribeAudio(filePath, progressCallback, summaryPrompt);
+        const result = await geminiService.transcribeAudio(filePath, progressCallback, summaryPrompt, liveNotes);
         console.log('Transcription completed successfully');
         console.log('Saving metadata for:', filePath);
+        // Attach renderer-captured notes so downstream consumers (Notion upload,
+        // re-render in the modal) can read them off the result object.
+        if (liveNotes && liveNotes.length > 0) {
+            result.liveNotes = liveNotes;
+        }
         // Save transcription files (summary.md + transcript.md)
         const title = result.suggestedTitle || path.basename(filePath, path.extname(filePath));
         let transcriptionPath;
@@ -1228,6 +1285,7 @@ electron_1.ipcMain.handle('transcribe-audio', async (_, filePath) => {
                 result,
                 audioFilePath: filePath,
                 dataPath: electron_1.app.getPath('userData'),
+                liveNotes,
             });
             console.log('Transcription saved to:', transcriptionPath);
         }
@@ -1242,6 +1300,7 @@ electron_1.ipcMain.handle('transcribe-audio', async (_, filePath) => {
                     suggestedTitle: result.suggestedTitle,
                     transcriptionPath,
                     customFields: result.customFields,
+                    liveNotes,
                     transcribedAt: new Date().toISOString(),
                 });
             }
@@ -1255,6 +1314,7 @@ electron_1.ipcMain.handle('transcribe-audio', async (_, filePath) => {
                     keyPoints: result.keyPoints,
                     actionItems: result.actionItems,
                     customFields: result.customFields,
+                    liveNotes,
                     transcribedAt: new Date().toISOString(),
                 });
             }
@@ -1413,6 +1473,8 @@ electron_1.ipcMain.handle('get-metadata', async (_, filePath) => {
                         actionItems: transcription.actionItems,
                         customFields: transcription.customFields ?? metadata.customFields,
                         emoji: transcription.emoji,
+                        liveNotes: transcription.liveNotes ?? metadata.liveNotes,
+                        highlights: transcription.highlights,
                         notionPageUrl: transcription.notionPageUrl,
                         slackSentAt: transcription.slackSentAt,
                         slackError: transcription.slackError,
@@ -1512,33 +1574,40 @@ electron_1.ipcMain.handle('get-recordings', async () => {
         }
         // Read all files in the recordings directory
         const files = fs.readdirSync(recordingsDir);
-        // Filter for audio files and get their stats
-        const recordings = files
-            .filter((file) => {
-            // Filter out segment files
+        // Filter for audio files and get their stats. Skip per-file races so one
+        // deleted recording does not make the whole list fail.
+        const recordings = [];
+        for (const file of files) {
             if (file.includes('_segment_'))
-                return false;
-            return (0, audioFormats_1.isSupportedAudioExtension)(path.extname(file));
-        })
-            .map((file) => {
+                continue;
+            if (!(0, audioFormats_1.isSupportedAudioExtension)(path.extname(file)))
+                continue;
             const filePath = path.join(recordingsDir, file);
-            const stats = fs.statSync(filePath);
+            let stats;
+            try {
+                stats = fs.statSync(filePath);
+            }
+            catch (err) {
+                if (err.code === 'ENOENT')
+                    continue;
+                throw err;
+            }
             // Extract title from filename (format: title_timestamp.ext)
             const nameWithoutExt = path.basename(file, path.extname(file));
             const parts = nameWithoutExt.split('_');
             const timestamp = parts.pop(); // Remove timestamp
             const title = parts.join('_') || 'Untitled';
-            return {
+            recordings.push({
                 filename: file,
                 path: filePath,
-                title: title,
-                timestamp: timestamp,
+                title,
+                timestamp,
                 size: stats.size,
                 createdAt: stats.birthtime,
                 modifiedAt: stats.mtime,
-            };
-        })
-            .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime()); // Sort by newest first
+            });
+        }
+        recordings.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime()); // Sort by newest first
         return { success: true, recordings };
     }
     catch (error) {

package/dist/outputService.js

@@ -33,12 +33,15 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatOffsetTimestamp = formatOffsetTimestamp;
 exports.sanitizeForPath = sanitizeForPath;
 exports.formatTimestamp = formatTimestamp;
 exports.camelToLabel = camelToLabel;
 exports.formatSummary = formatSummary;
 exports.formatTranscript = formatTranscript;
 exports.parseFrontmatter = parseFrontmatter;
+exports.parseLiveNotesField = parseLiveNotesField;
+exports.parseHighlightsField = parseHighlightsField;
 exports.getTranscriptionsDir = getTranscriptionsDir;
 exports.saveTranscription = saveTranscription;
 exports.listTranscriptions = listTranscriptions;
@@ -46,6 +49,22 @@ exports.readTranscription = readTranscription;
 exports.updateTranscriptionStatus = updateTranscriptionStatus;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+/**
+ * Format a millisecond offset as `mm:ss` (or `hh:mm:ss` when the offset crosses
+ * one hour) — used by every Highlights-rendering sink (summary.md, Notion,
+ * modal, CLI) and by the Gemini prompt so the LLM sees the same coordinate
+ * system as the saved output.
+ */
+function formatOffsetTimestamp(offsetMs) {
+    const totalSeconds = Math.max(0, Math.floor(offsetMs / 1000));
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const pad = (n) => String(n).padStart(2, '0');
+    return hours > 0
+        ? `${pad(hours)}:${pad(minutes)}:${pad(seconds)}`
+        : `${pad(minutes)}:${pad(seconds)}`;
+}
 function sanitizeForPath(name) {
     return name
         .replace(/[\/\\:*?"<>|]/g, '_')
@@ -69,7 +88,7 @@ function camelToLabel(key) {
         .replace(/^./, (s) => s.toUpperCase())
         .trim();
 }
-function formatSummary(result, title, mergedFrom) {
+function formatSummary(result, title, mergedFrom, liveNotes, highlights) {
     const lines = [];
     lines.push(`# ${title}\n`);
     if (mergedFrom?.length) {
@@ -98,6 +117,37 @@ function formatSummary(result, title, mergedFrom) {
         }
         lines.push('');
     }
+    // Prefer the AI-enriched "highlights" view when present -- it carries the
+    // same user notes plus per-moment subtitle/bullets. Fall back to the bare
+    // bullet list of liveNotes when Gemini didn't produce highlights.
+    const enriched = highlights && highlights.length > 0 ? highlights : null;
+    if (enriched || liveNotes?.length) {
+        lines.push('## 🗒️ Highlights\n');
+        if (enriched) {
+            for (const h of enriched) {
+                const ts = formatOffsetTimestamp(h.offsetMs);
+                const title = (h.userText ?? '').trim();
+                lines.push(title ? `### [${ts}] ${title}` : `### [${ts}] 🏴`);
+                if (h.subtitle?.trim()) {
+                    lines.push(`*${h.subtitle.trim()}*`);
+                }
+                if (h.bullets?.length) {
+                    lines.push('');
+                    for (const b of h.bullets)
+                        lines.push(`- ${b}`);
+                }
+                lines.push('');
+            }
+        }
+        else {
+            for (const note of liveNotes) {
+                const ts = formatOffsetTimestamp(note.offsetMs);
+                const text = note.text?.trim();
+                lines.push(text ? `- [${ts}] ${text}` : `- [${ts}] 🏴`);
+            }
+            lines.push('');
+        }
+    }
     if (result.customFields) {
         for (const [key, value] of Object.entries(result.customFields)) {
             const label = camelToLabel(key);
@@ -157,6 +207,12 @@ function buildFrontmatter(meta) {
         for (const src of meta.mergedFrom)
             lines.push(`  - ${yamlQuote(src)}`);
     }
+    if (meta.liveNotes?.length) {
+        lines.push(`liveNotes: ${yamlQuote(JSON.stringify(meta.liveNotes))}`);
+    }
+    if (meta.highlights?.length) {
+        lines.push(`highlights: ${yamlQuote(JSON.stringify(meta.highlights))}`);
+    }
     if (meta.notionPageUrl) {
         lines.push(`notionPageUrl: ${yamlQuote(meta.notionPageUrl)}`);
     }
@@ -222,6 +278,66 @@ function parseFrontmatter(content) {
     }
     return { meta, body };
 }
+function parseLiveNotesField(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+        if (!Array.isArray(parsed))
+            return undefined;
+        const notes = [];
+        for (const item of parsed) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const offsetMs = Number(item.offsetMs);
+            const text = item.text;
+            if (!Number.isFinite(offsetMs))
+                continue;
+            notes.push({
+                offsetMs: Math.max(0, Math.floor(offsetMs)),
+                text: typeof text === 'string' ? text : '',
+            });
+        }
+        return notes.length > 0 ? notes : undefined;
+    }
+    catch (e) {
+        console.warn('Failed to parse liveNotes from frontmatter:', e);
+        return undefined;
+    }
+}
+function parseHighlightsField(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
+        if (!Array.isArray(parsed))
+            return undefined;
+        const entries = [];
+        for (const item of parsed) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const offsetMs = Number(item.offsetMs);
+            if (!Number.isFinite(offsetMs))
+                continue;
+            const userText = item.userText;
+            const subtitle = item.subtitle;
+            const bullets = item.bullets;
+            entries.push({
+                offsetMs: Math.max(0, Math.floor(offsetMs)),
+                userText: typeof userText === 'string' ? userText : '',
+                subtitle: typeof subtitle === 'string' && subtitle.trim().length > 0 ? subtitle : undefined,
+                bullets: Array.isArray(bullets)
+                    ? bullets.map((b) => (typeof b === 'string' ? b : '')).filter((b) => b.length > 0)
+                    : undefined,
+            });
+        }
+        return entries.length > 0 ? entries : undefined;
+    }
+    catch (e) {
+        console.warn('Failed to parse highlights from frontmatter:', e);
+        return undefined;
+    }
+}
 function yamlUnquote(value) {
     if (value.startsWith('"') && value.endsWith('"')) {
         return value
@@ -236,6 +352,9 @@ function yamlUnquote(value) {
 function getTranscriptionsDir(dataPath) {
     return path.join(dataPath, 'transcriptions');
 }
+function getResultHighlights(result) {
+    return result.highlights && result.highlights.length > 0 ? result.highlights : undefined;
+}
 /**
  * Save transcription as summary.md + transcript.md in a timestamped folder.
  * Returns the created folder path.
@@ -246,6 +365,7 @@ function saveTranscription(opts) {
     const folderPath = path.join(parentDir, folderName);
     fs.mkdirSync(folderPath, { recursive: true });
     const transcribedAt = new Date().toISOString();
+    const highlights = getResultHighlights(opts.result);
     // summary.md with frontmatter (stores all raw data for machine reading)
     const frontmatter = buildFrontmatter({
         title: opts.title,
@@ -259,8 +379,10 @@ function saveTranscription(opts) {
         transcribedAt,
         emoji: opts.result.emoji,
         mergedFrom: opts.mergedFrom,
+        liveNotes: opts.liveNotes,
+        highlights,
     });
-    const summaryBody = formatSummary(opts.result, opts.title, opts.mergedFrom);
+    const summaryBody = formatSummary(opts.result, opts.title, opts.mergedFrom, opts.liveNotes, highlights);
     fs.writeFileSync(path.join(folderPath, 'summary.md'), `${frontmatter}\n\n${summaryBody}`, 'utf-8');
     // transcript.md
     fs.writeFileSync(path.join(folderPath, 'transcript.md'), formatTranscript(opts.result, opts.title), 'utf-8');
@@ -355,6 +477,8 @@ async function readTranscription(folderPath) {
                 console.warn('Failed to parse customFields from frontmatter:', e);
             }
         }
+        const liveNotes = parseLiveNotesField(meta.liveNotes);
+        const highlights = parseHighlightsField(meta.highlights);
         return {
             title: meta.title || path.basename(folderPath),
             suggestedTitle: meta.suggestedTitle,
@@ -367,6 +491,8 @@ async function readTranscription(folderPath) {
             transcribedAt: meta.transcribedAt,
             emoji: meta.emoji,
             mergedFrom: meta.mergedFrom,
+            liveNotes,
+            highlights,
             notionPageUrl: meta.notionPageUrl,
             slackSentAt: meta.slackSentAt,
             slackError: meta.slackError,
@@ -397,6 +523,8 @@ async function updateTranscriptionStatus(folderPath, updates) {
             customFields = undefined;
         }
     }
+    const liveNotes = parseLiveNotesField(meta.liveNotes);
+    const highlights = parseHighlightsField(meta.highlights);
     // Spread first so any unknown frontmatter keys (added by future writers, or
     // by hand-edits) survive the round-trip; named fields override with proper
     // typing and defaults.
@@ -407,6 +535,8 @@ async function updateTranscriptionStatus(folderPath, updates) {
         transcript: meta.transcript || '',
         transcribedAt: meta.transcribedAt || new Date().toISOString(),
         customFields,
+        liveNotes,
+        highlights,
     };
     applyStatusUpdate(merged, 'notionPageUrl', updates.notionPageUrl);
     applyStatusUpdate(merged, 'slackSentAt', updates.slackSentAt);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "listener-ai",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "description": "A lightweight desktop application for recording and transcribing meetings with AI-powered notes.",
   "main": "dist/main.js",
   "bin": {
@@ -29,7 +29,7 @@
     "lint:fix": "oxlint --fix src renderer scripts",
     "format": "oxfmt 'src/**/*.ts' 'renderer/**/*.ts' 'renderer/**/*.tsx' 'scripts/**/*.js' 'scripts/**/*.ts'",
     "format:check": "oxfmt --check 'src/**/*.ts' 'renderer/**/*.ts' 'renderer/**/*.tsx' 'scripts/**/*.js' 'scripts/**/*.ts'",
-    "test": "tsc && node --test dist/meetingDetectorService.test.js dist/searchService.test.js dist/agentService.test.js dist/simpleAudioRecorder.test.js dist/outputService.test.js dist/slackService.test.js dist/services/audioConcatService.test.js dist/cli.test.js",
+    "test": "tsc && node --test \"dist/**/*.test.js\"",
     "dist": "pnpm run build && electron-builder",
     "dist:mac": "pnpm run build && electron-builder --mac",
     "dist:mac-x64": "pnpm run build && electron-builder --mac --x64",