task-summary-extractor 9.4.0 → 9.5.0

package/.env.example

@@ -9,7 +9,7 @@ FIREBASE_MEASUREMENT_ID=G-XXXXXXXXXX
 
 # ======================== GEMINI AI ========================
 GEMINI_API_KEY=your_gemini_api_key
-GEMINI_MODEL=gemini-2.5-flash
+GEMINI_MODEL=gemini-2.5-flash-lite
 
 # ======================== VIDEO PROCESSING ========================
 # Speed multiplier (default: 1.6)

package/ARCHITECTURE.md

@@ -525,6 +525,7 @@ Directories skipped during recursive discovery: `node_modules`, `.git`, `compres
 | Stage | Skip Condition |
 |-------|----------------|
 | **Compression** | `compressed/{video}/segment_*.mp4` exist on disk |
+| **No-compress split** | `--no-compress` flag: raw keyframe split via `ffmpeg -c copy` (no re-encoding) |
 | **Firebase upload** | File already exists at `calls/{name}/segments/{video}/` (bypassed by `--force-upload`) |
 | **Storage URL → Gemini** | Firebase download URL available (bypassed by `--no-storage-url`) |
 | **Gemini analysis** | Run file exists in `gemini_runs/` AND user chooses not to re-analyze |
@@ -577,6 +578,11 @@ JSONL structured format includes phase spans with timing metrics for observabili
 | Sharpening | `unsharp=3:3:0.3` | Preserve text clarity |
 | x264 params | `aq-mode=3:deblock=-1,-1:psy-rd=1.0,0.0` | Text readability |
 | Audio | AAC, 64–128k, original sample rate | Clear speech |
+| Speed | 1.6× default (`--speed` flag, env `VIDEO_SPEED`) | Reduce tokens per segment |
+| Segment Duration | 280s default, compress mode only (`--segment-time` flag) | Context budget per segment |
+| No-Compress Mode | Off by default (`--no-compress` flag) | Stream-copy split at 1200s (20 min), no re-encoding |
+
+> **Google Gemini constraints:** ~300 tokens/sec (default res), ~100 tok/sec (low res). File API: 2 GB/file (free), 20 GB (paid). Max ~1 hour at default res per 1M context window.
 
 ---
 

package/QUICK_START.md

@@ -150,8 +150,8 @@ taskex --name "Your Name" --skip-upload "my-meeting"
 ### What happens
 
 The pipeline will:
-1. **Compress** the video (~30s)
-2. **Segment** it into ≤5 min chunks
+1. **Compress** the video (~30s) — or **split raw** with `--no-compress`
+2. **Segment** it into ≤5 min chunks (configurable with `--segment-time` in compress mode)
 3. **Upload** segments to Firebase Storage (if configured)
 4. **Analyze** each segment with Gemini AI — uses Firebase Storage URL directly when available (skips separate Gemini upload)
 5. **Quality check** — retry weak segments automatically (reuses file reference — no re-upload)
@@ -162,6 +162,8 @@ The pipeline will:
 
 > **Tip:** Use `--force-upload` to re-upload files that already exist in Storage. Use `--no-storage-url` to bypass Storage URL optimization and force Gemini File API uploads.
 
+> **Tip:** Use `--no-compress` to skip re-encoding (auto-splits at 20 min). Use `--speed 2.0` to speed up compressed playback (saves tokens), or `--segment-time 600` for longer compressed segments.
+
 This takes **~2-5 minutes** depending on video length.
 
 ---

package/README.md

@@ -241,6 +241,23 @@ Skip parts of the pipeline you don't need:
 | `--skip-compression` | Video compression | You already compressed/segmented the video |
 | `--skip-gemini` | AI analysis entirely | You just want to compress & upload |
 
+### Video Processing Flags
+
+Control how video is processed before AI analysis:
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--no-compress` | off | Skip re-encoding — pass raw video to Gemini (auto-splits at 20 min) |
+| `--speed <n>` | `1.6` | Playback speed multiplier (compress mode only) |
+| `--segment-time <n>` | `280` | Segment duration in seconds, compress mode only (30–3600) |
+
+**Duration constraints** (per [Google Gemini docs](https://ai.google.dev/gemini-api/docs/vision#video)):
+- Default resolution: ~300 tokens/sec → max ~55 min/segment (recommended: ≤20 min)
+- File API limit: 2 GB/file (free) / 20 GB (paid)
+- Supported formats: mp4, mpeg, mov, avi, x-flv, mpg, webm, wmv, 3gpp
+
+> **Tip:** Use `--no-compress` for large, high-quality recordings that you want to analyze at original quality. Raw video is auto-split at 20-minute intervals via `ffmpeg -c copy` (stream-copy). `--speed` and `--segment-time` only apply to compression mode.
+
 ### Tuning Flags
 
 **You probably don't need these.** The defaults work well. These are for power users:
@@ -282,6 +299,7 @@ OUTPUT     --format <md|html|json|pdf|docx|all>  --min-confidence <high|medium|l
            --no-html
 UPLOAD     --force-upload  --no-storage-url
 SKIP       --skip-compression  --skip-gemini
+VIDEO      --no-compress  --speed <n>  --segment-time <n>
 DYNAMIC    --request <text>
 PROGRESS   --repo <path>
 TUNING     --thinking-budget  --compilation-thinking-budget  --parallel

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-summary-extractor",
-  "version": "9.4.0",
+  "version": "9.5.0",
   "description": "AI-powered meeting analysis & document generation CLI — video + document processing, deep dive docs, dynamic mode, interactive CLI with model selection, confidence scoring, learning loop, git progress tracking",
   "main": "process_and_upload.js",
   "bin": {

package/src/phases/discover.js

@@ -80,6 +80,7 @@ async function phaseDiscover(ctx) {
   if (opts.skipUpload) activeFlags.push('skip-upload');
   if (opts.forceUpload) activeFlags.push('force-upload');
   if (opts.noStorageUrl) activeFlags.push('no-storage-url');
+  if (opts.noCompress) activeFlags.push('no-compress');
   if (opts.skipCompression) activeFlags.push('skip-compression');
   if (opts.skipGemini) activeFlags.push('skip-gemini');
   if (opts.resume) activeFlags.push('resume');

package/src/phases/init.js

@@ -50,7 +50,7 @@ async function phaseInit() {
     skipUpload: !!flags['skip-upload'],
     forceUpload: !!flags['force-upload'],
     noStorageUrl: !!flags['no-storage-url'],
-    skipCompression: !!flags['skip-compression'],
+    skipCompression: !!flags['skip-compression'], // DEPRECATED — use --no-compress
     skipGemini: !!flags['skip-gemini'],
     resume: !!flags.resume,
     reanalyze: !!flags.reanalyze,
@@ -66,6 +66,10 @@ async function phaseInit() {
     disableLearning: !!flags['no-learning'],
     disableDiff: !!flags['no-diff'],
     noHtml: !!flags['no-html'],
+    // Video processing flags
+    noCompress: !!flags['no-compress'],
+    speed: flags.speed ? parseFloat(flags.speed) : null,
+    segmentTime: flags['segment-time'] ? parseInt(flags['segment-time'], 10) : null,
     deepDive: !!flags['deep-dive'],
     deepSummary: !!flags['deep-summary'],
     deepSummaryExclude: typeof flags['exclude-docs'] === 'string'
@@ -123,6 +127,55 @@ async function phaseInit() {
     }
   }
 
+  // --- Validate video processing flags ---
+  if (opts.noCompress) {
+    // --no-compress: raw passthrough — speed and segment-time are not user-configurable
+    if (opts.speed !== null) {
+      console.log(c.warn('  ⚠  --speed is ignored with --no-compress (raw video is not re-encoded)'));
+      opts.speed = null;
+    }
+    if (opts.segmentTime !== null) {
+      console.log(c.warn('  ⚠  --segment-time is ignored with --no-compress (auto: 1200s / 20 min per segment)'));
+      opts.segmentTime = null;
+    }
+    if (opts.skipCompression) {
+      console.log(c.warn('  ⚠  --skip-compression is redundant with --no-compress — ignoring'));
+      opts.skipCompression = false;
+    }
+  } else {
+    if (opts.speed !== null) {
+      if (Number.isNaN(opts.speed) || opts.speed < 0.1 || opts.speed > 10) {
+        throw new Error(`Invalid --speed "${flags.speed}". Must be between 0.1 and 10.`);
+      }
+    }
+    if (opts.segmentTime !== null) {
+      if (Number.isNaN(opts.segmentTime) || opts.segmentTime < 30 || opts.segmentTime > 3600) {
+        throw new Error(`Invalid --segment-time "${flags['segment-time']}". Must be between 30 and 3600 seconds.`);
+      }
+      // Duration-aware validation (Google Gemini: ~300 tokens/sec at default resolution)
+      const TOKENS_PER_SEC = 300;
+      const CONTEXT_LIMIT = 1_048_576;
+      const SAFE_VIDEO_BUDGET = CONTEXT_LIMIT * 0.6; // 60% for video, rest for prompt+docs+output
+      const effectiveSpeed = opts.speed || 1.0;
+      const effectiveVideoSec = opts.segmentTime / effectiveSpeed;
+      const estimatedTokens = Math.round(effectiveVideoSec * TOKENS_PER_SEC);
+
+      if (estimatedTokens > CONTEXT_LIMIT) {
+        throw new Error(
+          `--segment-time ${opts.segmentTime}s exceeds Gemini context window! ` +
+          `Estimated ${(estimatedTokens / 1000).toFixed(0)}K tokens/segment (limit: 1,048K). ` +
+          `Reduce to ≤${Math.floor((CONTEXT_LIMIT / TOKENS_PER_SEC) * effectiveSpeed)}s.`
+        );
+      }
+      if (estimatedTokens > SAFE_VIDEO_BUDGET) {
+        console.log(c.warn(
+          `  ⚠  --segment-time ${opts.segmentTime}s is very large (~${(estimatedTokens / 1000).toFixed(0)}K tokens/segment). ` +
+          `Recommended: ≤${Math.floor((SAFE_VIDEO_BUDGET / TOKENS_PER_SEC) * effectiveSpeed)}s to leave room for prompt & output.`
+        ));
+      }
+    }
+  }
+
   // --- Validate min-confidence level ---
   if (opts.minConfidence) {
     const { validateConfidenceLevel } = require('../utils/confidence-filter');
@@ -318,6 +371,15 @@ function _printRunSummary(opts, modelId, models, targetDir) {
     console.log(`    ${c.dim('Disabled:')}    ${disabled.join(c.dim(' · '))}`);
   }
 
+  // Video processing settings
+  const { SPEED, SEG_TIME } = require('../config');
+  const effectiveSpeed = opts.noCompress ? 1.0 : (opts.speed || SPEED);
+  const effectiveSegTime = opts.noCompress ? 1200 : (opts.segmentTime || SEG_TIME);
+  const videoMode = opts.noCompress
+    ? c.cyan('raw (stream-copy, auto-split at 20 min)')
+    : c.green(`compress × ${effectiveSpeed}x  |  ${effectiveSegTime}s segments`);
+  console.log(`    ${c.dim('Video:')}       ${videoMode}`);
+
   if (opts.runMode) {
     console.log(`    ${c.dim('Run mode:')}    ${c.bold(opts.runMode)}`);
   }

package/src/phases/process-media.js

@@ -10,7 +10,7 @@ const { AUDIO_EXTS, SPEED } = config;
 // --- Services ---
 const { uploadToStorage, storageExists } = require('../services/firebase');
 const { processWithGemini, cleanupGeminiFiles } = require('../services/gemini');
-const { compressAndSegment, compressAndSegmentAudio, probeFormat, verifySegment } = require('../services/video');
+const { compressAndSegment, compressAndSegmentAudio, splitOnly, probeFormat, verifySegment } = require('../services/video');
 
 // --- Utils ---
 const { fmtDuration, fmtBytes } = require('../utils/format');
@@ -60,6 +60,12 @@ async function phaseProcessVideo(ctx, videoPath, videoIndex) {
     ? fs.readdirSync(segmentDir).filter(f => f.startsWith('segment_') && (f.endsWith('.mp4') || f.endsWith('.m4a'))).sort()
     : [];
 
+  // Build video processing options from CLI flags
+  // --no-compress uses hardcoded 1200s (splitOnly default); --segment-time only for compress mode
+  const videoOpts = {};
+  if (!opts.noCompress && opts.segmentTime) videoOpts.segTime = opts.segmentTime;
+  if (!opts.noCompress && opts.speed) videoOpts.speed = opts.speed;
+
   if (opts.skipCompression || opts.dryRun) {
     if (existingSegments.length > 0) {
       segments = existingSegments.map(f => path.join(segmentDir, f));
@@ -70,18 +76,23 @@ async function phaseProcessVideo(ctx, videoPath, videoIndex) {
         console.log(`  ${c.dim(`[DRY-RUN] Would compress "${path.basename(videoPath)}" into segments`)}`);
         return { fileResult: null, segmentAnalyses: [] };
       }
-      segments = compressAndSegment(videoPath, segmentDir);
+      segments = compressAndSegment(videoPath, segmentDir, videoOpts);
       log.step(`Compressed → ${segments.length} segment(s)`);
     }
   } else if (existingSegments.length > 0) {
     segments = existingSegments.map(f => path.join(segmentDir, f));
     log.step(`SKIP compression — ${segments.length} segment(s) already on disk`);
     console.log(`  ${c.success(`Skipped compression \u2014 ${c.highlight(segments.length)} segment(s) already exist`)}`);
+  } else if (opts.noCompress) {
+    // --no-compress: split raw video at keyframes, no re-encoding
+    segments = splitOnly(videoPath, segmentDir, videoOpts);
+    log.step(`Split (raw) → ${segments.length} segment(s)`);
+    console.log(`  \u2192 ${c.highlight(segments.length)} raw segment(s) created`);
   } else {
     if (isAudio) {
-      segments = compressAndSegmentAudio(videoPath, segmentDir);
+      segments = compressAndSegmentAudio(videoPath, segmentDir, videoOpts);
     } else {
-      segments = compressAndSegment(videoPath, segmentDir);
+      segments = compressAndSegment(videoPath, segmentDir, videoOpts);
     }
     log.step(`Compressed → ${segments.length} segment(s)`);
     console.log(`  \u2192 ${c.highlight(segments.length)} segment(s) created`);
@@ -90,6 +101,20 @@ async function phaseProcessVideo(ctx, videoPath, videoIndex) {
   progress.markCompressed(baseName, segments.length);
   const origSize = fs.statSync(videoPath).size;
   log.step(`original=${(origSize / 1048576).toFixed(2)}MB (${fmtBytes(origSize)}) | ${segments.length} segment(s)`);
+
+  // Duration-aware warnings for raw segments
+  if (opts.noCompress && segments.length > 0) {
+    const totalSegSize = segments.reduce((s, p) => s + fs.statSync(p).size, 0);
+    const avgSegMB = totalSegSize / segments.length / 1048576;
+    if (avgSegMB > 500) {
+      console.warn(`  ${c.warn(`Avg segment ~${avgSegMB.toFixed(0)} MB — large raw segments take longer to upload.`)}`);
+      console.warn(`  ${c.dim('  Tip: remove --no-compress to re-encode into smaller segments.')}`);
+    }
+    // All raw segments must use Gemini File API (>20 MB external URL limit)
+    if (avgSegMB > 20) {
+      console.log(`  ${c.dim('Raw segments >20 MB — will use Gemini File API upload (not storage URLs).')}`);
+    }
+  }
   console.log('');
 
   const fileResult = {
@@ -178,10 +203,12 @@ async function phaseProcessVideo(ctx, videoPath, videoIndex) {
   }
 
   // Calculate cumulative time offsets for VTT time-slicing
+  // When --no-compress is active, segments play at real time (speed = 1.0)
+  const effectiveSpeed = opts.noCompress ? 1.0 : (opts.speed || SPEED);
   let cumulativeTimeSec = 0;
   for (const meta of segmentMeta) {
     meta.startTimeSec = cumulativeTimeSec;
-    meta.endTimeSec = cumulativeTimeSec + (meta.durSec || 0) * SPEED;
+    meta.endTimeSec = cumulativeTimeSec + (meta.durSec || 0) * effectiveSpeed;
     cumulativeTimeSec = meta.endTimeSec;
   }
 

package/src/pipeline.js

@@ -136,9 +136,10 @@ async function run() {
     userName: fullCtx.userName,
     inputMode: ctx.inputMode,
     settings: {
-      speed: SPEED,
-      segmentTimeSec: SEG_TIME,
-      preset: PRESET,
+      speed: fullCtx.opts.noCompress ? 1.0 : (fullCtx.opts.speed || SPEED),
+      segmentTimeSec: fullCtx.opts.noCompress ? 1200 : (fullCtx.opts.segmentTime || SEG_TIME),
+      noCompress: !!fullCtx.opts.noCompress,
+      ...(fullCtx.opts.noCompress ? {} : { preset: PRESET }),
       geminiModel: config.GEMINI_MODEL,
       thinkingBudget: fullCtx.opts.thinkingBudget,
     },

package/src/services/video.js

@@ -13,7 +13,7 @@ const { execSync, spawnSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const { SPEED, SEG_TIME, PRESET } = require('../config');
-const { fmtDuration } = require('../utils/format');
+const { fmtDuration, fmtBytes } = require('../utils/format');
 const { c } = require('../utils/colors');
 
 // ======================== BINARY DETECTION ========================
@@ -103,17 +103,19 @@ function verifySegment(segPath) {
 
 /**
  * Build the common ffmpeg encoding args (video + audio filters/codecs).
+ * @param {string} inputFile
+ * @param {{ speed?: number }} [overrides]
  * Returns { encodingArgs, effectiveDuration }.
  */
-function buildEncodingArgs(inputFile) {
+function buildEncodingArgs(inputFile, { speed = SPEED } = {}) {
   const width = parseInt(probe(inputFile, 'v:0', 'width') || '0');
   const channels = parseInt(probe(inputFile, 'a:0', 'channels') || '1');
   const sampleRate = probe(inputFile, 'a:0', 'sample_rate') || '16000';
   const duration = probeFormat(inputFile, 'duration');
   const durationSec = duration ? parseFloat(duration) : null;
-  const effectiveDuration = durationSec ? durationSec / SPEED : null;
+  const effectiveDuration = durationSec ? durationSec / speed : null;
 
-  let vf = `setpts=PTS/${SPEED}`;
+  let vf = `setpts=PTS/${speed}`;
   let crf = 24;
   let tune = ['-tune', 'stillimage'];
   let profile = ['-profile:v', 'main'];
@@ -122,21 +124,21 @@ function buildEncodingArgs(inputFile) {
 
   if (width > 1920) {
     // 4K+ → scale to 1080p
-    vf = `scale=1920:1080,unsharp=3:3:0.3,setpts=PTS/${SPEED}`;
+    vf = `scale=1920:1080,unsharp=3:3:0.3,setpts=PTS/${speed}`;
     crf = 20;
     tune = [];
     profile = ['-profile:v', 'high'];
     audioBr = '128k';
   } else if (width > 0) {
     // Meeting / screenshare
-    vf = `unsharp=3:3:0.3,setpts=PTS/${SPEED}`;
+    vf = `unsharp=3:3:0.3,setpts=PTS/${speed}`;
   }
 
   if (channels === 2) audioBr = '128k';
 
   const encodingArgs = [
     '-vf', vf,
-    '-af', `atempo=${SPEED}`,
+    '-af', `atempo=${speed}`,
     '-c:v', 'libx264', '-crf', String(crf), '-preset', PRESET,
     ...tune,
     '-x264-params', x264p,
@@ -146,7 +148,7 @@ function buildEncodingArgs(inputFile) {
     '-movflags', '+faststart',
   ];
 
-  return { encodingArgs, effectiveDuration, width, crf, audioBr, duration };
+  return { encodingArgs, effectiveDuration, width, crf, audioBr, duration, speed };
 }
 
 /**
@@ -155,27 +157,28 @@ function buildEncodingArgs(inputFile) {
  * - Long videos → segment muxer for splitting.
  * - Post-compression validation: verifies each output has a valid moov atom.
  *   Corrupt segments are re-encoded individually with the regular MP4 muxer.
+ * @param {{ segTime?: number, speed?: number }} [opts]
  * Returns sorted array of segment file paths.
  */
-function compressAndSegment(inputFile, outputDir) {
-  const { encodingArgs, effectiveDuration, width, crf, audioBr, duration } = buildEncodingArgs(inputFile);
+function compressAndSegment(inputFile, outputDir, { segTime = SEG_TIME, speed = SPEED } = {}) {
+  const { encodingArgs, effectiveDuration, width, crf, audioBr, duration } = buildEncodingArgs(inputFile, { speed });
 
   fs.mkdirSync(outputDir, { recursive: true });
 
   console.log(`  Resolution : ${width > 0 ? width + 'p' : 'unknown'}`);
-  console.log(`  Duration   : ${duration ? fmtDuration(parseFloat(duration)) : 'unknown'}${effectiveDuration ? ` (${fmtDuration(effectiveDuration)} at ${SPEED}x)` : ''}`);
-  console.log(`  CRF ${crf} | ${audioBr} audio | ${SPEED}x speed`);
+  console.log(`  Duration   : ${duration ? fmtDuration(parseFloat(duration)) : 'unknown'}${effectiveDuration ? ` (${fmtDuration(effectiveDuration)} at ${speed}x)` : ''}`);
+  console.log(`  CRF ${crf} | ${audioBr} audio | ${speed}x speed`);
 
   // Decide: single output vs segmented
-  const needsSegmentation = effectiveDuration === null || effectiveDuration > SEG_TIME;
+  const needsSegmentation = effectiveDuration === null || effectiveDuration > segTime;
 
   if (needsSegmentation) {
-    console.log(`  Compressing (segmented, ${SEG_TIME}s chunks)...`);
+    console.log(`  Compressing (segmented, ${segTime}s chunks)...`);
     const args = [
       '-y', '-err_detect', 'ignore_err', '-fflags', '+genpts+discardcorrupt',
       '-i', inputFile,
       ...encodingArgs,
-      '-f', 'segment', '-segment_time', String(SEG_TIME), '-reset_timestamps', '1',
+      '-f', 'segment', '-segment_time', String(segTime), '-reset_timestamps', '1',
       '-map', '0:v:0', '-map', '0:a:0',
       path.join(outputDir, 'segment_%02d.mp4'),
     ];
@@ -248,7 +251,7 @@ function compressAndSegment(inputFile, outputDir) {
         const rsArgs = [
           '-y', '-i', fallbackPath,
           '-c', 'copy',
-          '-f', 'segment', '-segment_time', String(SEG_TIME), '-reset_timestamps', '1',
+          '-f', 'segment', '-segment_time', String(segTime), '-reset_timestamps', '1',
           '-movflags', '+faststart',
           path.join(reSegDir, 'segment_%02d.mp4'),
         ];
@@ -302,34 +305,34 @@ function compressAndSegment(inputFile, outputDir) {
  *
  * Returns sorted array of segment file paths.
  */
-function compressAndSegmentAudio(inputFile, outputDir) {
+function compressAndSegmentAudio(inputFile, outputDir, { segTime = SEG_TIME, speed = SPEED } = {}) {
   fs.mkdirSync(outputDir, { recursive: true });
 
   const duration = probeFormat(inputFile, 'duration');
   const durationSec = duration ? parseFloat(duration) : null;
-  const effectiveDuration = durationSec ? durationSec / SPEED : null;
+  const effectiveDuration = durationSec ? durationSec / speed : null;
   const channels = parseInt(probe(inputFile, 'a:0', 'channels') || '1', 10);
   const sampleRate = probe(inputFile, 'a:0', 'sample_rate') || '16000';
   const audioBr = channels >= 2 ? '128k' : '64k';
 
-  console.log(`  Duration : ${duration ? fmtDuration(parseFloat(duration)) : 'unknown'}${effectiveDuration ? ` (${fmtDuration(effectiveDuration)} at ${SPEED}x)` : ''}`);
-  console.log(`  Audio-only mode | ${SPEED}x speed | ${audioBr} bitrate`);
+  console.log(`  Duration : ${duration ? fmtDuration(parseFloat(duration)) : 'unknown'}${effectiveDuration ? ` (${fmtDuration(effectiveDuration)} at ${speed}x)` : ''}`);
+  console.log(`  Audio-only mode | ${speed}x speed | ${audioBr} bitrate`);
 
   const encodingArgs = [
-    '-af', `atempo=${SPEED}`,
+    '-af', `atempo=${speed}`,
     '-c:a', 'aac', '-b:a', audioBr, '-ar', sampleRate, '-ac', String(channels),
     '-vn',  // no video
     '-movflags', '+faststart',
   ];
 
-  const needsSegmentation = effectiveDuration === null || effectiveDuration > SEG_TIME;
+  const needsSegmentation = effectiveDuration === null || effectiveDuration > segTime;
 
   if (needsSegmentation) {
-    console.log(`  Compressing (segmented, ${SEG_TIME}s chunks)...`);
+    console.log(`  Compressing (segmented, ${segTime}s chunks)...`);
     const args = [
       '-y', '-i', inputFile,
       ...encodingArgs,
-      '-f', 'segment', '-segment_time', String(SEG_TIME), '-reset_timestamps', '1',
+      '-f', 'segment', '-segment_time', String(segTime), '-reset_timestamps', '1',
       path.join(outputDir, 'segment_%02d.m4a'),
     ];
     const result = spawnSync(getFFmpeg(), args, { stdio: 'inherit' });
@@ -383,7 +386,7 @@ function compressAndSegmentAudio(inputFile, outputDir) {
         const rsArgs = [
           '-y', '-i', fallbackPath,
           '-c', 'copy', '-vn',
-          '-f', 'segment', '-segment_time', String(SEG_TIME), '-reset_timestamps', '1',
+          '-f', 'segment', '-segment_time', String(segTime), '-reset_timestamps', '1',
           path.join(reSegDir, 'segment_%02d.m4a'),
         ];
         spawnSync(getFFmpeg(), rsArgs, { stdio: 'inherit' });
@@ -408,12 +411,100 @@ function compressAndSegmentAudio(inputFile, outputDir) {
   return segments;
 }
 
+/**
+ * Split a media file into segments WITHOUT re-encoding (stream copy).
+ * No compression, no speed-up — just fast keyframe-aligned splitting.
+ * For use with --no-compress: passes raw video to Gemini via File API.
+ *
+ * @param {string} inputFile - Path to input media file
+ * @param {string} outputDir - Directory for output segments
+ * @param {{ segTime?: number }} opts - Options (segTime defaults to 1200s for raw mode)
+ * @returns {string[]} Sorted array of segment file paths
+ */
+function splitOnly(inputFile, outputDir, { segTime = 1200 } = {}) {
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const duration = probeFormat(inputFile, 'duration');
+  const durationSec = duration ? parseFloat(duration) : null;
+  const ext = path.extname(inputFile).toLowerCase();
+  const isAudio = ['.mp3', '.wav', '.m4a', '.ogg', '.flac', '.aac', '.wma'].includes(ext);
+  const outExt = isAudio ? '.m4a' : '.mp4';
+  const width = isAudio ? 0 : parseInt(probe(inputFile, 'v:0', 'width') || '0');
+
+  console.log(`  Mode     : ${c.cyan('raw split')} (no re-encoding, no speed-up)`);
+  if (!isAudio) console.log(`  Resolution : ${width > 0 ? width + 'p' : 'unknown'}`);
+  console.log(`  Duration : ${duration ? fmtDuration(durationSec) : 'unknown'}`);
+  console.log(`  File size: ${fmtBytes(fs.statSync(inputFile).size)}`);
+
+  const needsSegmentation = durationSec === null || durationSec > segTime;
+
+  if (needsSegmentation) {
+    console.log(`  Splitting at keyframes (~${segTime}s chunks)...`);
+    const args = [
+      '-y', '-err_detect', 'ignore_err', '-fflags', '+genpts+discardcorrupt',
+      '-i', inputFile,
+      '-c', 'copy',
+      '-f', 'segment', '-segment_time', String(segTime), '-reset_timestamps', '1',
+      ...(isAudio ? ['-vn'] : ['-map', '0:v:0', '-map', '0:a:0']),
+      '-movflags', '+faststart',
+      path.join(outputDir, `segment_%02d${outExt}`),
+    ];
+    const result = spawnSync(getFFmpeg(), args, { stdio: 'inherit' });
+    if (result.status !== 0) {
+      console.warn(`  ${c.warn(`ffmpeg exited with code ${result.status} (output may still be usable)`)}`);
+    }
+  } else {
+    console.log(`  Single segment (duration ${fmtDuration(durationSec)} ≤ ${segTime}s) — copying...`);
+    const outPath = path.join(outputDir, `segment_00${outExt}`);
+    const args = [
+      '-y', '-err_detect', 'ignore_err', '-fflags', '+genpts+discardcorrupt',
+      '-i', inputFile,
+      '-c', 'copy',
+      ...(isAudio ? ['-vn'] : ['-map', '0:v:0', '-map', '0:a:0']),
+      '-movflags', '+faststart',
+      outPath,
+    ];
+    const result = spawnSync(getFFmpeg(), args, { stdio: 'inherit' });
+    if (result.status !== 0) {
+      console.warn(`  ${c.warn(`ffmpeg exited with code ${result.status}`)}`);
+    }
+  }
+
+  // Collect segments
+  const segments = fs.readdirSync(outputDir)
+    .filter(f => f.startsWith('segment_') && (f.endsWith('.mp4') || f.endsWith('.m4a')))
+    .sort()
+    .map(f => path.join(outputDir, f));
+
+  // Validate
+  const corrupt = segments.filter(s => !verifySegment(s));
+  if (corrupt.length > 0) {
+    console.warn(`  ${c.warn(`${corrupt.length} segment(s) may be corrupt (no moov atom):`)}`);
+    corrupt.forEach(s => console.warn(`    ${c.error(path.basename(s))}`));
+    console.warn(`  ${c.dim('Stream-copy splits at keyframes — some containers may need re-mux.')}`);
+    console.warn(`  ${c.dim('Remove --no-compress to re-encode instead.')}`);
+  }
+
+  // Duration validation: warn if any segment exceeds 1 hour (Gemini sweet spot)
+  for (const seg of segments) {
+    const dur = probeFormat(seg, 'duration');
+    if (dur && parseFloat(dur) > 3600) {
+      console.warn(`  ${c.warn(`${path.basename(seg)} is ${fmtDuration(parseFloat(dur))} — very long segments use more Gemini tokens.`)}`);
+      console.warn(`  ${c.dim('  Consider removing --no-compress to re-encode into shorter segments.')}`);
+      break; // warn once
+    }
+  }
+
+  return segments;
+}
+
 module.exports = {
   findBin,
   probe,
   probeFormat,
   compressAndSegment,
   compressAndSegmentAudio,
+  splitOnly,
   verifySegment,
   getFFmpeg,
   getFFprobe,

package/src/utils/cli.js

@@ -33,7 +33,7 @@ function parseArgs(argv) {
   const BOOLEAN_FLAGS = new Set([
     'help', 'h', 'version', 'v',
     'skip-upload', 'force-upload', 'no-storage-url',
-    'skip-compression', 'skip-gemini',
+    'skip-compression', 'skip-gemini', 'no-compress',
     'resume', 'reanalyze', 'dry-run',
     'dynamic', 'deep-dive', 'deep-summary', 'update-progress',
     'no-focused-pass', 'no-learning', 'no-diff',
@@ -381,12 +381,22 @@ ${f('--format <type>', 'Output: md, html, json, pdf, docx, all — comma-separat
 ${f('--min-confidence <level>', 'Filter: high, medium, low (default: all)')}
 ${f('--output <dir>', 'Custom output directory for results')}
 ${f('--skip-upload', 'Skip Firebase Storage uploads')}
-${f('--skip-compression', 'Use existing segments (no re-compress)')}
+${f('--skip-compression', 'Use existing segments from previous run (deprecated: auto-detected)')}
 ${f('--skip-gemini', 'Skip AI analysis')}
 ${f('--resume', 'Resume from last checkpoint')}
 ${f('--reanalyze', 'Force re-analysis of all segments')}
 ${f('--dry-run', 'Preview without executing')}
 
+  ${h('VIDEO PROCESSING')}
+${f('--no-compress', 'Skip re-encoding — pass raw video to Gemini (fast, no quality loss)')}
+${f2('Auto-splits at 20 min (1200s) if needed. --speed and --segment-time are ignored.')}
+${f2('Gemini File API: up to 2 GB/file, ~300 tok/sec at default resolution.')}
+${f('--speed <n>', 'Playback speed multiplier for compression mode (default: 1.6)')}
+${f('--segment-time <n>', 'Segment duration in seconds for compression mode (default: 280)')}
+${f2('Duration constraints (per Google Gemini docs):')}
+${f2('  • Default res: ~300 tok/sec → max ~55 min/segment (safe: ≤20 min)')}
+${f2('  • File API limit: 2 GB (free) / 20 GB (paid) per file')}
+
   ${h('TUNING')}
 ${f('--parallel <n>', 'Max parallel uploads (default: 3)')}
 ${f('--parallel-analysis <n>', 'Concurrent analysis batches (default: 2)')}