task-summary-extractor 9.3.1 → 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

@@ -1,8 +1,7 @@
 # Architecture & Technical Deep Dive
 
 > Internal reference for the pipeline's architecture, processing flows, and design decisions.  
-> For setup instructions, see [README.md](README.md) · [Quick Start](QUICK_START.md)  
-> For module map and roadmap, see [EXPLORATION.md](EXPLORATION.md)
+> For setup instructions, see [README.md](README.md) · [Quick Start](QUICK_START.md)
 
 ---
 
@@ -126,6 +125,7 @@ flowchart TB
 | 1 | **Init** | CLI parsing, interactive folder selection (if no arg), config validation, logger setup, load learning insights, route to dynamic/progress mode |
 | 2 | **Discover** | Find videos/audio, discover documents, resolve user name, check resume state |
 | 3 | **Services** | Firebase auth, Gemini init, prepare document parts |
+| 3.5 | **Deep Summary** | (optional) Pre-summarize context docs with Gemini — 60-80% token savings |
 | 4 | **Process** | Compress → Upload → Analyze → Quality Gate → Retry → Focused Pass |
 | 5 | **Compile** | Cross-segment compilation, diff engine comparison |
 | 6 | **Output** | Write JSON, render Markdown + HTML, upload to Firebase |
@@ -199,7 +199,7 @@ Each video segment goes through this flow (Phase 4 detail):
 
 ```mermaid
 flowchart TB
-    START(["Segment N"]) --> COMPRESS["ffmpeg compress\nH.264 CRF 24, 1.5x speed"]
+    START(["Segment N"]) --> COMPRESS["ffmpeg compress\nH.264 CRF 24, 1.6x speed"]
     COMPRESS --> VERIFY["Verify segment integrity"]
     VERIFY --> UPLOAD_FB["Upload to Firebase Storage\n→ download URL"]
 
@@ -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 |
@@ -563,7 +564,7 @@ JSONL structured format includes phase spans with timing metrics for observabili
 | **ffmpeg** | System binary | H.264 video compression + segmentation |
 | **Git** | System binary | Change detection for progress tracking |
 
-**Codebase: ~45 files · ~13,000+ lines** · npm package: `task-summary-extractor` · CLI: `taskex`
+**Codebase: ~48 files · ~13,600+ lines** · npm package: `task-summary-extractor` · CLI: `taskex`
 
 ---
 
@@ -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.
 
 ---
 
@@ -634,8 +640,8 @@ The project includes a comprehensive test suite using [vitest](https://vitest.de
 
 | Metric | Value |
 |--------|-------|
-| Test files | 13 |
-| Total tests | 285 |
+| Test files | 15 |
+| Total tests | 331 |
 | Framework | vitest v4.x |
 | Coverage | `@vitest/coverage-v8` |
 
@@ -662,45 +668,45 @@ npm run test:coverage # Coverage report
 |-----|-------------|
 | 📖 [README.md](README.md) | Setup, CLI flags, configuration, features |
 | 📖 [QUICK_START.md](QUICK_START.md) | Step-by-step first-time walkthrough |
-| 🔭 [EXPLORATION.md](EXPLORATION.md) | Module map, line counts, future roadmap |
 
 ---
 
-## JSON Schema Validation
+## Deep Summary
 
-All AI output is validated against JSON Schema definitions in `src/schemas/`:
+The `--deep-summary` flag (or interactive prompt when many docs are detected) pre-summarizes context documents before segment analysis:
 
-| Schema | File | Purpose |
-|--------|------|---------|
-| Segment analysis | `analysis-segment.schema.json` | Validates each segment's extracted data |
-| Compiled analysis | `analysis-compiled.schema.json` | Validates the final cross-segment compilation |
-
-Validation is performed by `src/utils/schema-validator.js` using [ajv](https://ajv.js.org/). Validation errors are reported as warnings with contextual hints for the retry/focused-pass cycle — they do not hard-fail the pipeline but are injected as corrective hints when the quality gate triggers a retry.
-
----
+```mermaid
+flowchart TB
+    START(["Context Docs"]) --> PARTITION["Partition: summarize vs. keep full"]
+    PARTITION --> SKIP["Skip tiny docs (<500 chars)"]
+    PARTITION --> EXCL["Excluded docs → keep full fidelity"]
+    PARTITION --> TO_SUM["Docs to summarize"]
+    TO_SUM --> TRUNC["Truncate oversized docs (>900K chars)"]
+    TRUNC --> BATCH["Group into batches\n(≤600K chars each)"]
+    BATCH --> AI["Gemini summarization\n(per batch)"]
+    AI --> REPLACE["Replace full content\nwith condensed summaries"]
+    REPLACE --> OUT(["Token-efficient\ncontext docs"])
+```
 
-## Test Suite
+| Constant | Value | Purpose |
+|----------|-------|---------|
+| `BATCH_MAX_CHARS` | 600,000 | Max input chars per summarization batch |
+| `MAX_DOC_CHARS` | 900,000 | Hard cap per-document before truncation |
+| `SUMMARY_MAX_OUTPUT` | 16,384 | Max output tokens per summarization call |
+| `MIN_SUMMARIZE_LENGTH` | 500 | Docs below this skip summarization |
 
-The project includes a comprehensive test suite using [vitest](https://vitest.dev/):
+Typical savings: 60-80% reduction in per-segment context tokens. The user can exclude specific docs from summarization via `--exclude-docs` or the interactive picker.
 
-| Metric | Value |
-|--------|-------|
-| Test files | 13 |
-| Total tests | 285 |
-| Framework | vitest v4.x |
-| Coverage | `@vitest/coverage-v8` |
-
-**Test categories:**
+---
 
-| Directory | What's Tested |
-|-----------|---------------|
-| `tests/utils/` | Utility modules: adaptive-budget, cli, confidence-filter, context-manager, diff-engine, format, json-parser, progress-bar, quality-gate, retry, schema-validator |
-| `tests/renderers/` | Renderer modules: html, markdown |
+## Context Window Safety
 
-**Commands:**
+Safeguards to prevent context window overflow:
 
-```bash
-npm test              # Run all tests
-npm run test:watch    # Watch mode
-npm run test:coverage # Coverage report
-```
+| Safeguard | Where | What It Does |
+|-----------|-------|-------------|
+| **P0/P1 hard cap** | `context-manager.js` | Critical docs can't exceed 2× the token budget |
+| **VTT fallback cap** | `context-manager.js` | Full VTT fallback capped at 500K chars |
+| **Doc truncation** | `deep-summary.js` | Oversized docs truncated to 900K chars before summarization |
+| **Compilation pre-flight** | `gemini.js` | Estimates tokens before compilation; trims middle segments if >80% of context |
+| **RESOURCE_EXHAUSTED recovery** | `gemini.js` | On quota/context errors: waits 30s, sheds docs, retries with reduced input |

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.
 
 ---
@@ -223,6 +225,7 @@ my-project/runs/{timestamp}/
 | **Force Gemini File API** | `taskex --no-storage-url "my-meeting"` |
 | **Preview without running** | `taskex --dry-run "my-meeting"` |
 | **Deep dive docs** | `taskex --deep-dive "my-meeting"` |
+| **Pre-summarize docs** | `taskex --deep-summary "my-meeting"` |
 | **Generate docs (no video)** | `taskex --dynamic "my-project"` |
 | **Track progress via git** | `taskex --update-progress --repo "C:\project" "my-meeting"` |
 | **Debug mode** | `taskex --log-level debug "my-meeting"` |
@@ -272,4 +275,3 @@ Your recordings, `.env`, logs — everything local is `.gitignore`d and safe.
 |------|-------|
 | Full feature list, all CLI flags, configuration | [README.md](README.md) |
 | How the pipeline works internally | [ARCHITECTURE.md](ARCHITECTURE.md) |
-| Module map, line counts, roadmap | [EXPLORATION.md](EXPLORATION.md) |

package/README.md

@@ -1,13 +1,13 @@
 # Task Summary Extractor
 
-> **v9.0.0** — AI-powered content analysis CLI — meetings, recordings, documents, or any mix. Install globally, run anywhere.
+> **v9.4.0** — AI-powered content analysis CLI — meetings, recordings, documents, or any mix. Install globally, run anywhere.
 
 <p align="center">
   <img src="https://img.shields.io/badge/node-%3E%3D18.0.0-green" alt="Node.js" />
   <img src="https://img.shields.io/badge/gemini-2.5--flash-blue" alt="Gemini" />
   <img src="https://img.shields.io/badge/firebase-11.x-orange" alt="Firebase" />
-  <img src="https://img.shields.io/badge/version-9.0.0-brightgreen" alt="Version" />
-  <img src="https://img.shields.io/badge/tests-285%20passing-brightgreen" alt="Tests" />
+  <img src="https://img.shields.io/badge/version-9.4.0-brightgreen" alt="Version" />
+  <img src="https://img.shields.io/badge/tests-331%20passing-brightgreen" alt="Tests" />
   <img src="https://img.shields.io/badge/npm-task--summary--extractor-red" alt="npm" />
 </p>
 
@@ -62,6 +62,20 @@ taskex --update-progress --repo "C:\my-project" "my-meeting"
 
 > **v7.2.3**: If the call folder isn't a git repo, the tool auto-initializes one for baseline tracking.
 
+### ⚡ Deep Summary (`--deep-summary`)
+
+Pre-summarize context documents to reduce per-segment token usage by 60-80%:
+
+```bash
+taskex --deep-summary --name "Jane" "my-meeting"
+```
+
+Exclude specific docs from summarization (keep at full fidelity):
+
+```bash
+taskex --deep-summary --exclude-docs "code-map.md,sprint.md" "my-meeting"
+```
+
 > See all modes explained with diagrams → [ARCHITECTURE.md](ARCHITECTURE.md#pipeline-phases)
 
 ---
@@ -172,6 +186,8 @@ These are the ones you'll actually use:
 | `--format <type>` | Output format: `md`, `html`, `json`, `pdf`, `docx`, `all` (default: `md`) | `--format html` |
 | `--min-confidence <level>` | Filter items by confidence: `high`, `medium`, `low` | `--min-confidence high` |
 | `--no-html` | Suppress HTML report generation | `--no-html` |
+| `--deep-summary` | Pre-summarize context docs (60-80% token savings) | `--deep-summary` |
+| `--exclude-docs <list>` | Docs to keep full during deep-summary (comma-separated) | `--exclude-docs "code-map.md"` |
 
 **Typical usage:**
 
@@ -198,6 +214,7 @@ Choose what the tool does. Only use one at a time:
 | *(none)* | **Content analysis** | `results.md` + `results.html` — structured task document |
 | `--dynamic` | **Doc generation** | `INDEX.md` + 3–15 topic documents |
 | `--deep-dive` | **Topic explainers** | `INDEX.md` + per-topic deep-dive docs |
+| `--deep-summary` | **Token-efficient analysis** | Same as content analysis, but context docs pre-summarized (60-80% savings) |
 | `--update-progress` | **Progress check** | `progress.md` — item status via git |
 
 **Dynamic mode** also uses:
@@ -224,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:
@@ -259,12 +293,13 @@ taskex [flags] [folder]
 
 CONFIG     --gemini-key  --firebase-key  --firebase-project
            --firebase-bucket  --firebase-domain
-MODES      --dynamic  --deep-dive  --update-progress
+MODES      --dynamic  --deep-dive  --deep-summary  --update-progress
 CORE       --name  --model  --skip-upload  --resume  --reanalyze  --dry-run
 OUTPUT     --format <md|html|json|pdf|docx|all>  --min-confidence <high|medium|low>
            --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
@@ -394,7 +429,7 @@ GEMINI_API_KEY=your-key-here
 
 # Optional — uncomment to customize
 # GEMINI_MODEL=gemini-2.5-flash
-# VIDEO_SPEED=1.5
+# VIDEO_SPEED=1.6
 # THINKING_BUDGET=24576
 # LOG_LEVEL=info
 
@@ -413,7 +448,7 @@ GEMINI_API_KEY=your-key-here
 
 | Feature | Description |
 |---------|-------------|
-| **Video/Audio Compression** | H.264 CRF 24, text-optimized sharpening, configurable speed |
+| **Video/Audio Compression** | H.264 CRF 24, text-optimized sharpening, 1.6× speed |
 | **Smart Segmentation** | ≤5 min chunks with boundary-aware splitting |
 | **Cross-Segment Continuity** | Ticket IDs, names, and context carry forward |
 | **Document Discovery** | Auto-finds docs in all subfolders |
@@ -434,6 +469,8 @@ GEMINI_API_KEY=your-key-here
 | **HTML Report** | Self-contained HTML report with collapsible sections, filtering, dark mode |
 | **JSON Schema Validation** | Validates AI output against JSON Schema (segment + compiled) |
 | **Confidence Filter** | `--min-confidence` flag to exclude low-confidence items from output |
+| **Deep Summary** | `--deep-summary` pre-summarizes context docs, 60-80% token savings per segment |
+| **Context Window Safety** | Auto-truncation, pre-flight token checks, RESOURCE_EXHAUSTED recovery |
 | **Multi-Format Output** | `--format` flag: Markdown, HTML, JSON, PDF, DOCX, or all formats at once |
 | **Interactive CLI** | Run with no args → guided experience |
 | **Resume / Checkpoint** | `--resume` continues interrupted runs |
@@ -507,6 +544,7 @@ task-summary-extractor/
 │   │   ├── git.js              Git CLI wrapper
 │   │   └── doc-parser.js       Document text extraction (DOCX, XLSX, PPTX, etc.)
 │   ├── modes/                  AI-heavy pipeline phase modules
+│   │   ├── deep-summary.js     Pre-summarize context docs (deep-summary feature)
 │   │   ├── deep-dive.js        Topic discovery & deep-dive doc generation
 │   │   ├── dynamic-mode.js     Dynamic document planning & generation
 │   │   ├── focused-reanalysis.js  Targeted reanalysis of weak segments
@@ -528,17 +566,14 @@ task-summary-extractor/
 │       ├── schema-validator.js JSON Schema validation (ajv)
 │       └── ... (15 more utility modules)
 │
-├── tests/                      Test suite — 285 tests across 13 files (vitest)
+├── tests/                      Test suite — 331 tests across 15 files (vitest)
 │   ├── utils/                  Utility module tests
 │   └── renderers/              Renderer tests
 │
 ├── QUICK_START.md              Step-by-step setup guide
-├── ARCHITECTURE.md             Technical deep dive
-└── EXPLORATION.md              Roadmap & future features
+└── ARCHITECTURE.md             Technical deep dive
 ```
 
-> Full module map with line counts → [EXPLORATION.md](EXPLORATION.md#full-module-map)
-
 ---
 
 ## npm Scripts
@@ -551,7 +586,7 @@ task-summary-extractor/
 | `npm run check` | Validate environment |
 | `npm start` | Run the pipeline |
 | `npm run help` | Show CLI help |
-| `npm test` | Run test suite (285 tests) |
+| `npm test` | Run test suite (331 tests) |
 | `npm run test:watch` | Run tests in watch mode |
 | `npm run test:coverage` | Run tests with coverage report |
 
@@ -561,6 +596,9 @@ task-summary-extractor/
 
 | Version | Highlights |
 |---------|-----------|
+| **v9.4.0** | **Context window safety** — pre-flight token checks, auto-truncation for oversized docs/VTTs, RESOURCE_EXHAUSTED recovery with automatic doc shedding, chunked compilation for large segment sets, P0/P1 hard cap (2× budget) prevents context overflow, improved deep-summary prompt quality |
+| **v9.3.1** | **Audit & polish** — VIDEO_SPEED 1.5→1.6, `--exclude-docs` flag for non-interactive deep-summary exclusion, friendlier Gemini error messages, dead code removal, DRY RUN_PRESETS |
+| **v9.3.0** | **Deep summary** — `--deep-summary` pre-summarizes context documents (60-80% token savings), interactive doc picker, `--exclude-docs` for CLI automation, batch processing |
 | **v9.0.0** | **CLI UX upgrade** — colors & progress bar, HTML reports, PDF & DOCX output (via puppeteer and docx npm package), JSON Schema validation, confidence filter (`--min-confidence`), pipeline decomposition (`src/phases/` — 9 modules), test suite (285 tests via vitest), multi-format output (`--format`: md/html/json/pdf/docx/all), doc-parser service, shared renderer utilities |
 | **v8.3.0** | **Universal content analysis** — prompt v4.0.0 supports video, audio, documents, and mixed content; input type auto-detection; timestamps conditional on content type; gemini.js bridge text generalized; all markdown docs updated |
 | **v8.2.0** | **Architecture cleanup** — `src/modes/` for AI pipeline phases, `retry.js` self-contained defaults, dead code removal, export trimming, `process_and_upload.js` slim shim, `progress.js` → `checkpoint.js`, merged `prompt.js` into `cli.js` |
@@ -587,7 +625,6 @@ task-summary-extractor/
 |-----|-------------|-------------|
 | 📖 **[QUICK_START.md](QUICK_START.md)** | Full setup walkthrough, examples, troubleshooting | First time using the tool |
 | 🏗️ **[ARCHITECTURE.md](ARCHITECTURE.md)** | Pipeline phases, algorithms, Mermaid diagrams | Understanding how it works |
-| 🔭 **[EXPLORATION.md](EXPLORATION.md)** | Module map, line counts, future roadmap | Contributing or extending |
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-summary-extractor",
-  "version": "9.3.1",
+  "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/modes/deep-summary.js

@@ -36,6 +36,13 @@ const BATCH_MAX_CHARS = 600000;
 /** Minimum content length (chars) to bother summarizing — below this, keep full */
 const MIN_SUMMARIZE_LENGTH = 500;
 
+/**
+ * Hard cap per-document chars before sending to Gemini.
+ * Gemini context = 1M tokens; prompt overhead ~50K tokens; at 0.3 tok/char
+ * 900K chars ≈ 270K tokens — safe with prompt + thinking overhead.
+ */
+const MAX_DOC_CHARS = 900000;
+
 // ======================== BATCH BUILDER ========================
 
 /**
@@ -51,8 +58,22 @@ function buildBatches(docs, maxChars = BATCH_MAX_CHARS) {
   let currentBatch = [];
   let currentChars = 0;
 
-  for (const doc of docs) {
-    const docChars = doc.content ? doc.content.length : 0;
+  for (let doc of docs) {
+    let docChars = doc.content ? doc.content.length : 0;
+
+    // Truncate extremely large docs to avoid exceeding the context window.
+    // Any single doc beyond MAX_DOC_CHARS is capped (tail is dropped) and a
+    // warning is prepended so the summariser knows the content is incomplete.
+    if (docChars > MAX_DOC_CHARS) {
+      const truncated = doc.content.substring(0, MAX_DOC_CHARS);
+      doc = {
+        ...doc,
+        content: `[TRUNCATED — original ${(docChars / 1024).toFixed(0)} KB exceeded the ${(MAX_DOC_CHARS / 1024).toFixed(0)} KB limit; only the first ${(MAX_DOC_CHARS / 1024).toFixed(0)} KB is included]\n\n${truncated}`,
+        _truncatedFrom: docChars,
+      };
+      docChars = doc.content.length;
+      console.warn(`    ${c.warn(`${doc.fileName} truncated from ${(doc._truncatedFrom / 1024).toFixed(0)} KB to ${(MAX_DOC_CHARS / 1024).toFixed(0)} KB for deep summary`)}`);
+    }
 
     // If this single doc exceeds the batch limit, it gets its own batch
     if (docChars > maxChars) {
@@ -120,23 +141,35 @@ async function summarizeBatch(ai, docs, opts = {}) {
 
   const promptText = `You are a precision document summarizer for a meeting analysis pipeline.
 
-Your job: read ALL documents below and produce a CONDENSED version of each that preserves:
-- Every ticket ID, task ID, CR number, or reference number (verbatim)
-- All assignees, reviewers, and responsible parties
-- All statuses (open, closed, in_progress, blocked, etc.)
-- All action items and their owners
-- All blockers, dependencies, and deadlines
-- Key decisions and their rationale
-- File paths and code references
-- Numerical data (percentages, counts, dates, versions)
-
-What to remove:
+Your job: read ALL documents below and produce a CONDENSED version of each that preserves every piece of actionable information.
+
+WHAT TO PRESERVE (in order of importance):
+1. IDENTIFIERS — Every ticket ID, task ID, CR number, PR number, JIRA key, GitHub issue, reference number, version number. Copy these VERBATIM — do not paraphrase or abbreviate IDs.
+2. PEOPLE — All assignees, reviewers, approvers, requesters, and responsible parties. Use full names exactly as they appear.
+3. STATUSES & STATES — All statuses (open, closed, in_progress, blocked, deferred, etc.) and state markers (✅, ⬜, ⏸️, 🔲). Preserve the exact status vocabulary used in the document.
+4. ACTION ITEMS — Every action item, commitment, and deliverable with its owner, deadline, and dependency chain.
+5. BLOCKERS & DEPENDENCIES — What is blocked, by whom, what it blocks downstream.
+6. DECISIONS & RATIONALE — Key decisions and WHY they were made (not just what).
+7. CROSS-REFERENCES — When Document A references something from Document B, preserve that linkage. If ticket X is mentioned in a code-map entry, keep both the ticket ID and the code-map path.
+8. TECHNICAL SPECIFICS — File paths, code references, API endpoints, database tables, configuration keys, environment names (dev/staging/prod).
+9. NUMERICAL DATA — Percentages, counts, dates, deadlines, version numbers, sizes.
+10. CHECKLISTS & PROGRESS — Preserve checklist items with their completion status markers. Include progress ratios (e.g., "35/74 done, 6 blocked").
+
+WHAT TO REMOVE:
 - Verbose explanations of well-known concepts
-- Redundant phrasing and filler text
-- Formatting-only content (decorative headers, dividers)
-- Boilerplate/template text that adds no information
+- Redundant phrasing, filler text, throat-clearing sentences
+- Formatting-only content (decorative headers, horizontal rules, empty sections)
+- Boilerplate/template text that adds no project-specific information
+- Repeated definitions or glossary entries that don't change across documents
 ${focusSection}
 
+QUALITY REQUIREMENTS:
+- Aim for 70-80% size reduction while preserving ALL actionable information.
+- Every ID, every name, every status MUST survive the summarization.
+- If two documents reference the same entity (ticket, file, person), ensure the summary preserves enough context in BOTH summaries for downstream consumers to make the connection.
+- When a document contains a table, preserve the table structure (header + key rows). Omit empty or low-value rows.
+- When a document has nested structure (subsections, indented lists), preserve the hierarchy — use indentation or numbering.
+
 OUTPUT FORMAT:
 Return valid JSON with this structure:
 {
@@ -151,9 +184,6 @@ Return valid JSON with this structure:
   }
 }
 
-Aim for 70-80% size reduction while preserving ALL actionable information.
-Every ID, every name, every status must survive the summarization.
-
 DOCUMENTS TO SUMMARIZE (${docEntries.length} documents):
 
 ${docEntries.join('\n\n')}`;
@@ -162,7 +192,7 @@ ${docEntries.join('\n\n')}`;
     model: config.GEMINI_MODEL,
     contents: [{ role: 'user', parts: [{ text: promptText }] }],
     config: {
-      systemInstruction: 'You are a lossless information compressor. Preserve every ID, name, status, assignment, and actionable detail. Output valid JSON only.',
+      systemInstruction: 'You are a lossless information compressor specialized in engineering and business documents. Preserve every ID, name, status, assignment, dependency, file path, decision rationale, and actionable detail. Maintain cross-document references (when doc A mentions entity from doc B, keep both sides). Output valid JSON only.',
       maxOutputTokens: SUMMARY_MAX_OUTPUT,
       temperature: 0,
       thinkingConfig: { thinkingBudget },
@@ -372,4 +402,5 @@ module.exports = {
   SUMMARY_MAX_OUTPUT,
   BATCH_MAX_CHARS,
   MIN_SUMMARIZE_LENGTH,
+  MAX_DOC_CHARS,
 };

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

@@ -46,7 +46,7 @@ const phaseDeepDive    = require('./phases/deep-dive');
 // --- Utils (for run orchestration + alt modes) ---
 const { c } = require('./utils/colors');
 const { findDocsRecursive } = require('./utils/fs');
-const { promptUserText, selectDocsToExclude } = require('./utils/cli');
+const { promptUser, promptUserText, selectDocsToExclude } = require('./utils/cli');
 const { createProgressBar } = require('./utils/progress-bar');
 const { buildHealthReport, printHealthDashboard } = require('./utils/health-dashboard');
 const { saveHistory, buildHistoryEntry } = require('./utils/learning-loop');
@@ -96,6 +96,23 @@ async function run() {
   bar.tick('Services ready');
 
   // Phase 3.5 (optional): Deep Summary — pre-summarize context docs
+  // If user didn't pass --deep-summary but has many context docs, offer it interactively
+  if (!fullCtx.opts.deepSummary && process.stdin.isTTY && fullCtx.ai && fullCtx.contextDocs.length >= 3) {
+    const inlineDocs = fullCtx.contextDocs.filter(d => d.type === 'inlineText' && d.content);
+    const totalChars = inlineDocs.reduce((sum, d) => sum + d.content.length, 0);
+    const totalTokensEstimate = Math.ceil(totalChars * 0.3);
+    // Only offer when context is large enough to benefit (>100K tokens)
+    if (totalTokensEstimate > 100000) {
+      console.log('');
+      console.log(`  ${c.cyan('You have')} ${c.highlight(inlineDocs.length)} ${c.cyan('context docs')} (~${c.highlight((totalTokensEstimate / 1000).toFixed(0) + 'K')} ${c.cyan('tokens)')}`);
+      console.log(`  ${c.dim('Deep summary can reduce per-segment context by 60-80%, saving time and cost.')}`);
+      const wantDeepSummary = await promptUser(`  ${c.cyan('Enable deep summary?')} [y/N] `);
+      if (wantDeepSummary) {
+        fullCtx.opts.deepSummary = true;
+      }
+    }
+  }
+
   if (fullCtx.opts.deepSummary && fullCtx.ai && fullCtx.contextDocs.length > 0) {
     // Interactive picker: let user choose docs to keep at full fidelity
     if (process.stdin.isTTY && fullCtx.opts.deepSummaryExclude.length === 0) {
@@ -119,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/gemini.js

@@ -459,16 +459,53 @@ async function processWithGemini(ai, filePath, displayName, contextDocs = [], pr
         throw reuploadErr;
       }
     } 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;
+      // Handle RESOURCE_EXHAUSTED specifically — shed lower-priority docs and retry
+      if (errMsg.includes('RESOURCE_EXHAUSTED') || errMsg.includes('429') || errMsg.includes('quota')) {
+        console.warn(`    ${c.warn('Context window or quota exceeded — shedding docs and retrying after 30s...')}`);
+        await new Promise(r => setTimeout(r, 30000));
+        // Rebuild with half the doc budget
+        const reducedBudget = Math.floor(docBudget * 0.5);
+        const { selected: reducedDocs } = selectDocsByBudget(contextDocs, reducedBudget, { segmentIndex });
+        const reducedParts = [contentParts[0]]; // keep video
+        for (const doc of reducedDocs) {
+          if (doc.type === 'inlineText') {
+            let content = doc.content;
+            const isVtt = doc.fileName.toLowerCase().endsWith('.vtt') || doc.fileName.toLowerCase().endsWith('.srt');
+            if (isVtt && segmentStartSec != null && segmentEndSec != null) {
+              content = sliceVttForSegment(content, segmentStartSec, segmentEndSec);
+            }
+            reducedParts.push({ text: `=== Document: ${doc.fileName} ===\n${content}` });
+          } else if (doc.type === 'fileData') {
+            reducedParts.push({ fileData: { mimeType: doc.mimeType, fileUri: doc.fileUri } });
+          }
+        }
+        // Re-add prompt/context parts (last 3-5 parts are prompt, focus, etc.)
+        const nonDocParts = contentParts.slice(1 + selectedDocs.length);
+        reducedParts.push(...nonDocParts);
+        requestPayload.contents[0].parts = reducedParts;
+        console.log(`    Reduced to ${reducedDocs.length} docs (budget: ${(reducedBudget / 1000).toFixed(0)}K tokens)`);
+        try {
+          response = await withRetry(
+            () => ai.models.generateContent(requestPayload),
+            { label: `Gemini segment analysis — reduced docs (${displayName})`, maxRetries: 1, baseDelay: 5000 }
+          );
+          console.log(`    ${c.success('Reduced-context retry succeeded')}`);
+        } catch (reduceErr) {
+          console.error(`    ${c.error(`Reduced-context retry also failed: ${reduceErr.message}`)}`);
+          throw reduceErr;
+        }
+      } 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;
@@ -628,6 +665,60 @@ ${segmentDumps}`;
 
   const contentParts = [{ text: compilationPrompt }];
 
+  // ------- Pre-flight context window check -------
+  const estimatedInputTokens = estimateTokens(compilationPrompt);
+  const safeLimit = Math.floor(config.GEMINI_CONTEXT_WINDOW * 0.80); // 80% of context window
+  if (estimatedInputTokens > safeLimit) {
+    console.warn(`  ${c.warn(`Compilation input (~${(estimatedInputTokens / 1000).toFixed(0)}K tokens) exceeds 80% of context window (${(safeLimit / 1000).toFixed(0)}K). Trimming older segment detail...`)}`);
+    // Re-build segment dumps with aggressive compression: keep only first & last 2 segments
+    // at full detail, compress the middle ones to IDs + statuses only.
+    const trimmedDumps = allSegmentAnalyses.map((analysis, idx) => {
+      const clean = { ...analysis };
+      delete clean._geminiMeta;
+      delete clean.seg;
+      delete clean.conversation_transcript;
+      const isEdge = idx < 2 || idx >= allSegmentAnalyses.length - 2;
+      if (!isEdge) {
+        // Aggressive compression for middle segments
+        if (clean.tickets) {
+          clean.tickets = clean.tickets.map(t => ({
+            ticket_id: t.ticket_id, status: t.status, title: t.title,
+            assignee: t.assignee, source_segment: t.source_segment,
+          }));
+        }
+        if (clean.change_requests) {
+          clean.change_requests = clean.change_requests.map(cr => ({
+            id: cr.id, status: cr.status, title: cr.title,
+            assigned_to: cr.assigned_to, source_segment: cr.source_segment,
+          }));
+        }
+        if (clean.action_items) {
+          clean.action_items = clean.action_items.map(ai => ({
+            id: ai.id, description: ai.description, assigned_to: ai.assigned_to,
+            status: ai.status, source_segment: ai.source_segment,
+          }));
+        }
+        delete clean.file_references;
+        clean.summary = (clean.summary || '').substring(0, 200);
+      } else {
+        if (clean.tickets) {
+          clean.tickets = clean.tickets.map(t => {
+            const tc = { ...t };
+            if (tc.comments && tc.comments.length > 5) {
+              tc.comments = tc.comments.slice(0, 5);
+              tc.comments.push({ note: `...${t.comments.length - 5} more comments omitted` });
+            }
+            return tc;
+          });
+        }
+      }
+      return `=== SEGMENT ${idx + 1} OF ${allSegmentAnalyses.length} ===\n${JSON.stringify(clean, null, 2)}`;
+    }).join('\n\n');
+    contentParts[0] = { text: compilationPrompt.replace(segmentDumps, trimmedDumps) };
+    const newEstimate = estimateTokens(contentParts[0].text);
+    console.log(`  Trimmed compilation input to ~${(newEstimate / 1000).toFixed(0)}K tokens`);
+  }
+
   const requestPayload = {
     model: config.GEMINI_MODEL,
     contents: [{ role: 'user', parts: contentParts }],
@@ -640,10 +731,44 @@ ${segmentDumps}`;
 
   const t0 = Date.now();
   console.log(`  Compiling with ${config.GEMINI_MODEL}...`);
-  const response = await withRetry(
-    () => ai.models.generateContent(requestPayload),
-    { label: 'Gemini final compilation', maxRetries: 2, baseDelay: 5000 }
-  );
+  let response;
+  try {
+    response = await withRetry(
+      () => ai.models.generateContent(requestPayload),
+      { label: 'Gemini final compilation', maxRetries: 2, baseDelay: 5000 }
+    );
+  } catch (compileErr) {
+    const errMsg = compileErr.message || '';
+    if (errMsg.includes('RESOURCE_EXHAUSTED') || errMsg.includes('429') || errMsg.includes('quota')) {
+      console.warn(`  ${c.warn('Context window or quota exceeded during compilation — waiting 30s and retrying with reduced input...')}`);
+      await new Promise(r => setTimeout(r, 30000));
+      // Halve the compilation prompt by keeping only edge segments
+      const miniDumps = allSegmentAnalyses.map((analysis, idx) => {
+        const clean = { tickets: (analysis.tickets || []).map(t => ({ ticket_id: t.ticket_id, status: t.status, title: t.title, assignee: t.assignee })),
+          change_requests: (analysis.change_requests || []).map(cr => ({ id: cr.id, status: cr.status, title: cr.title })),
+          action_items: (analysis.action_items || []).map(ai => ({ id: ai.id, description: ai.description, assigned_to: ai.assigned_to, status: ai.status })),
+          blockers: (analysis.blockers || []).map(b => ({ id: b.id, description: b.description, status: b.status })),
+          scope_changes: analysis.scope_changes || [],
+          your_tasks: analysis.your_tasks || {},
+          summary: (analysis.summary || '').substring(0, 300),
+        };
+        return `=== SEGMENT ${idx + 1} OF ${allSegmentAnalyses.length} ===\n${JSON.stringify(clean, null, 2)}`;
+      }).join('\n\n');
+      requestPayload.contents[0].parts = [{ text: compilationPrompt.replace(/SEGMENT ANALYSES:\n[\s\S]*$/, `SEGMENT ANALYSES:\n${miniDumps}`) }];
+      try {
+        response = await withRetry(
+          () => ai.models.generateContent(requestPayload),
+          { label: 'Gemini compilation (reduced)', maxRetries: 1, baseDelay: 5000 }
+        );
+        console.log(`  ${c.success('Reduced compilation succeeded')}`);
+      } catch (reduceErr) {
+        console.error(`  ${c.error(`Reduced compilation also failed: ${reduceErr.message}`)}`);
+        throw reduceErr;
+      }
+    } else {
+      throw compileErr;
+    }
+  }
   const durationMs = Date.now() - t0;
   const rawText = response.text;
 

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)')}

package/src/utils/context-manager.js

@@ -29,6 +29,14 @@ function estimateDocTokens(doc) {
   return 500;
 }
 
+/**
+ * Hard character limit for VTT fallback.
+ * When VTT parsing fails (0 cues), the full VTT is returned.
+ * Cap it so a huge transcript can't blow the context window.
+ * 500K chars ≈ 150K tokens — leaves plenty of room for docs + prompt.
+ */
+const VTT_FALLBACK_MAX_CHARS = 500000;
+
 // ════════════════════════════════════════════════════════════
 //  Priority Classification
 // ════════════════════════════════════════════════════════════
@@ -100,12 +108,16 @@ function selectDocsByBudget(allDocs, tokenBudget, opts = {}) {
   const excluded = [];
   let usedTokens = 0;
 
+  // Hard cap: even P0/P1 docs may not exceed 2× the budget.
+  // This prevents a handful of huge critical docs from blowing the context window.
+  const hardCap = tokenBudget * 2;
+
   for (const item of classified) {
     if (usedTokens + item.tokens <= tokenBudget) {
       selected.push(item.doc);
       usedTokens += item.tokens;
-    } else if (item.priority <= PRIORITY.HIGH) {
-      // P0 and P1 are always included even if over budget
+    } else if (item.priority <= PRIORITY.HIGH && usedTokens + item.tokens <= hardCap) {
+      // P0 and P1 are always included even if over budget, up to the hard cap
       selected.push(item.doc);
       usedTokens += item.tokens;
     } else {
@@ -171,14 +183,28 @@ function parseVttCues(vttContent) {
  */
 function sliceVttForSegment(vttContent, segStartSec, segEndSec, overlapSec = 30) {
   const cues = parseVttCues(vttContent);
-  if (cues.length === 0) return vttContent; // fallback: return full VTT
+  if (cues.length === 0) {
+    // Fallback: return full VTT but cap size to avoid context window overflow
+    if (vttContent.length > VTT_FALLBACK_MAX_CHARS) {
+      return vttContent.substring(0, VTT_FALLBACK_MAX_CHARS) +
+        `\n\n[TRUNCATED — original VTT was ${(vttContent.length / 1024).toFixed(0)} KB; capped at ${(VTT_FALLBACK_MAX_CHARS / 1024).toFixed(0)} KB]`;
+    }
+    return vttContent;
+  }
 
   const rangeStart = Math.max(0, segStartSec - overlapSec);
   const rangeEnd = segEndSec + overlapSec;
 
   const filtered = cues.filter(c => c.endSec >= rangeStart && c.startSec <= rangeEnd);
 
-  if (filtered.length === 0) return vttContent; // fallback
+  if (filtered.length === 0) {
+    // Fallback with cap
+    if (vttContent.length > VTT_FALLBACK_MAX_CHARS) {
+      return vttContent.substring(0, VTT_FALLBACK_MAX_CHARS) +
+        `\n\n[TRUNCATED — original VTT was ${(vttContent.length / 1024).toFixed(0)} KB; capped at ${(VTT_FALLBACK_MAX_CHARS / 1024).toFixed(0)} KB]`;
+    }
+    return vttContent;
+  }
 
   const header = `WEBVTT\n\n[Segment transcript: ${formatHMS(segStartSec)} — ${formatHMS(segEndSec)}]\n[Showing cues from ${formatHMS(rangeStart)} to ${formatHMS(rangeEnd)} with ${overlapSec}s overlap]\n`;
 
@@ -492,4 +518,5 @@ module.exports = {
   buildProgressiveContext,
   buildSegmentFocus,
   detectBoundaryContext,
+  VTT_FALLBACK_MAX_CHARS,
 };