task-summary-extractor 9.1.0 → 9.2.1

package/package.json

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

@@ -8,7 +8,7 @@ const { compileFinalResult } = require('../services/gemini');
 
 // --- Utils ---
 const { calculateCompilationBudget } = require('../utils/adaptive-budget');
-const { validateAnalysis, formatSchemaLine } = require('../utils/schema-validator');
+const { validateAnalysis, formatSchemaLine, normalizeAnalysis } = require('../utils/schema-validator');
 const { c } = require('../utils/colors');
 
 // --- Shared state ---
@@ -41,7 +41,7 @@ async function phaseCompile(ctx, allSegmentAnalyses) {
         { thinkingBudget: compBudget.budget }
       );
 
-      compiledAnalysis = compilationResult.compiled;
+      compiledAnalysis = normalizeAnalysis(compilationResult.compiled);
       compilationRun = compilationResult.run;
 
       // Track compilation cost

package/src/phases/init.js

@@ -12,7 +12,7 @@ const {
 
 // --- Utils ---
 const { c } = require('../utils/colors');
-const { parseArgs, showHelp, selectFolder, selectModel } = require('../utils/cli');
+const { parseArgs, showHelp, selectFolder, selectModel, selectRunMode, selectFormats, selectConfidence } = require('../utils/cli');
 const { promptForKey } = require('../utils/global-config');
 const Logger = require('../logger');
 const Progress = require('../utils/checkpoint');
@@ -73,9 +73,78 @@ async function phaseInit() {
     repoPath: flags.repo || null,
     model: typeof flags.model === 'string' ? flags.model : null,
     minConfidence: typeof flags['min-confidence'] === 'string' ? flags['min-confidence'].toLowerCase() : null,
-    format: typeof flags.format === 'string' ? flags.format.toLowerCase() : 'all',
+    format: typeof flags.format === 'string' ? flags.format.toLowerCase() : null,
+    runMode: null, // will be populated by interactive selector or inferred
   };
 
+  // --- Determine if user provided enough flags to skip interactive mode ---
+  const hasExplicitMode = opts.model || flags['no-focused-pass'] || flags['no-learning'] || flags['no-diff'] || opts.format;
+  const isNonInteractive = !process.stdin.isTTY;
+
+  // --- Interactive Run-Mode selector (only when TTY and no explicit flags) ---
+  if (!hasExplicitMode && !isNonInteractive && !opts.skipGemini) {
+    // Show the welcome banner
+    const pkg = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, 'package.json'), 'utf8'));
+    console.log('');
+    console.log(c.heading('  ┌──────────────────────────────────────────────────────────────────────────────┐'));
+    console.log(c.heading(`  │  ${c.bold('taskex')} ${c.dim(`v${pkg.version}`)}  —  AI-powered meeting analysis                              │`));
+    console.log(c.heading('  └──────────────────────────────────────────────────────────────────────────────┘'));
+
+    const mode = await selectRunMode();
+    opts.runMode = mode;
+
+    if (mode !== 'custom') {
+      // Apply preset overrides
+      const { selectRunMode: _ignore, ...cliModule } = require('../utils/cli');
+      // Access RUN_PRESETS from the module
+      const presetOverrides = {
+        fast: {
+          disableFocusedPass: true,
+          disableLearning: true,
+          disableDiff: true,
+          format: 'md,json',
+          formats: new Set(['md', 'json']),
+          modelTier: 'economy',
+        },
+        balanced: {
+          disableFocusedPass: false,
+          disableLearning: false,
+          disableDiff: false,
+          format: 'all',
+          formats: new Set(['md', 'html', 'json', 'pdf', 'docx']),
+          modelTier: 'balanced',
+        },
+        detailed: {
+          disableFocusedPass: false,
+          disableLearning: false,
+          disableDiff: false,
+          format: 'all',
+          formats: new Set(['md', 'html', 'json', 'pdf', 'docx']),
+          modelTier: 'premium',
+        },
+      };
+      const preset = presetOverrides[mode];
+      if (preset) {
+        opts.disableFocusedPass = preset.disableFocusedPass;
+        opts.disableLearning = preset.disableLearning;
+        opts.disableDiff = preset.disableDiff;
+        opts.format = preset.format;
+        opts.formats = preset.formats;
+        opts._modelTier = preset.modelTier; // used later for model auto-selection
+      }
+    } else {
+      // Custom mode: show interactive pickers for format & confidence
+      const chosenFormats = await selectFormats();
+      opts.formats = chosenFormats;
+      opts.format = chosenFormats.size === 5 ? 'all' : [...chosenFormats].join(',');
+
+      const chosenConfidence = await selectConfidence();
+      if (chosenConfidence) {
+        opts.minConfidence = chosenConfidence;
+      }
+    }
+  }
+
   // --- Validate min-confidence level ---
   if (opts.minConfidence) {
     const { validateConfidenceLevel } = require('../utils/confidence-filter');
@@ -87,18 +156,22 @@ async function phaseInit() {
   }
 
   // --- Validate --format flag (supports comma-separated: md,html,pdf) ---
-  const VALID_FORMATS = new Set(['md', 'html', 'json', 'pdf', 'docx', 'all']);
-  const requestedFormats = opts.format.split(',').map(f => f.trim()).filter(Boolean);
-  const invalidFormats = requestedFormats.filter(f => !VALID_FORMATS.has(f));
-  if (invalidFormats.length > 0) {
-    throw new Error(`Invalid --format "${invalidFormats.join(', ')}". Valid: md, html, json, pdf, docx, all`);
+  // If format wasn't set by interactive picker or flag, default to 'all'
+  if (!opts.format) opts.format = 'all';
+  if (!opts.formats) {
+    const VALID_FORMATS = new Set(['md', 'html', 'json', 'pdf', 'docx', 'all']);
+    const requestedFormats = opts.format.split(',').map(f => f.trim()).filter(Boolean);
+    const invalidFormats = requestedFormats.filter(f => !VALID_FORMATS.has(f));
+    if (invalidFormats.length > 0) {
+      throw new Error(`Invalid --format "${invalidFormats.join(', ')}". Valid: md, html, json, pdf, docx, all`);
+    }
+    // Normalise: "all" or set of specific formats
+    opts.formats = requestedFormats.includes('all')
+      ? new Set(['md', 'html', 'json', 'pdf', 'docx'])
+      : new Set(requestedFormats);
+    // Keep opts.format as the original string for backwards compatibility
+    opts.format = requestedFormats.includes('all') ? 'all' : requestedFormats.join(',');
   }
-  // Normalise: "all" or set of specific formats
-  opts.formats = requestedFormats.includes('all')
-    ? new Set(['md', 'html', 'json', 'pdf', 'docx'])
-    : new Set(requestedFormats);
-  // Keep opts.format as the original string for backwards compatibility
-  opts.format = requestedFormats.includes('all') ? 'all' : requestedFormats.join(',');
 
   // --- Resolve folder: positional arg or interactive selection ---
   let folderArg = positional[0];
@@ -186,6 +259,21 @@ async function phaseInit() {
     // CLI flag: --model <id> — validate and activate
     setActiveModel(opts.model);
     log.step(`Model set via flag: ${config.GEMINI_MODEL}`);
+  } else if (opts._modelTier) {
+    // Preset-driven: auto-select the best model for the chosen tier
+    const modelIds = Object.keys(GEMINI_MODELS);
+    const tierModel = modelIds.find(id => GEMINI_MODELS[id].tier === opts._modelTier);
+    if (tierModel) {
+      setActiveModel(tierModel);
+      console.log(c.success(`Model auto-selected: ${GEMINI_MODELS[tierModel].name} (${opts._modelTier} tier)`));
+      log.step(`Model auto-selected for ${opts._modelTier} tier: ${config.GEMINI_MODEL}`);
+    } else {
+      // Fallback to interactive if tier not found
+      const chosenModel = await selectModel(GEMINI_MODELS, config.GEMINI_MODEL);
+      setActiveModel(chosenModel);
+      log.step(`Model selected: ${config.GEMINI_MODEL}`);
+    }
+    delete opts._modelTier;
   } else {
     // Interactive model selection
     const chosenModel = await selectModel(GEMINI_MODELS, config.GEMINI_MODEL);
@@ -193,6 +281,9 @@ async function phaseInit() {
     log.step(`Model selected: ${config.GEMINI_MODEL}`);
   }
 
+  // --- Print run summary ---
+  _printRunSummary(opts, config.GEMINI_MODEL, GEMINI_MODELS, targetDir);
+
   // --- Initialize progress tracking ---
   const progress = new Progress(targetDir);
   const costTracker = new CostTracker(getActiveModelPricing());
@@ -204,4 +295,56 @@ async function phaseInit() {
   return { opts, targetDir, progress, costTracker, progressBar };
 }
 
-module.exports = phaseInit;
+/**
+ * Print a compact run summary with all active settings.
+ */
+function _printRunSummary(opts, modelId, models, targetDir) {
+  const modelName = (models[modelId] || {}).name || modelId;
+  const tier = (models[modelId] || {}).tier || '?';
+  const cost = (models[modelId] || {}).costEstimate || '';
+
+  console.log('');
+  console.log(c.heading('  ┌──────────────────────────────────────────────────────────────────────────────┐'));
+  console.log(c.heading('  │                        📋  Run Summary                                       │'));
+  console.log(c.heading('  └──────────────────────────────────────────────────────────────────────────────┘'));
+  console.log('');
+  console.log(`    ${c.dim('Folder:')}      ${c.bold(path.basename(targetDir))}`);
+  console.log(`    ${c.dim('Model:')}       ${c.bold(modelName)} ${c.dim(`(${tier})`)} ${cost ? c.dim(cost) : ''}`);
+  console.log(`    ${c.dim('Formats:')}     ${c.bold(opts.format === 'all' ? 'all (md, html, json, pdf, docx)' : opts.format)}`);
+
+  if (opts.minConfidence) {
+    console.log(`    ${c.dim('Confidence:')}  ${c.bold(opts.minConfidence)}+`);
+  }
+
+  // Feature toggles
+  const features = [];
+  if (!opts.disableFocusedPass) features.push(c.green('focused-pass'));
+  if (!opts.disableLearning) features.push(c.green('learning'));
+  if (!opts.disableDiff) features.push(c.green('diff'));
+  if (opts.deepDive) features.push(c.cyan('deep-dive'));
+  if (opts.dynamic) features.push(c.cyan('dynamic'));
+  if (opts.resume) features.push(c.yellow('resume'));
+  if (opts.dryRun) features.push(c.yellow('dry-run'));
+  if (opts.skipUpload) features.push(c.dim('skip-upload'));
+
+  const disabled = [];
+  if (opts.disableFocusedPass) disabled.push(c.dim('no-focused'));
+  if (opts.disableLearning) disabled.push(c.dim('no-learning'));
+  if (opts.disableDiff) disabled.push(c.dim('no-diff'));
+
+  if (features.length > 0) {
+    console.log(`    ${c.dim('Features:')}    ${features.join(c.dim(' · '))}`);
+  }
+  if (disabled.length > 0) {
+    console.log(`    ${c.dim('Disabled:')}    ${disabled.join(c.dim(' · '))}`);
+  }
+
+  if (opts.runMode) {
+    console.log(`    ${c.dim('Run mode:')}    ${c.bold(opts.runMode)}`);
+  }
+
+  console.log(c.dim('  ' + '─'.repeat(78)));
+  console.log('');
+}
+
+module.exports = phaseInit;

package/src/phases/process-media.js

@@ -17,7 +17,7 @@ const { fmtDuration, fmtBytes } = require('../utils/format');
 const { promptUser } = require('../utils/cli');
 const { parallelMap } = require('../utils/retry');
 const { assessQuality, formatQualityLine, getConfidenceStats, THRESHOLDS } = require('../utils/quality-gate');
-const { validateAnalysis, formatSchemaLine, schemaScore } = require('../utils/schema-validator');
+const { validateAnalysis, formatSchemaLine, schemaScore, normalizeAnalysis } = require('../utils/schema-validator');
 const { calculateThinkingBudget } = require('../utils/adaptive-budget');
 const { detectBoundaryContext, sliceVttForSegment } = require('../utils/context-manager');
 
@@ -264,7 +264,7 @@ async function phaseProcessVideo(ctx, videoPath, videoIndex) {
       try {
         const existingRun = JSON.parse(fs.readFileSync(latestRunPath, 'utf8'));
         geminiRunFile = path.relative(PROJECT_ROOT, path.join(geminiRunsDir, latestRunFile));
-        analysis = existingRun.output.parsed || { rawResponse: existingRun.output.raw };
+        analysis = normalizeAnalysis(existingRun.output.parsed || { rawResponse: existingRun.output.raw });
         analysis._geminiMeta = {
           model: existingRun.run.model,
           processedAt: existingRun.run.timestamp,
@@ -396,7 +396,7 @@ async function phaseProcessVideo(ctx, videoPath, videoIndex) {
         geminiFileName = geminiRun.input.videoFile.geminiFileName || null;
         const usedExternalUrl = geminiRun.input.videoFile.usedExternalUrl || false;
 
-        analysis = geminiRun.output.parsed || { rawResponse: geminiRun.output.raw };
+        analysis = normalizeAnalysis(geminiRun.output.parsed || { rawResponse: geminiRun.output.raw });
         analysis._geminiMeta = {
           model: geminiRun.run.model,
           processedAt: geminiRun.run.timestamp,
@@ -474,7 +474,7 @@ async function phaseProcessVideo(ctx, videoPath, videoIndex) {
             const retryRunFilePath = path.join(geminiRunsDir, retryRunFileName);
             fs.writeFileSync(retryRunFilePath, JSON.stringify(retryRun, null, 2), 'utf8');
 
-            const retryAnalysis = retryRun.output.parsed || { rawResponse: retryRun.output.raw };
+            const retryAnalysis = normalizeAnalysis(retryRun.output.parsed || { rawResponse: retryRun.output.raw });
             const retryQuality = assessQuality(retryAnalysis, {
               parseSuccess: retryRun.output.parseSuccess,
               rawLength: (retryRun.output.raw || '').length,
@@ -492,7 +492,7 @@ async function phaseProcessVideo(ctx, videoPath, videoIndex) {
             // Use retry result if better
             if (retryQuality.score > qualityReport.score) {
               retryImproved = true;
-              analysis = retryAnalysis;
+              analysis = normalizeAnalysis(retryAnalysis);
               analysis._geminiMeta = {
                 model: retryRun.run.model,
                 processedAt: retryRun.run.timestamp,

package/src/pipeline.js

@@ -231,7 +231,7 @@ async function run() {
 async function runDocOnly(ctx) {
   // Lazy imports for doc-only mode
   const { compileFinalResult } = require('./services/gemini');
-  const { validateAnalysis, formatSchemaLine } = require('./utils/schema-validator');
+  const { validateAnalysis, formatSchemaLine, normalizeAnalysis } = require('./utils/schema-validator');
   const { renderResultsMarkdown } = require('./renderers/markdown');
   const { renderResultsHtml } = require('./renderers/html');
   const { renderResultsPdf } = require('./renderers/pdf');
@@ -297,7 +297,7 @@ async function runDocOnly(ctx) {
       }
     );
 
-    compiledAnalysis = compilationResult.compiled;
+    compiledAnalysis = normalizeAnalysis(compilationResult.compiled);
     compilationRun = compilationResult.run;
 
     if (compilationRun?.tokenUsage) {

package/src/schemas/analysis-segment.schema.json

@@ -5,7 +5,7 @@
   "description": "JSON Schema for a single segment's AI analysis output. Uses additionalProperties:true to allow extra fields without failing.",
   "type": "object",
   "additionalProperties": true,
-  "required": ["tickets", "action_items", "change_requests", "summary"],
+  "required": ["summary"],
   "properties": {
     "tickets": {
       "type": "array",

package/src/utils/cli.js

@@ -354,6 +354,11 @@ function showHelp() {
     ${c.bold('taskex setup')} ${c.dim('[--check | --silent]')}
     ${c.bold('taskex config')} ${c.dim('[--show | --clear]')}
 
+  ${h('INTERACTIVE MODE')}
+${f('taskex', 'Launch interactive wizard — choose run mode, model, format, confidence')}
+${f2('Run modes: ⚡ Fast · ⚖️ Balanced · 🔬 Detailed · ⚙️ Custom')}
+${f2('When flags are provided, interactive prompts are skipped automatically.')}
+
   ${h('SUBCOMMANDS')}
 ${f('setup', 'Full interactive setup (prerequisites, deps, .env)')}
 ${f('setup --check', 'Validation only — verify environment')}
@@ -417,8 +422,10 @@ ${f('--help, -h', 'Show this help message')}
 ${f('--version, -v', 'Show version')}
 
   ${h('EXAMPLES')}
-    ${c.dim('$')} taskex ${c.dim('# Interactive mode')}
-    ${c.dim('$')} taskex "call 1" ${c.dim('# Analyze a call')}
+    ${c.dim('$')} taskex ${c.dim('# Interactive wizard — choose mode, model, format')}
+    ${c.dim('$')} taskex "call 1" ${c.dim('# Analyze a call (interactive wizard)')}
+    ${c.dim('$')} taskex --model gemini-2.5-pro "call 1" ${c.dim('# Skip wizard, use specific model')}
+    ${c.dim('$')} taskex --format md,html "call 1" ${c.dim('# Skip wizard, specific formats')}
     ${c.dim('$')} taskex --name "Jane" --skip-upload "call 1"
     ${c.dim('$')} taskex --model gemini-2.5-pro --deep-dive "call 1"
     ${c.dim('$')} taskex --dynamic --request "Plan API migration" "specs"
@@ -434,7 +441,10 @@ ${f('--version, -v', 'Show version')}
   throw Object.assign(new Error('HELP_SHOWN'), { code: 'HELP_SHOWN' });
 }
 
-module.exports = { parseArgs, showHelp, discoverFolders, selectFolder, selectModel, promptUser, promptUserText };
+module.exports = {
+  parseArgs, showHelp, discoverFolders, selectFolder, selectModel,
+  promptUser, promptUserText, selectRunMode, selectFormats, selectConfidence,
+};
 
 // ======================== INTERACTIVE PROMPTS ========================
 
@@ -462,3 +472,252 @@ function promptUserText(question) {
     });
   });
 }
+
+// ======================== RUN MODE SELECTOR ========================
+
+/**
+ * Run-mode presets. Each key maps to a set of opts overrides.
+ * 'custom' triggers the interactive per-setting prompts.
+ */
+const RUN_PRESETS = {
+  fast: {
+    label: 'Fast',
+    icon: '⚡',
+    description: 'Economy model, skip extras, Markdown + JSON only — fastest & cheapest',
+    overrides: {
+      disableFocusedPass: true,
+      disableLearning: true,
+      disableDiff: true,
+      format: 'md,json',
+      formats: new Set(['md', 'json']),
+      modelTier: 'economy',
+    },
+  },
+  balanced: {
+    label: 'Balanced',
+    icon: '⚖️',
+    description: 'Balanced model, learning enabled, all formats — recommended default',
+    overrides: {
+      disableFocusedPass: false,
+      disableLearning: false,
+      disableDiff: false,
+      format: 'all',
+      formats: new Set(['md', 'html', 'json', 'pdf', 'docx']),
+      modelTier: 'balanced',
+    },
+  },
+  detailed: {
+    label: 'Detailed',
+    icon: '🔬',
+    description: 'Premium model, all features, all formats — highest quality analysis',
+    overrides: {
+      disableFocusedPass: false,
+      disableLearning: false,
+      disableDiff: false,
+      format: 'all',
+      formats: new Set(['md', 'html', 'json', 'pdf', 'docx']),
+      modelTier: 'premium',
+    },
+  },
+  custom: {
+    label: 'Custom',
+    icon: '⚙️',
+    description: 'Choose each setting interactively',
+    overrides: {},
+  },
+};
+
+/**
+ * Interactive run-mode selector. Shows preset options and returns the chosen
+ * preset key. The caller applies overrides to opts.
+ *
+ * @returns {Promise<string>} Preset key: 'fast' | 'balanced' | 'detailed' | 'custom'
+ */
+async function selectRunMode() {
+  const readline = require('readline');
+  const presetKeys = Object.keys(RUN_PRESETS);
+
+  console.log('');
+  console.log(c.heading('  ┌──────────────────────────────────────────────────────────────────────────────┐'));
+  console.log(c.heading('  │                        🚀  Run Mode                                          │'));
+  console.log(c.heading('  └──────────────────────────────────────────────────────────────────────────────┘'));
+  console.log('');
+
+  presetKeys.forEach((key, i) => {
+    const p = RUN_PRESETS[key];
+    const num = c.cyan(`[${i + 1}]`);
+    const label = c.bold(`${p.icon} ${p.label}`);
+    const desc = c.dim(p.description);
+    const marker = key === 'balanced' ? c.green(' ← default') : '';
+    console.log(`    ${num} ${label}${marker}`);
+    console.log(`        ${desc}`);
+  });
+  console.log('');
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question('  Select run mode [1-4] (Enter = balanced): ', answer => {
+      rl.close();
+      const trimmed = (answer || '').trim();
+
+      if (!trimmed) {
+        console.log(c.success('Using balanced mode'));
+        resolve('balanced');
+        return;
+      }
+
+      const num = parseInt(trimmed, 10);
+      if (num >= 1 && num <= presetKeys.length) {
+        const key = presetKeys[num - 1];
+        console.log(c.success(`Using ${RUN_PRESETS[key].label} mode`));
+        resolve(key);
+        return;
+      }
+
+      // Try matching by name
+      const lower = trimmed.toLowerCase();
+      const match = presetKeys.find(k => k === lower || RUN_PRESETS[k].label.toLowerCase() === lower);
+      if (match) {
+        console.log(c.success(`Using ${RUN_PRESETS[match].label} mode`));
+        resolve(match);
+        return;
+      }
+
+      console.log(c.warn(`Unknown "${trimmed}" — using balanced mode`));
+      resolve('balanced');
+    });
+  });
+}
+
+// ======================== FORMAT PICKER ========================
+
+const ALL_FORMATS = [
+  { key: 'md',   icon: '📝', label: 'Markdown',  desc: 'Human-readable report' },
+  { key: 'html', icon: '🌐', label: 'HTML',      desc: 'Styled web page' },
+  { key: 'pdf',  icon: '📄', label: 'PDF',       desc: 'Portable document' },
+  { key: 'docx', icon: '📘', label: 'Word',      desc: 'Editable Word document' },
+  { key: 'json', icon: '🔧', label: 'JSON',      desc: 'Machine-readable data' },
+];
+
+/**
+ * Interactive format picker — user enters comma-separated numbers or "all".
+ * Returns a Set of chosen format keys.
+ *
+ * @returns {Promise<Set<string>>}
+ */
+async function selectFormats() {
+  const readline = require('readline');
+
+  console.log('');
+  console.log(`  ${c.bold('📦 Output Formats')} ${c.dim('(select one or more)')}`);
+  console.log(c.dim('  ' + '─'.repeat(50)));
+
+  ALL_FORMATS.forEach((f, i) => {
+    const num = c.cyan(`[${i + 1}]`);
+    console.log(`    ${num} ${f.icon} ${c.bold(f.label.padEnd(12))} ${c.dim(f.desc)}`);
+  });
+  console.log(`    ${c.cyan('[A]')} ${c.bold('All formats')}`);
+  console.log('');
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question('  Formats (e.g. 1,2,3 or A for all) [Enter = all]: ', answer => {
+      rl.close();
+      const trimmed = (answer || '').trim().toLowerCase();
+
+      if (!trimmed || trimmed === 'a' || trimmed === 'all') {
+        const all = new Set(ALL_FORMATS.map(f => f.key));
+        console.log(c.success('All formats selected'));
+        resolve(all);
+        return;
+      }
+
+      const parts = trimmed.split(/[\s,]+/).filter(Boolean);
+      const chosen = new Set();
+      for (const p of parts) {
+        const num = parseInt(p, 10);
+        if (num >= 1 && num <= ALL_FORMATS.length) {
+          chosen.add(ALL_FORMATS[num - 1].key);
+        } else {
+          // Try matching format key by name
+          const match = ALL_FORMATS.find(f => f.key === p || f.label.toLowerCase() === p);
+          if (match) chosen.add(match.key);
+        }
+      }
+
+      if (chosen.size === 0) {
+        console.log(c.warn('No valid formats selected — using all'));
+        resolve(new Set(ALL_FORMATS.map(f => f.key)));
+        return;
+      }
+
+      const labels = [...chosen].map(k => ALL_FORMATS.find(f => f.key === k)?.label || k);
+      console.log(c.success(`Formats: ${labels.join(', ')}`));
+      resolve(chosen);
+    });
+  });
+}
+
+// ======================== CONFIDENCE PICKER ========================
+
+/**
+ * Interactive confidence-level selector.
+ * Returns null (keep all) or a string like 'high' or 'medium'.
+ *
+ * @returns {Promise<string|null>}
+ */
+async function selectConfidence() {
+  const readline = require('readline');
+
+  const levels = [
+    { key: null,     icon: '🌐', label: 'All',    desc: 'Keep everything — no filtering' },
+    { key: 'low',    icon: '🟡', label: 'Low+',   desc: 'Keep low, medium & high confidence' },
+    { key: 'medium', icon: '🟠', label: 'Medium+', desc: 'Keep medium & high confidence' },
+    { key: 'high',   icon: '🔴', label: 'High',   desc: 'Only high-confidence items' },
+  ];
+
+  console.log('');
+  console.log(`  ${c.bold('🎯 Confidence Filter')}`);
+  console.log(c.dim('  ' + '─'.repeat(50)));
+
+  levels.forEach((l, i) => {
+    const num = c.cyan(`[${i + 1}]`);
+    const marker = i === 0 ? c.green(' ← default') : '';
+    console.log(`    ${num} ${l.icon} ${c.bold(l.label.padEnd(10))} ${c.dim(l.desc)}${marker}`);
+  });
+  console.log('');
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question('  Confidence filter [1-4] (Enter = keep all): ', answer => {
+      rl.close();
+      const trimmed = (answer || '').trim();
+
+      if (!trimmed) {
+        console.log(c.success('Keeping all confidence levels'));
+        resolve(null);
+        return;
+      }
+
+      const num = parseInt(trimmed, 10);
+      if (num >= 1 && num <= levels.length) {
+        const chosen = levels[num - 1];
+        console.log(c.success(`Confidence filter: ${chosen.label}`));
+        resolve(chosen.key);
+        return;
+      }
+
+      // Try matching by name
+      const lower = trimmed.toLowerCase();
+      const match = levels.find(l => l.key === lower || l.label.toLowerCase() === lower);
+      if (match) {
+        console.log(c.success(`Confidence filter: ${match.label}`));
+        resolve(match.key);
+        return;
+      }
+
+      console.log(c.warn(`Unknown "${trimmed}" — keeping all`));
+      resolve(null);
+    });
+  });
+}

package/src/utils/quality-gate.js

@@ -29,14 +29,16 @@ const THRESHOLDS = {
 
 // Required top-level fields in a valid analysis
 const REQUIRED_FIELDS = [
-  'tickets',
-  'action_items',
-  'change_requests',
   'summary',
 ];
 
 // Optional but valuable fields (boost score when present)
+// tickets, action_items, change_requests are here because a segment may
+// legitimately contain none of these (e.g. a segment that is only chit-chat).
 const VALUED_FIELDS = [
+  'tickets',
+  'action_items',
+  'change_requests',
   'blockers',
   'scope_changes',
   'file_references',
@@ -70,11 +72,11 @@ function scoreStructure(analysis) {
   let bonus = 0;
   for (const field of VALUED_FIELDS) {
     if (analysis[field] !== undefined && analysis[field] !== null) {
-      bonus += 3; // up to 12 bonus points
+      bonus += 2; // up to 14 bonus points (7 valued fields)
     }
   }
 
-  const baseScore = (present / REQUIRED_FIELDS.length) * 80;
+  const baseScore = (present / REQUIRED_FIELDS.length) * 70;
   return { score: Math.min(100, baseScore + bonus), issues };
 }
 
@@ -335,7 +337,7 @@ function buildRetryHints(analysis, issues) {
   const hints = [];
 
   if (issues.some(i => i.includes('Missing required field'))) {
-    hints.push('CRITICAL: Your previous response was missing required fields. You MUST include ALL of: tickets, action_items, change_requests, summary. Use empty arrays [] if no items exist.');
+    hints.push('CRITICAL: Your previous response was missing the required "summary" field. You MUST include a "summary" string. Include tickets, action_items, and change_requests arrays if relevant — omit them or use empty arrays [] if none exist in this segment.');
   }
 
   if (issues.some(i => i.includes('JSON parse failed'))) {

package/src/utils/schema-validator.js

@@ -306,9 +306,38 @@ function formatSchemaLine(report) {
   return `    ${c.warn(`Schema: ${report.errorCount} error(s) — ${report.errors.slice(0, 2).map(e => e.message).join('; ')}`)}`;
 }
 
+// ======================== POST-PARSE NORMALIZATION ========================
+
+/** Array fields that should default to [] when missing from analysis output. */
+const ARRAY_DEFAULTS = [
+  'tickets', 'action_items', 'change_requests',
+  'blockers', 'scope_changes', 'file_references',
+];
+
+/**
+ * Normalize a parsed analysis object by filling in missing array fields
+ * with empty arrays. This prevents downstream code from crashing when
+ * a segment legitimately has no tickets/action_items/etc.
+ *
+ * Mutates `data` in-place and returns it for convenience.
+ *
+ * @param {object} data - Parsed analysis (may have missing fields)
+ * @returns {object} The same object with defaults applied
+ */
+function normalizeAnalysis(data) {
+  if (!data || typeof data !== 'object') return data;
+  for (const field of ARRAY_DEFAULTS) {
+    if (data[field] === undefined || data[field] === null) {
+      data[field] = [];
+    }
+  }
+  return data;
+}
+
 module.exports = {
   validateAnalysis,
   buildSchemaRetryHints,
   schemaScore,
   formatSchemaLine,
+  normalizeAnalysis,
 };