task-summary-extractor 8.3.0 → 9.0.0

package/src/services/doc-parser.js

@@ -0,0 +1,346 @@
+/**
+ * Document parser service — converts rich document formats (DOCX, DOC, XLSX,
+ * PPTX, RTF, ODT, EPUB, HTML) to plain text for Gemini AI ingestion.
+ *
+ * Strategy:
+ *  1. mammoth — DOCX → clean text (best quality, preserves structure)
+ *  2. xlsx    — XLSX/XLS/CSV → text tables
+ *  3. officeparser — DOC, PPTX, ODT, RTF, EPUB (broad fallback)
+ *  4. Built-in — HTML → text (regex strip), JSON/XML → passthrough
+ *
+ * All parsers return plain text. Binary files that can't be parsed
+ * are skipped with a warning (no crash).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { c } = require('../utils/colors');
+
+// ======================== PARSER REGISTRY ========================
+
+/**
+ * Extensions handled by each parser strategy.
+ * Order matters: first match wins.
+ */
+const PARSER_MAP = {
+  // mammoth — high-quality DOCX conversion
+  '.docx': 'mammoth',
+
+  // xlsx — Excel spreadsheets
+  '.xlsx': 'xlsx',
+  '.xls':  'xlsx',
+
+  // officeparser — broad Office/ODF/EPUB support
+  '.doc':  'officeparser',
+  '.pptx': 'officeparser',
+  '.ppt':  'officeparser',
+  '.odt':  'officeparser',
+  '.odp':  'officeparser',
+  '.ods':  'officeparser',
+  '.rtf':  'officeparser',
+  '.epub': 'officeparser',
+
+  // Built-in parsers
+  '.html': 'html',
+  '.htm':  'html',
+  '.xml':  'builtin-text',
+  '.json': 'builtin-text',
+};
+
+/**
+ * All extensions this module can parse (union of PARSER_MAP keys).
+ * Exported for config.js to extend DOC_EXTS and remove GEMINI_UNSUPPORTED.
+ */
+const PARSEABLE_EXTS = Object.keys(PARSER_MAP);
+
+/**
+ * Extensions that were previously unsupported but are now parseable.
+ * Used to update GEMINI_UNSUPPORTED → INLINE_TEXT_EXTS migration.
+ */
+const NEWLY_SUPPORTED_EXTS = ['.docx', '.doc', '.xlsx', '.xls', '.pptx', '.ppt', '.odt', '.odp', '.ods', '.rtf', '.epub', '.html', '.htm'];
+
+// ======================== MAMMOTH (DOCX) ========================
+
+/**
+ * Parse a DOCX file to plain text using mammoth.
+ * Falls back to raw text extraction if styled conversion fails.
+ *
+ * @param {string} filePath - Absolute path to .docx file
+ * @returns {Promise<{ text: string, warnings: string[] }>}
+ */
+async function parseDocx(filePath) {
+  const mammoth = require('mammoth');
+  const warnings = [];
+
+  try {
+    // First try: extract raw text (most reliable, preserves all content)
+    const result = await mammoth.extractRawText({ path: filePath });
+    if (result.messages && result.messages.length > 0) {
+      for (const msg of result.messages) {
+        warnings.push(`mammoth: ${msg.message}`);
+      }
+    }
+
+    let text = (result.value || '').trim();
+
+    // If raw text is empty, try HTML conversion as fallback
+    if (!text) {
+      const htmlResult = await mammoth.convertToHtml({ path: filePath });
+      text = stripHtml(htmlResult.value || '');
+      if (htmlResult.messages) {
+        for (const msg of htmlResult.messages) {
+          warnings.push(`mammoth-html: ${msg.message}`);
+        }
+      }
+    }
+
+    return { text, warnings };
+  } catch (err) {
+    return { text: '', warnings: [`mammoth parse failed: ${err.message}`] };
+  }
+}
+
+// ======================== XLSX (Excel) ========================
+
+/**
+ * Parse an Excel file (XLSX/XLS) to text tables.
+ * Each sheet becomes a section with rows formatted as pipe-delimited tables.
+ *
+ * @param {string} filePath - Absolute path to .xlsx/.xls file
+ * @returns {Promise<{ text: string, warnings: string[] }>}
+ */
+async function parseExcel(filePath) {
+  const XLSX = require('xlsx');
+  const warnings = [];
+
+  try {
+    const workbook = XLSX.readFile(filePath, { type: 'file' });
+    const sections = [];
+
+    for (const sheetName of workbook.SheetNames) {
+      const sheet = workbook.Sheets[sheetName];
+      if (!sheet) continue;
+
+      // Convert sheet to array of arrays
+      const rows = XLSX.utils.sheet_to_json(sheet, { header: 1, defval: '' });
+      if (rows.length === 0) continue;
+
+      const lines = [`=== Sheet: ${sheetName} ===`];
+
+      // Format as pipe-delimited table (Gemini reads this well)
+      for (const row of rows) {
+        const cells = row.map(cell => {
+          if (cell === null || cell === undefined) return '';
+          return String(cell).replace(/\|/g, '\\|').replace(/\n/g, ' ');
+        });
+        lines.push(`| ${cells.join(' | ')} |`);
+      }
+
+      sections.push(lines.join('\n'));
+    }
+
+    const text = sections.join('\n\n');
+    if (!text) warnings.push('Excel file has no readable content');
+
+    return { text, warnings };
+  } catch (err) {
+    return { text: '', warnings: [`xlsx parse failed: ${err.message}`] };
+  }
+}
+
+// ======================== OFFICEPARSER (DOC, PPTX, ODT, RTF, EPUB) ========================
+
+/**
+ * Parse a document using officeparser (broad format support).
+ * Handles: .doc, .pptx, .ppt, .odt, .odp, .ods, .rtf, .epub
+ *
+ * @param {string} filePath - Absolute path to document
+ * @returns {Promise<{ text: string, warnings: string[] }>}
+ */
+async function parseWithOfficeParser(filePath) {
+  const officeparser = require('officeparser');
+  const warnings = [];
+
+  try {
+    const text = await officeparser.parseOfficeAsync(filePath);
+    if (!text || !text.trim()) {
+      warnings.push('officeparser returned empty text');
+    }
+    return { text: (text || '').trim(), warnings };
+  } catch (err) {
+    return { text: '', warnings: [`officeparser failed: ${err.message}`] };
+  }
+}
+
+// ======================== HTML STRIP ========================
+
+/**
+ * Strip HTML tags to extract plain text.
+ * Handles common elements: headings, paragraphs, lists, tables, breaks.
+ *
+ * @param {string} html - HTML content
+ * @returns {string} Plain text
+ */
+function stripHtml(html) {
+  if (!html) return '';
+
+  let text = html;
+
+  // Convert block elements to newlines
+  text = text.replace(/<\/(p|div|h[1-6]|li|tr|blockquote|section|article)>/gi, '\n');
+  text = text.replace(/<br\s*\/?>/gi, '\n');
+  text = text.replace(/<hr\s*\/?>/gi, '\n---\n');
+
+  // Convert list items
+  text = text.replace(/<li[^>]*>/gi, '- ');
+
+  // Convert headings to markdown-style
+  text = text.replace(/<h1[^>]*>/gi, '\n# ');
+  text = text.replace(/<h2[^>]*>/gi, '\n## ');
+  text = text.replace(/<h3[^>]*>/gi, '\n### ');
+  text = text.replace(/<h[4-6][^>]*>/gi, '\n#### ');
+
+  // Convert table cells
+  text = text.replace(/<td[^>]*>/gi, ' | ');
+  text = text.replace(/<th[^>]*>/gi, ' | ');
+
+  // Strip all remaining tags
+  text = text.replace(/<[^>]+>/g, '');
+
+  // Decode common HTML entities
+  text = text.replace(/&amp;/g, '&');
+  text = text.replace(/&lt;/g, '<');
+  text = text.replace(/&gt;/g, '>');
+  text = text.replace(/&quot;/g, '"');
+  text = text.replace(/&#39;/g, "'");
+  text = text.replace(/&nbsp;/g, ' ');
+
+  // Clean up excessive whitespace
+  text = text.replace(/[ \t]+/g, ' ');
+  text = text.replace(/\n{3,}/g, '\n\n');
+  text = text.trim();
+
+  return text;
+}
+
+// ======================== BUILT-IN TEXT ========================
+
+/**
+ * Read a file as UTF-8 text (for JSON, XML, etc.).
+ * @param {string} filePath
+ * @returns {Promise<{ text: string, warnings: string[] }>}
+ */
+async function parseBuiltinText(filePath) {
+  try {
+    const content = await fs.promises.readFile(filePath, 'utf8');
+    return { text: content.trim(), warnings: [] };
+  } catch (err) {
+    return { text: '', warnings: [`Failed to read file: ${err.message}`] };
+  }
+}
+
+/**
+ * Parse an HTML file by reading it and stripping tags.
+ * @param {string} filePath
+ * @returns {Promise<{ text: string, warnings: string[] }>}
+ */
+async function parseHtmlFile(filePath) {
+  try {
+    const html = await fs.promises.readFile(filePath, 'utf8');
+    const text = stripHtml(html);
+    return { text, warnings: [] };
+  } catch (err) {
+    return { text: '', warnings: [`Failed to read HTML: ${err.message}`] };
+  }
+}
+
+// ======================== MAIN PARSE FUNCTION ========================
+
+/**
+ * Parse any supported document to plain text.
+ *
+ * @param {string} filePath - Absolute path to the document
+ * @param {object} [opts]
+ * @param {number} [opts.maxLength] - Truncate output to this many characters (default: unlimited)
+ * @param {boolean} [opts.silent] - Suppress console warnings (default: false)
+ * @returns {Promise<{ text: string, ext: string, parser: string, warnings: string[], success: boolean }>}
+ */
+async function parseDocument(filePath, opts = {}) {
+  const ext = path.extname(filePath).toLowerCase();
+  const parser = PARSER_MAP[ext];
+
+  if (!parser) {
+    return {
+      text: '',
+      ext,
+      parser: 'none',
+      warnings: [`No parser available for extension "${ext}"`],
+      success: false,
+    };
+  }
+
+  let result;
+  switch (parser) {
+    case 'mammoth':
+      result = await parseDocx(filePath);
+      break;
+    case 'xlsx':
+      result = await parseExcel(filePath);
+      break;
+    case 'officeparser':
+      result = await parseWithOfficeParser(filePath);
+      break;
+    case 'html':
+      result = await parseHtmlFile(filePath);
+      break;
+    case 'builtin-text':
+      result = await parseBuiltinText(filePath);
+      break;
+    default:
+      result = { text: '', warnings: [`Unknown parser "${parser}" for "${ext}"`] };
+  }
+
+  let text = result.text || '';
+  const warnings = result.warnings || [];
+
+  // Truncate if requested
+  if (opts.maxLength && text.length > opts.maxLength) {
+    text = text.slice(0, opts.maxLength) + '\n\n... (truncated — original was ' + result.text.length.toLocaleString() + ' chars)';
+    warnings.push(`Output truncated to ${opts.maxLength.toLocaleString()} chars`);
+  }
+
+  // Log warnings if not silent
+  if (!opts.silent && warnings.length > 0) {
+    for (const w of warnings) {
+      console.warn(`    ${c.warn(`${path.basename(filePath)}: ${w}`)}`);
+    }
+  }
+
+  return {
+    text,
+    ext,
+    parser,
+    warnings,
+    success: text.length > 0,
+  };
+}
+
+/**
+ * Check if a file extension is parseable by this module.
+ * @param {string} ext - Extension including dot (e.g. '.docx')
+ * @returns {boolean}
+ */
+function canParse(ext) {
+  return ext.toLowerCase() in PARSER_MAP;
+}
+
+module.exports = {
+  parseDocument,
+  canParse,
+  stripHtml,
+  PARSEABLE_EXTS,
+  NEWLY_SUPPORTED_EXTS,
+  PARSER_MAP,
+};

package/src/services/gemini.js

@@ -12,6 +12,7 @@ const {
   GEMINI_API_KEY,
   GEMINI_FILE_API_EXTS,
   INLINE_TEXT_EXTS,
+  DOC_PARSER_EXTS,
   GEMINI_UNSUPPORTED,
   MIME_MAP,
   GEMINI_POLL_TIMEOUT_MS,
@@ -19,6 +20,7 @@ const {
 // Access config.GEMINI_MODEL and config.GEMINI_CONTEXT_WINDOW at call time
 // (not destructured) so runtime model changes via setActiveModel() are visible.
 const { extractJson } = require('../utils/json-parser');
+const { parseDocument } = require('./doc-parser');
 const {
   selectDocsByBudget,
   sliceVttForSegment,
@@ -28,6 +30,7 @@ const {
 } = require('../utils/context-manager');
 const { formatHMS } = require('../utils/format');
 const { withRetry } = require('../utils/retry');
+const { c } = require('../utils/colors');
 
 // ======================== INIT ========================
 
@@ -60,7 +63,18 @@ async function prepareDocsForGemini(ai, docFileList) {
         console.log(`    Reading ${name} (inline text)...`);
         const content = await fs.promises.readFile(docPath, 'utf8');
         prepared.push({ type: 'inlineText', fileName: name, content });
-        console.log(`    ✓ ${name} ready (${(content.length / 1024).toFixed(1)} KB)`);
+        console.log(`    ${c.success(`${name} ready (${(content.length / 1024).toFixed(1)} KB)`)}`);
+      } else if (DOC_PARSER_EXTS.includes(ext)) {
+        // Binary document — convert to text via doc-parser
+        console.log(`    Parsing ${name} (${ext} → text)...`);
+        const result = await parseDocument(docPath, { silent: true });
+        if (result.success && result.text) {
+          prepared.push({ type: 'inlineText', fileName: name, content: result.text });
+          console.log(`    ${c.success(`${name} parsed (${(result.text.length / 1024).toFixed(1)} KB text extracted)`)}`);
+        } else {
+          const reason = result.warnings.length > 0 ? result.warnings[0] : 'empty output';
+          console.warn(`    ${c.warn(`${name} — parse failed (${reason}), will upload to Firebase only`)}`);
+        }
       } else if (GEMINI_FILE_API_EXTS.includes(ext)) {
         const mime = MIME_MAP[ext] || 'application/octet-stream';
         console.log(`    Uploading ${name} to Gemini File API...`);
@@ -76,7 +90,7 @@ async function prepareDocsForGemini(ai, docFileList) {
         const pollStart = Date.now();
         while (file.state === 'PROCESSING') {
           if (Date.now() - pollStart > GEMINI_POLL_TIMEOUT_MS) {
-            console.warn(`    ⚠ ${name} — polling timed out after ${(GEMINI_POLL_TIMEOUT_MS / 1000).toFixed(0)}s, skipping`);
+            console.warn(`    ${c.warn(`${name} — polling timed out after ${(GEMINI_POLL_TIMEOUT_MS / 1000).toFixed(0)}s, skipping`)}`);
             file = null;
             break;
           }
@@ -88,7 +102,7 @@ async function prepareDocsForGemini(ai, docFileList) {
         }
 
         if (!file || file.state === 'FAILED') {
-          console.warn(`    ⚠ ${name} — Gemini processing failed, skipping`);
+          console.warn(`    ${c.warn(`${name} — Gemini processing failed, skipping`)}`);
           continue;
         }
 
@@ -99,14 +113,14 @@ async function prepareDocsForGemini(ai, docFileList) {
           fileUri: file.uri,
           geminiFileName: file.name,
         });
-        console.log(`    ✓ ${name} ready (File API)`);
+        console.log(`    ${c.success(`${name} ready (File API)`)}`);
       } else if (GEMINI_UNSUPPORTED.includes(ext)) {
-        console.warn(`    ⚠ ${name} — format not supported by Gemini, will upload to Firebase only`);
+        console.warn(`    ${c.warn(`${name} — format not supported by Gemini, will upload to Firebase only`)}`);
       } else {
-        console.warn(`    ⚠ ${name} — unknown doc type, skipping`);
+        console.warn(`    ${c.warn(`${name} — unknown doc type, skipping`)}`);
       }
     } catch (err) {
-      console.warn(`    ⚠ ${name} — failed: ${err.message}`);
+      console.warn(`    ${c.warn(`${name} — failed: ${err.message}`)}`);
     }
   }
 
@@ -258,21 +272,10 @@ async function processWithGemini(ai, filePath, displayName, contextDocs = [], pr
   let file;
   let usedExternalUrl = false;
 
-  if (existingFileUri) {
-    // Strategy A: Reuse Gemini File API URI from a previous pass
-    file = { uri: existingFileUri, mimeType: existingFileMime, name: existingGeminiFileName, state: 'ACTIVE' };
-    console.log(`    Reusing Gemini File API URI (skip upload)`);
-  } else if (storageDownloadUrl) {
-    // Strategy B: Use Firebase Storage download URL as Gemini External URL
-    // Supported for models >= 2.5; limit 100MB per payload.
-    // Gemini fetches the file on-demand — no separate upload + polling needed.
-    file = { uri: storageDownloadUrl, mimeType: 'video/mp4', name: null, state: 'ACTIVE' };
-    usedExternalUrl = true;
-    console.log(`    Using Firebase Storage URL as external reference (skip Gemini upload)`);
-  } else {
-    // Strategy C: Upload to Gemini File API (default fallback)
+  // Helper: upload via Gemini File API with polling (Strategy C)
+  async function uploadViaFileApi() {
     console.log(`    Uploading to Gemini File API...`);
-    file = await withRetry(
+    let uploaded = await withRetry(
       () => ai.files.upload({
         file: filePath,
         config: { mimeType: 'video/mp4', displayName },
@@ -280,26 +283,51 @@ async function processWithGemini(ai, filePath, displayName, contextDocs = [], pr
       { label: `Gemini file upload (${displayName})`, maxRetries: 3 }
     );
 
-    // 3. Wait for processing (with polling + retry on get + timeout)
     let waited = 0;
     const pollStart = Date.now();
-    while (file.state === 'PROCESSING') {
+    while (uploaded.state === 'PROCESSING') {
       if (Date.now() - pollStart > GEMINI_POLL_TIMEOUT_MS) {
         throw new Error(`Gemini file processing timed out after ${(GEMINI_POLL_TIMEOUT_MS / 1000).toFixed(0)}s for ${displayName}. Try again or increase GEMINI_POLL_TIMEOUT_MS.`);
       }
       process.stdout.write(`    Processing${'.'.repeat((waited % 3) + 1)}   \r`);
       await new Promise(r => setTimeout(r, 5000));
       waited++;
-      file = await withRetry(
-        () => ai.files.get({ name: file.name }),
+      uploaded = await withRetry(
+        () => ai.files.get({ name: uploaded.name }),
         { label: 'Gemini file status check', maxRetries: 2, baseDelay: 1000 }
       );
     }
     console.log('    Processing complete.        ');
 
-    if (file.state === 'FAILED') {
-      throw new Error(`Gemini file processing failed for ${displayName}`);
+    if (uploaded.state === 'FAILED') {
+      throw new Error(`Gemini file processing failed for ${displayName}. The file may be corrupt or in an unsupported format — try re-compressing or converting to MP4.`);
     }
+    return uploaded;
+  }
+
+  const EXTERNAL_URL_MAX_BYTES = 20 * 1024 * 1024; // 20 MB — Gemini rejects HTTPS URLs for larger files
+
+  if (existingFileUri) {
+    // Strategy A: Reuse Gemini File API URI from a previous pass
+    file = { uri: existingFileUri, mimeType: existingFileMime, name: existingGeminiFileName, state: 'ACTIVE' };
+    console.log(`    Reusing Gemini File API URI (skip upload)`);
+  } else if (storageDownloadUrl) {
+    // Strategy B: Use Firebase Storage download URL as Gemini External URL
+    // Supported for models >= 2.5; Gemini rejects external HTTPS URLs for files > ~20 MB.
+    const fileSizeBytes = fs.existsSync(filePath) ? fs.statSync(filePath).size : 0;
+    if (fileSizeBytes > EXTERNAL_URL_MAX_BYTES) {
+      console.log(`    Segment too large for external URL (${(fileSizeBytes / 1048576).toFixed(1)} MB > 20 MB) — using File API upload`);
+      // file stays null → falls through to Strategy C below
+    } else {
+      file = { uri: storageDownloadUrl, mimeType: 'video/mp4', name: null, state: 'ACTIVE' };
+      usedExternalUrl = true;
+      console.log(`    Using Firebase Storage URL as external reference (skip Gemini upload)`);
+    }
+  }
+
+  if (!file) {
+    // Strategy C: Upload to Gemini File API (default fallback, or after B was skipped for large files)
+    file = await uploadViaFileApi();
   }
 
   // 4. Build content parts with SMART CONTEXT MANAGEMENT
@@ -375,7 +403,7 @@ async function processWithGemini(ai, filePath, displayName, contextDocs = [], pr
 
   contentParts.push({ text: promptText });
 
-  // 5. Send request (configurable thinking budget for complex multi-ticket analysis)
+  // 5. Send request (model uses its default thinking budget)
   const requestPayload = {
     model: config.GEMINI_MODEL,
     contents: [{ role: 'user', parts: contentParts }],
@@ -383,15 +411,50 @@ async function processWithGemini(ai, filePath, displayName, contextDocs = [], pr
       systemInstruction,
       maxOutputTokens: 65536,
       temperature: 0,
-      thinkingConfig: { thinkingBudget },
     },
   };
 
   const t0 = Date.now();
-  const response = await withRetry(
-    () => ai.models.generateContent(requestPayload),
-    { label: `Gemini segment analysis (${displayName})`, maxRetries: 2, baseDelay: 5000 }
-  );
+  let response;
+  try {
+    response = await withRetry(
+      () => ai.models.generateContent(requestPayload),
+      { label: `Gemini segment analysis (${displayName})`, maxRetries: 2, baseDelay: 5000 }
+    );
+  } catch (apiErr) {
+    const errMsg = apiErr.message || '';
+
+    // Automatic fallback: if external URL was rejected, retry via Gemini File API upload
+    if (usedExternalUrl && errMsg.includes('INVALID_ARGUMENT')) {
+      console.log(`    ${c.warn('External URL rejected by Gemini — falling back to File API upload...')}`);
+      try {
+        file = await uploadViaFileApi();
+        usedExternalUrl = false;
+        // Replace the video reference in contentParts[0]
+        contentParts[0] = { fileData: { mimeType: file.mimeType, fileUri: file.uri } };
+        requestPayload.contents[0].parts = contentParts;
+        response = await withRetry(
+          () => ai.models.generateContent(requestPayload),
+          { label: `Gemini segment analysis — File API retry (${displayName})`, maxRetries: 2, baseDelay: 5000 }
+        );
+        console.log(`    ${c.success('File API fallback succeeded')}`);
+      } catch (fallbackErr) {
+        console.error(`    ${c.error(`File API fallback also failed: ${fallbackErr.message}`)}`);
+        throw fallbackErr;
+      }
+    } else {
+      // Log request diagnostics for other errors to aid debugging
+      const partSummary = contentParts.map((p, i) => {
+        if (p.fileData) return `  [${i}] fileData: ${p.fileData.mimeType} → ${(p.fileData.fileUri || '').substring(0, 120)}`;
+        if (p.text) return `  [${i}] text: ${p.text.length} chars → ${p.text.substring(0, 80).replace(/\n/g, ' ')}...`;
+        return `  [${i}] unknown part`;
+      });
+      console.error(`    ${c.error('Request diagnostics:')}`);
+      console.error(`    Model: ${config.GEMINI_MODEL} | Parts: ${contentParts.length} | maxOutput: 65536`);
+      partSummary.forEach(s => console.error(`    ${s}`));
+      throw apiErr;
+    }
+  }
   const durationMs = Date.now() - t0;
 
   const rawText = response.text;
@@ -556,11 +619,6 @@ ${segmentDumps}`;
       systemInstruction: `${systemInstruction}\n\nYou are now in COMPILATION MODE — your job is to merge multiple segment analyses into one final unified output. Deduplicate, reconcile conflicts, and produce the definitive analysis. Output valid JSON only — no markdown fences.`,
       maxOutputTokens: 65536,
       temperature: 0,
-      // Thinking tokens share the maxOutputTokens pool in Gemini 2.5+ models.
-      // Default 10240 leaves ~55K for output — enough for full structured merge.
-      // Too low (4096) → model hits ceiling and produces minimal output.
-      // Too high (16384) → eats into output budget causing truncation.
-      thinkingConfig: { thinkingBudget: compilationThinking },
     },
   };
 
@@ -594,9 +652,9 @@ ${segmentDumps}`;
   const compiled = extractJson(rawText);
 
   if (!compiled) {
-    console.warn('  ⚠ Failed to parse compiled result — falling back to raw segment merge');
+    console.warn(`  ${c.warn('Failed to parse compiled result — falling back to raw segment merge')}`);
   } else {
-    console.log('  ✓ Final compilation complete');
+    console.log(`  ${c.success('Final compilation complete')}`);
   }
 
   return {
@@ -657,7 +715,7 @@ async function analyzeVideoForContext(ai, filePath, displayName, opts = {}) {
   console.log('    Processing complete.        ');
 
   if (file.state === 'FAILED') {
-    throw new Error(`Gemini file processing failed for ${displayName}`);
+    throw new Error(`Gemini file processing failed for ${displayName}. The file may be corrupt or in an unsupported format — try re-compressing or using a different segment.`);
   }
 
   // 3. Build prompt for comprehensive summary
@@ -701,7 +759,6 @@ FORMAT:
       systemInstruction: 'You are a meticulous video analyst. Produce comprehensive, detailed summaries that capture everything in the video. Write in clear Markdown prose.',
       maxOutputTokens: 32768,
       temperature: 0.1,
-      thinkingConfig: { thinkingBudget },
     },
   };
 
@@ -718,7 +775,7 @@ FORMAT:
   try {
     await ai.files.delete({ name: file.name });
   } catch (cleanupErr) {
-    console.warn(`    ⚠ Gemini file cleanup failed: ${cleanupErr.message}`);
+    console.warn(`    ${c.warn(`Gemini file cleanup failed: ${cleanupErr.message}`)}`);
   }
 
   const usage = response.usageMetadata || {};
@@ -730,7 +787,7 @@ FORMAT:
   };
 
   console.log(`    Tokens — input: ${tokenUsage.inputTokens.toLocaleString()} | output: ${tokenUsage.outputTokens.toLocaleString()} | thinking: ${tokenUsage.thoughtTokens.toLocaleString()}`);
-  console.log(`    ✓ Summary: ${summary.length.toLocaleString()} chars in ${(durationMs / 1000).toFixed(1)}s`);
+console.log(`    ${c.success(`Summary: ${summary.length.toLocaleString()} chars in ${(durationMs / 1000).toFixed(1)}s`)}`);
 
   return { summary, durationMs, tokenUsage };
 }