metame-cli 1.4.34 → 1.5.1

package/scripts/providers.js

@@ -21,12 +21,46 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const HOME = os.homedir();
-const METAME_DIR = path.join(HOME, '.metame');
-const PROVIDERS_FILE = path.join(METAME_DIR, 'providers.yaml');
-
 const yaml = require('./resolve-yaml');
 
+const DEFAULT_DISTILL_MODEL = 'haiku';
+const DISTILL_MODEL_ALIASES = new Map([
+  ['5.1mini', 'gpt-5.1-codex-mini'],
+  ['gpt5.1mini', 'gpt-5.1-codex-mini'],
+  ['gpt-5.1-mini', 'gpt-5.1-codex-mini'],
+  ['gpt5.1-codex-mini', 'gpt-5.1-codex-mini'],
+  ['codex-mini', 'gpt-5.1-codex-mini'],
+  ['5mini', 'gpt-5-mini'],
+  ['gpt5mini', 'gpt-5-mini'],
+]);
+
+function canonicalizeAliasKey(input) {
+  return String(input || '').trim().toLowerCase().replace(/[\s_]+/g, '').replace(/^gpt[-\s]?/i, 'gpt');
+}
+
+function normalizeDistillModel(model, { allowEmpty = false } = {}) {
+  const raw = String(model || '').trim();
+  if (!raw) {
+    if (allowEmpty) return null;
+    throw new Error('蒸馏模型不能为空。');
+  }
+  const alias = DISTILL_MODEL_ALIASES.get(canonicalizeAliasKey(raw));
+  const normalized = (alias || raw).trim();
+  if (!/^[a-zA-Z0-9._-]{2,80}$/.test(normalized)) {
+    throw new Error(`无效蒸馏模型: ${raw}`);
+  }
+  return normalized;
+}
+
+function resolveDistillModel(config, overrideModel) {
+  if (overrideModel !== undefined && overrideModel !== null && String(overrideModel).trim() !== '') {
+    return normalizeDistillModel(overrideModel);
+  }
+  const configured = config && config.distill_model ? String(config.distill_model).trim() : '';
+  if (configured) return normalizeDistillModel(configured);
+  return DEFAULT_DISTILL_MODEL;
+}
+
 // ---------------------------------------------------------
 // DEFAULT CONFIG
 // ---------------------------------------------------------
@@ -38,6 +72,7 @@ function defaultConfig() {
     },
     distill_provider: null,
     daemon_provider: null,
+    distill_model: null,
   };
 }
 
@@ -45,13 +80,49 @@ function defaultConfig() {
 // LOAD / SAVE (cached — file rarely changes)
 // ---------------------------------------------------------
 let _providersCache = null;
+let _providersCachePath = '';
+let _providersCacheStamp = '';
 
-function loadProviders() {
-  if (_providersCache) return _providersCache;
+function getProvidersFilePath() {
+  const home = process.env.HOME || os.homedir();
+  return path.join(home, '.metame', 'providers.yaml');
+}
+
+function computeFileStamp(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return 'missing';
+    const st = fs.statSync(filePath);
+    return `${Math.trunc(st.mtimeMs)}:${st.size}`;
+  } catch {
+    return 'error';
+  }
+}
+
+function loadProviders(options = {}) {
+  const force = !!(options && options.force);
+  const providersFile = getProvidersFilePath();
+  const currentStamp = computeFileStamp(providersFile);
+  if (_providersCachePath && _providersCachePath !== providersFile) {
+    _providersCache = null;
+    _providersCacheStamp = '';
+  }
+  if (!force && _providersCache && _providersCachePath === providersFile && _providersCacheStamp === currentStamp) {
+    return _providersCache;
+  }
   try {
-    if (!fs.existsSync(PROVIDERS_FILE)) { _providersCache = defaultConfig(); return _providersCache; }
-    const data = yaml.load(fs.readFileSync(PROVIDERS_FILE, 'utf8'));
-    if (!data || typeof data !== 'object') { _providersCache = defaultConfig(); return _providersCache; }
+    if (!fs.existsSync(providersFile)) {
+      _providersCachePath = providersFile;
+      _providersCacheStamp = currentStamp;
+      _providersCache = defaultConfig();
+      return _providersCache;
+    }
+    const data = yaml.load(fs.readFileSync(providersFile, 'utf8'));
+    if (!data || typeof data !== 'object') {
+      _providersCachePath = providersFile;
+      _providersCacheStamp = currentStamp;
+      _providersCache = defaultConfig();
+      return _providersCache;
+    }
     if (!data.providers) data.providers = {};
     if (!data.providers.anthropic) data.providers.anthropic = { label: 'Anthropic (Official)' };
     _providersCache = {
@@ -59,18 +130,29 @@ function loadProviders() {
       providers: data.providers,
       distill_provider: data.distill_provider || null,
       daemon_provider: data.daemon_provider || null,
+      distill_model: (() => {
+        try { return normalizeDistillModel(data.distill_model, { allowEmpty: true }); } catch { return null; }
+      })(),
     };
+    _providersCachePath = providersFile;
+    _providersCacheStamp = currentStamp;
     return _providersCache;
   } catch {
+    _providersCachePath = providersFile;
+    _providersCacheStamp = currentStamp;
     _providersCache = defaultConfig();
     return _providersCache;
   }
 }
 
 function saveProviders(config) {
-  if (!fs.existsSync(METAME_DIR)) fs.mkdirSync(METAME_DIR, { recursive: true });
-  fs.writeFileSync(PROVIDERS_FILE, yaml.dump(config, { lineWidth: -1 }), 'utf8');
-  _providersCache = null; // invalidate on write
+  const providersFile = getProvidersFilePath();
+  const metameDir = path.dirname(providersFile);
+  if (!fs.existsSync(metameDir)) fs.mkdirSync(metameDir, { recursive: true });
+  fs.writeFileSync(providersFile, yaml.dump(config, { lineWidth: -1 }), 'utf8');
+  _providersCache = null;
+  _providersCachePath = providersFile;
+  _providersCacheStamp = '';
 }
 
 // ---------------------------------------------------------
@@ -182,6 +264,19 @@ function setRole(role, providerName) {
   saveProviders(config);
 }
 
+function getDistillModel() {
+  const config = loadProviders();
+  return resolveDistillModel(config);
+}
+
+function setDistillModel(model) {
+  const config = loadProviders();
+  const normalized = normalizeDistillModel(model, { allowEmpty: true });
+  config.distill_model = normalized || null;
+  saveProviders(config);
+  return config.distill_model;
+}
+
 // ---------------------------------------------------------
 // DISPLAY
 // ---------------------------------------------------------
@@ -204,6 +299,7 @@ function listFormatted() {
     if (d) lines.push(`  Distill provider: ${d}`);
     if (dm) lines.push(`  Daemon provider:  ${dm}`);
   }
+  lines.push(`  Distill model:    ${resolveDistillModel(config)}`);
 
   return lines.join('\n');
 }
@@ -212,18 +308,45 @@ function listFormatted() {
 // Claude subprocess helper (shared by distill.js + skill-evolution.js)
 // ---------------------------------------------------------
 /**
- * Call `claude -p --model haiku` as a subprocess with extra env vars.
- * Deletes CLAUDECODE from env to prevent recursive session detection.
+ * Historical name: now this helper calls the configured distill model,
+ * not necessarily Haiku.
+ */
+function callHaiku(input, extraEnv, timeout, options = {}) {
+  return callDistillModel(input, extraEnv, timeout, options);
+}
+
+/**
+ * Call distill model as a subprocess with extra env vars.
+ * Engine-aware: claude uses `claude -p --model`, codex uses `codex exec --json -m`.
  */
-function callHaiku(input, extraEnv, timeout) {
+function callDistillModel(input, extraEnv, timeout, options = {}) {
   const { execFile } = require('child_process');
   const env = { ...process.env, ...extraEnv, METAME_INTERNAL_PROMPT: '1' };
   delete env.CLAUDECODE;
+  // Force refresh to pick up cross-process edits to providers.yaml immediately.
+  const config = loadProviders({ force: true });
+  const model = resolveDistillModel(config, options.model);
+  const engine = options.engine || _currentEngine;
+  const bin = engine === 'codex' ? 'codex' : 'claude';
+  const args = engine === 'codex'
+    ? ['exec', '--json', '-m', model, '--full-auto', '-']
+    : ['-p', '--model', model, '--no-session-persistence'];
+  // On Windows, bare binary names need shell:true to resolve .cmd wrappers.
+  // For codex, also sanitize CODEX_HOME if it points to a non-existent path.
+  const isWin = process.platform === 'win32';
+  if (isWin && engine === 'codex' && env.CODEX_HOME && !fs.existsSync(env.CODEX_HOME)) {
+    delete env.CODEX_HOME;
+  }
+  const spawnOpts = {
+    env,
+    timeout,
+    maxBuffer: 10 * 1024 * 1024,
+    ...(isWin ? { shell: process.env.COMSPEC || true, windowsHide: true } : {}),
+  };
   return new Promise((resolve, reject) => {
     const proc = execFile(
-      'claude',
-      ['-p', '--model', 'haiku', '--no-session-persistence'],
-      { env, timeout, maxBuffer: 10 * 1024 * 1024 },
+      bin, args,
+      spawnOpts,
       (err, stdout, stderr) => {
         if (err) {
           const detail = (stderr || stdout || '').trim().split('\n')[0];
@@ -231,7 +354,24 @@ function callHaiku(input, extraEnv, timeout) {
           err.stdout = stdout;
           err.stderr = stderr;
           reject(err);
-        } else resolve(stdout.trim());
+        } else {
+          // codex --json outputs JSON lines; extract agent message text
+          if (engine === 'codex') {
+            try {
+              const lines = stdout.trim().split('\n');
+              for (let i = lines.length - 1; i >= 0; i--) {
+                const evt = JSON.parse(lines[i]);
+                if (evt.type === 'item.completed' && evt.item && evt.item.type === 'agent_message') {
+                  // item.text (string) is the primary field; content[] is an alternative format
+                  const text = evt.item.text
+                    || (evt.item.content || []).filter(c => c.type === 'text').map(c => c.text).join('\n');
+                  if (text && text.trim()) { resolve(text.trim()); return; }
+                }
+              }
+            } catch { /* fall through */ }
+          }
+          resolve(stdout.trim());
+        }
       },
     );
     proc.stdin.write(input);
@@ -240,9 +380,14 @@ function callHaiku(input, extraEnv, timeout) {
 }
 
 // ---------------------------------------------------------
-// EXPORTS
+// ENGINE AWARENESS (set by daemon.js setDefaultEngine)
+// ---------------------------------------------------------
+let _currentEngine = process.env.METAME_ENGINE === 'codex' ? 'codex' : 'claude';
+function setEngine(name) { _currentEngine = (name === 'codex') ? 'codex' : 'claude'; }
+function getEngine() { return _currentEngine; }
+
 // ---------------------------------------------------------
-module.exports = {
+const api = {
   loadProviders,
   saveProviders,
   buildEnv,
@@ -256,7 +401,22 @@ module.exports = {
   addProvider,
   removeProvider,
   setRole,
+  getDistillModel,
+  setDistillModel,
+  normalizeDistillModel,
   listFormatted,
+  callDistillModel,
   callHaiku,
-  PROVIDERS_FILE,
+  getProvidersFilePath,
+  setEngine,
+  getEngine,
 };
+
+Object.defineProperty(api, 'PROVIDERS_FILE', {
+  enumerable: true,
+  get: () => getProvidersFilePath(),
+});
+
+// EXPORTS
+// ---------------------------------------------------------
+module.exports = api;

package/scripts/schema.js

@@ -109,6 +109,9 @@ const SCHEMA = {
   'growth.last_reflection': { tier: 'T5', type: 'string' },
   'growth.quiet_until': { tier: 'T5', type: 'string' },
   'growth.mirror_enabled': { tier: 'T5', type: 'boolean' },
+  'growth.mentor_mode': { tier: 'T5', type: 'enum', values: ['off', 'gentle', 'active', 'intense'] },
+  'growth.mentor_friction_level': { tier: 'T5', type: 'number', min: 0, max: 10 },
+  'growth.weekly_report_last': { tier: 'T5', type: 'string' },
 };
 
 /**
@@ -181,6 +184,15 @@ function validate(key, value) {
     }
   }
 
+  if (def.type === 'number' && typeof value === 'number') {
+    if (Number.isFinite(def.min) && value < def.min) {
+      return { valid: false, reason: `Number must be >= ${def.min}` };
+    }
+    if (Number.isFinite(def.max) && value > def.max) {
+      return { valid: false, reason: `Number must be <= ${def.max}` };
+    }
+  }
+
   if (def.type === 'map') {
     if (typeof value !== 'object' || Array.isArray(value)) {
       return { valid: false, reason: `${key} must be an object (map)` };

package/scripts/session-analytics.js

@@ -23,6 +23,88 @@ let _stateDb = null;
 let _stmtIsProcessed = null;
 let _stmtMarkProcessed = null;
 
+function normalizeTsMs(ts) {
+  if (!ts) return 0;
+  const n = new Date(ts).getTime();
+  return Number.isFinite(n) ? n : 0;
+}
+
+function extractUserText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    for (const item of content) {
+      if (item && item.type === 'text' && item.text) return item.text;
+    }
+  }
+  return '';
+}
+
+function extractToolResultText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content.map(c => {
+    if (typeof c === 'string') return c;
+    if (c && typeof c.text === 'string') return c.text;
+    return '';
+  }).join(' ');
+}
+
+function tokenizeForRepetition(text) {
+  const input = String(text || '').toLowerCase();
+  if (!input) return new Set();
+
+  const out = new Set();
+  const ascii = input.match(/[a-z0-9_./-]{2,}/g) || [];
+  for (const t of ascii) out.add(t);
+
+  const hanRuns = input.match(/[\u4e00-\u9fff]{2,}/g) || [];
+  for (const run of hanRuns) {
+    if (run.length === 2) out.add(run);
+    else {
+      for (let i = 0; i < run.length - 1; i++) out.add(run.slice(i, i + 2));
+    }
+  }
+  return out;
+}
+
+function overlapRate3(a, b, c) {
+  if (!a.size || !b.size || !c.size) return 0;
+  const union = new Set([...a, ...b, ...c]);
+  if (!union.size) return 0;
+  let common = 0;
+  for (const t of a) {
+    if (b.has(t) && c.has(t)) common++;
+  }
+  return common / union.size;
+}
+
+function parseGitDiffLines(text) {
+  const src = String(text || '');
+  if (!src) return 0;
+
+  let best = 0;
+  // Matches: "2 files changed, 40 insertions(+), 20 deletions(-)"
+  const shortstat = src.match(/(\d+)\s+insertions?\(\+\)(?:,\s*(\d+)\s+deletions?\(-\))?/i);
+  if (shortstat) {
+    const ins = Number(shortstat[1]) || 0;
+    const del = Number(shortstat[2]) || 0;
+    best = Math.max(best, ins + del);
+  }
+
+  // Matches numstat lines: "12\t3\tsrc/file.js"
+  const rows = src.split('\n');
+  let numstatTotal = 0;
+  for (const row of rows) {
+    const m = row.match(/^\s*(\d+|-)\s+(\d+|-)\s+.+$/);
+    if (!m) continue;
+    const ins = m[1] === '-' ? 0 : (Number(m[1]) || 0);
+    const del = m[2] === '-' ? 0 : (Number(m[2]) || 0);
+    numstatTotal += ins + del;
+  }
+  best = Math.max(best, numstatTotal);
+  return best;
+}
+
 /**
  * Initialize analytics state DB.
  */
@@ -180,16 +262,88 @@ function extractSkeleton(jsonlPath) {
     branch: null,
     file_dirs: new Set(),
     intent: null,
+    inter_message_gaps: [],
+    tool_error_count: 0,
+    retry_sequences: 0,
+    longest_pause_sec: 0,
+    avg_pause_sec: 0,
+    semantic_repetition: 0,
+    file_churn: 0,
+    git_diff_lines: 0,
+    error_recovered: false,
+  };
+
+  const userTsMs = [];
+  const userTexts = [];
+  const toolUseById = new Map();
+  let lastToolName = null;
+  let seenToolError = false;
+  let seenToolSuccessAfterError = false;
+  const fileStates = new Map(); // 0/undefined: clean, 1: modified, 2: rolled back after modify
+
+  const markFileModified = (filePath) => {
+    if (!filePath || typeof filePath !== 'string') return;
+    const prev = fileStates.get(filePath) || 0;
+    if (prev === 2) skeleton.file_churn++;
+    fileStates.set(filePath, 1);
+  };
+
+  const markFileRolledBack = (filePath) => {
+    if (!filePath || typeof filePath !== 'string') return;
+    const prev = fileStates.get(filePath) || 0;
+    if (prev === 1) fileStates.set(filePath, 2);
+  };
+
+  const markAllRolledBack = () => {
+    for (const [k, v] of fileStates.entries()) {
+      if (v === 1) fileStates.set(k, 2);
+    }
+  };
+
+  const parseRollbackTargets = (cmd) => {
+    const out = [];
+    const text = String(cmd || '').trim();
+    if (!text) return out;
+
+    const checkout = text.match(/\bgit\s+checkout\s+--\s+(.+)$/i);
+    if (checkout && checkout[1]) {
+      for (const t of checkout[1].trim().split(/\s+/)) out.push(t.replace(/^['"]|['"]$/g, ''));
+    }
+    const restore = text.match(/\bgit\s+restore\b(?:\s+--\S+)*\s+(.+)$/i);
+    if (restore && restore[1]) {
+      for (const t of restore[1].trim().split(/\s+/)) out.push(t.replace(/^['"]|['"]$/g, ''));
+    }
+    return out.filter(Boolean);
+  };
+
+  const registerToolResult = (result, toolUseId = '') => {
+    if (!result || typeof result !== 'object') return;
+    const isErr = !!result.is_error;
+    if (isErr) {
+      skeleton.tool_error_count++;
+      seenToolError = true;
+    } else if (seenToolError) {
+      seenToolSuccessAfterError = true;
+    }
+
+    const text = extractToolResultText(result.content);
+    const toolMeta = toolUseById.get(String(toolUseId || ''));
+    const fromDiffCmd = !!(toolMeta && /\bgit\s+diff\b/i.test(String(toolMeta.command || '')));
+    if (fromDiffCmd || /\bfiles?\s+changed\b/i.test(text) || /^\s*(\d+|-)\s+(\d+|-)\s+.+$/m.test(text)) {
+      skeleton.git_diff_lines = Math.max(skeleton.git_diff_lines, parseGitDiffLines(text));
+    }
   };
 
   for (const line of lines) {
     if (!line.trim()) continue;
 
-    // Fast pre-filter: only parse lines that look like user or assistant messages
+    // Fast pre-filter: parse user/assistant/tool_result entries only
     if (!line.includes('"type":"user"') &&
         !line.includes('"type":"assistant"') &&
+        !line.includes('"type":"tool_result"') &&
         !line.includes('"type": "user"') &&
-        !line.includes('"type": "assistant"')) {
+        !line.includes('"type": "assistant"') &&
+        !line.includes('"type": "tool_result"')) {
       continue;
     }
 
@@ -222,18 +376,22 @@ function extractSkeleton(jsonlPath) {
 
       const content = msg.content;
       // Handle both string and array content
-      let userText = '';
-      if (typeof content === 'string') {
-        userText = content;
-        skeleton.user_snippets.push(content.slice(0, 100));
+      const userText = extractUserText(content);
+      if (userText) {
+        skeleton.user_snippets.push(userText.slice(0, 100));
         skeleton.message_count++;
-      } else if (Array.isArray(content)) {
+      }
+      if (userText) userTexts.push(userText);
+      if (ts) {
+        const ms = normalizeTsMs(ts);
+        if (ms > 0) userTsMs.push(ms);
+      }
+
+      // Some transcripts embed tool_result inside user blocks.
+      if (Array.isArray(content)) {
         for (const item of content) {
-          if (item.type === 'text' && item.text) {
-            userText = item.text;
-            skeleton.user_snippets.push(item.text.slice(0, 100));
-            skeleton.message_count++;
-            break; // One snippet per user message
+          if (item && item.type === 'tool_result') {
+            registerToolResult(item, item.tool_use_id || '');
           }
         }
       }
@@ -257,6 +415,14 @@ function extractSkeleton(jsonlPath) {
             const name = item.name || 'unknown';
             skeleton.tool_counts[name] = (skeleton.tool_counts[name] || 0) + 1;
             skeleton.total_tool_calls++;
+            if (name === lastToolName) skeleton.retry_sequences++;
+            lastToolName = name;
+            if (item.id) {
+              toolUseById.set(String(item.id), {
+                name,
+                command: item.input && typeof item.input.command === 'string' ? item.input.command : '',
+              });
+            }
 
             // Extract file directories from Read/Edit/Write operations
             if ((name === 'Read' || name === 'Edit' || name === 'Write') &&
@@ -265,6 +431,12 @@ function extractSkeleton(jsonlPath) {
               const segments = dirPath.split(path.sep).filter(Boolean);
               const shortDir = segments.slice(-2).join('/');
               if (shortDir) skeleton.file_dirs.add(shortDir);
+              if (name === 'Edit' || name === 'Write') {
+                markFileModified(item.input.file_path);
+              }
+            }
+            if (name === 'MultiEdit' && item.input && typeof item.input.file_path === 'string') {
+              markFileModified(item.input.file_path);
             }
 
             // Detect git commits from Bash tool calls
@@ -273,10 +445,22 @@ function extractSkeleton(jsonlPath) {
               if (cmd.includes('git commit') || cmd.includes('git push')) {
                 skeleton.git_committed = true;
               }
+              if (/\bgit\s+reset\s+--hard\b/i.test(cmd) || /\bgit\s+checkout\s+--\s*\./i.test(cmd)) {
+                markAllRolledBack();
+              } else {
+                const targets = parseRollbackTargets(cmd);
+                for (const t of targets) {
+                  if (t === '.' || t === '*') markAllRolledBack();
+                  else markFileRolledBack(t);
+                }
+              }
             }
           }
         }
       }
+    } else if (type === 'tool_result') {
+      const result = entry.message || {};
+      registerToolResult(result, result.tool_use_id || '');
     }
   }
 
@@ -291,6 +475,30 @@ function extractSkeleton(jsonlPath) {
   skeleton.models = [...skeleton.models];
   skeleton.file_dirs = [...skeleton.file_dirs].slice(0, 5);
 
+  // Inter-message gaps (sec), filter long breaks (>2h)
+  for (let i = 1; i < userTsMs.length; i++) {
+    const sec = Math.round((userTsMs[i] - userTsMs[i - 1]) / 1000);
+    if (sec > 0 && sec <= 2 * 60 * 60) skeleton.inter_message_gaps.push(sec);
+  }
+  if (skeleton.inter_message_gaps.length > 0) {
+    const sum = skeleton.inter_message_gaps.reduce((a, b) => a + b, 0);
+    skeleton.longest_pause_sec = Math.max(...skeleton.inter_message_gaps);
+    skeleton.avg_pause_sec = Math.round(sum / skeleton.inter_message_gaps.length);
+  }
+
+  // Semantic repetition: max overlap across sliding windows of 3 user messages.
+  if (userTexts.length >= 3) {
+    let maxOverlap = 0;
+    for (let i = 2; i < userTexts.length; i++) {
+      const a = tokenizeForRepetition(userTexts[i - 2]);
+      const b = tokenizeForRepetition(userTexts[i - 1]);
+      const c = tokenizeForRepetition(userTexts[i]);
+      maxOverlap = Math.max(maxOverlap, overlapRate3(a, b, c));
+    }
+    skeleton.semantic_repetition = Number(maxOverlap.toFixed(3));
+  }
+  skeleton.error_recovered = !!(seenToolError && seenToolSuccessAfterError);
+
   // Cap user snippets at 10
   if (skeleton.user_snippets.length > 10) {
     skeleton.user_snippets = skeleton.user_snippets.slice(0, 10);
@@ -663,6 +871,30 @@ function summarizeSession(skeleton, jsonlPath) {
   };
 }
 
+/**
+ * Decide whether a session should trigger postmortem generation.
+ * Purely numeric heuristics — no semantic inference.
+ */
+function detectSignificantSession(skeleton) {
+  if (!skeleton || typeof skeleton !== 'object') {
+    return { significant: false, reasons: [] };
+  }
+  const reasons = [];
+  const diffLines = Number(skeleton.git_diff_lines || 0);
+  const toolErrors = Number(skeleton.tool_error_count || 0);
+  const retries = Number(skeleton.retry_sequences || 0);
+  const durationMin = Number(skeleton.duration_min || 0);
+  const recovered = !!skeleton.error_recovered;
+
+  if (diffLines > 50 && toolErrors > 0 && recovered) {
+    reasons.push('large_change_with_error_recovery');
+  }
+  if (durationMin > 60 && retries > 5) {
+    reasons.push('long_debug_retry_loop');
+  }
+  return { significant: reasons.length > 0, reasons };
+}
+
 module.exports = {
   findLatestUnanalyzedSession,
   findSessionById,
@@ -673,6 +905,7 @@ module.exports = {
   formatForPrompt,
   formatGoalContext,
   summarizeSession,
+  detectSignificantSession,
   markAnalyzed,
   markFactsExtracted,
 };