task-summary-extractor 9.0.1 → 9.2.0

package/package.json

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

package/src/phases/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');
@@ -86,10 +155,22 @@ async function phaseInit() {
     opts.minConfidence = check.normalised.toLowerCase();
   }
 
-  // --- Validate --format flag ---
-  const VALID_FORMATS = new Set(['md', 'html', 'json', 'pdf', 'docx', 'all']);
-  if (!VALID_FORMATS.has(opts.format)) {
-    throw new Error(`Invalid --format "${opts.format}". Must be: md, html, json, pdf, docx, or all`);
+  // --- Validate --format flag (supports comma-separated: md,html,pdf) ---
+  // 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(',');
   }
 
   // --- Resolve folder: positional arg or interactive selection ---
@@ -178,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);
@@ -185,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());
@@ -196,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/output.js

@@ -25,6 +25,8 @@ const { getLog, phaseTimer, PROJECT_ROOT } = require('./_shared');
 
 /** Check whether a given output type should be rendered. */
 function shouldRender(opts, type) {
+  if (opts.formats) return opts.formats.has(type);
+  // Fallback for legacy callers
   if (opts.format === 'all') return true;
   return opts.format === type;
 }
@@ -59,14 +61,11 @@ async function phaseOutput(ctx, results, compiledAnalysis, compilationRun, compi
   // Attach cost summary to results
   results.costSummary = costTracker.getSummary();
 
-  // Write results JSON (always written unless --format excludes it)
+  // Write results JSON (always written; logged only when JSON format is requested)
   const jsonPath = path.join(runDir, 'results.json');
-  if (shouldRender(opts, 'json') || opts.format === 'all') {
-    fs.writeFileSync(jsonPath, JSON.stringify(results, null, 2), 'utf8');
+  fs.writeFileSync(jsonPath, JSON.stringify(results, null, 2), 'utf8');
+  if (shouldRender(opts, 'json')) {
     log.step(`Results JSON saved → ${jsonPath}`);
-  } else {
-    // Still write JSON internally (needed for uploads/diffs) but don't advertise
-    fs.writeFileSync(jsonPath, JSON.stringify(results, null, 2), 'utf8');
   }
 
   // Generate Markdown

package/src/pipeline.js

@@ -370,7 +370,7 @@ async function runDocOnly(ctx) {
   const jsonPath = path.join(runDir, 'results.json');
   fs.writeFileSync(jsonPath, JSON.stringify(results, null, 2), 'utf8');
 
-  const shouldRender = (type) => opts.format === 'all' || opts.format === type;
+  const shouldRender = (type) => opts.formats ? opts.formats.has(type) : (opts.format === 'all' || opts.format === type);
 
   if (compiledAnalysis) {
     const mdMeta = {

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')}
@@ -370,7 +375,7 @@ ${f('--deep-dive', 'Generate explanatory docs per topic')}
   ${h('CORE OPTIONS')}
 ${f('--name <name>', 'Your name (skip interactive prompt)')}
 ${f('--model <id>', 'Gemini model (skip interactive selector)')}
-${f('--format <type>', 'Output formats: md, html, json, pdf, docx, all (default: all)')}
+${f('--format <type>', 'Output: md, html, json, pdf, docx, all — comma-separated (default: all)')}
 ${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')}
@@ -417,13 +422,16 @@ ${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"
     ${c.dim('$')} taskex --min-confidence medium "call 1" ${c.dim('# Filter low-confidence')}
     ${c.dim('$')} taskex --format md "call 1" ${c.dim('# Markdown only')}
+    ${c.dim('$')} taskex --format md,html,pdf "call 1" ${c.dim('# Multiple formats')}
     ${c.dim('$')} taskex --format pdf "call 1" ${c.dim('# PDF report')}
     ${c.dim('$')} taskex --format docx "call 1" ${c.dim('# Word document')}
     ${c.dim('$')} taskex --resume "call 1" ${c.dim('# Resume interrupted run')}
@@ -433,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 ========================
 
@@ -461,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);
+    });
+  });
+}