#!/usr/bin/env node
/**
 * 融合权重自适应学习器 (v5.9)
 *
 * 对路由融合权重 (BM25, Semantic, Context, Project, Workflow) 进行在线学习。
 * 基于反馈纠正数据，用 projected gradient descent 调整权重使路由更准确。
 *
 * 约束:
 *   - 权重之和 = 1.0 (概率单纯形)
 *   - 每个权重 ∈ [0.05, 0.6] (防止退化)
 *   - 学习率 η = 0.02 (保守更新)
 *
 * 用法:
 *   node fusion-weight-learner.js              # 学习并输出权重
 *   node fusion-weight-learner.js --dry-run    # 仅预览
 *   node fusion-weight-learner.js --reset      # 重置为默认权重
 *   node fusion-weight-learner.js --json       # JSON 输出
 *
 * 文件:
 *   debug/fusion-weights.json   学习后的融合权重
 */

const fs = require('fs');
const path = require('path');

// MEDIUM-1: 引入 WeightStore，使用 safeWriteJson 进行并发安全写入
// 若加载失败则回退到直接写入 (不阻断功能)
let _weightStore = null;
try {
  const _ws = require('./weight-store.js');
  if (typeof _ws.safeWriteJson === 'function') {
    _weightStore = _ws;
  }
} catch {}

const detectClaudeRoot = () => require('./paths.config.js').PATHS.root;

const ROOT = detectClaudeRoot();
const DEBUG_DIR = path.join(ROOT, 'debug');
const FEEDBACK_FILE = path.join(DEBUG_DIR, 'route-feedback.jsonl');
const FUSION_WEIGHTS_FILE = path.join(DEBUG_DIR, 'fusion-weights.json');
const INDEX_FILE = path.join(ROOT, 'skills-index.json');

// 默认融合权重 (与 route-interceptor.js 一致)
const DEFAULT_WEIGHTS = {
  bm25: 0.40,
  semantic: 0.30,
  context: 0.15,
  project: 0.10,
  workflow: 0.05,
};

// 约束
const MIN_WEIGHT = 0.05;
const MAX_WEIGHT = 0.60;
const LEARNING_RATE = 0.02;
// W1 修复 (patch-w1-weight-decay, 2026-04-16): L2 正则化强度
// 每批次将权重按比例拉回 DEFAULT_WEIGHTS，防止 simulateSignals 三维=0 导致的单向漂移
const WEIGHT_DECAY = 0.02;
const DECAY_HALF_LIFE = 7 * 86400000; // 7 天半衰期

// v5.9: 多项目隔离支持
let _isolator = null;
try { _isolator = require('./project-isolator.js'); } catch {}
function getWeightsFile(cwd) {
  if (_isolator && cwd) return _isolator.getIsolatedPath('fusion-weights.json', cwd);
  return FUSION_WEIGHTS_FILE;
}

/**
 * 安全写入 fusion-weights.json
 * BUG-FIX: 原来委托给 weight-store.safeWriteJson（async Promise），
 * 但没有 await，导致进程退出时写入从未完成，权重永远停在 bootstrap 值。
 * fusion-weights.json 只有一个写入者（本文件），无并发写入，不需要锁。
 * 直接使用同步 fs.writeFileSync 保证写入在进程退出前完成。
 * @param {string} weightsFile - 目标文件路径
 * @param {Object} data - 要写入的数据
 */
function safeWriteFusionWeights(weightsFile, data) {
  _directWriteFallback(weightsFile, data);
}

/** 直接写入回退（weight-store 不可用时） */
function _directWriteFallback(weightsFile, data) {
  try {
    if (!fs.existsSync(path.dirname(weightsFile))) {
      fs.mkdirSync(path.dirname(weightsFile), { recursive: true });
    }
    fs.writeFileSync(weightsFile, JSON.stringify(data, null, 2) + '\n');
  } catch {}
}

/**
 * C1 原子重置助手 (patch-c1-atomic-reset, 2026-04-16)
 * 用 tmp+rename 覆盖为 DEFAULT_WEIGHTS，避免 unlinkSync 与并发 readFileSync 的 TOCTOU 竞态。
 * 读者永远看到合法 JSON (旧值或新的 DEFAULT)，不会 ENOENT。
 */
function atomicResetWeightsFile(weightsFile, reason) {
  try {
    if (!fs.existsSync(path.dirname(weightsFile))) {
      fs.mkdirSync(path.dirname(weightsFile), { recursive: true });
    }
    const payload = {
      weights: { ...DEFAULT_WEIGHTS },
      resetAt: new Date().toISOString(),
      resetReason: reason || 'manual',
    };
    const _tmp = weightsFile + '.tmp.' + process.pid;
    fs.writeFileSync(_tmp, JSON.stringify(payload, null, 2) + '\n');
    fs.renameSync(_tmp, weightsFile);
  } catch {}
}

/**
 * 加载当前融合权重
 * @param {string} [cwd] - 工作目录 (v5.9 per-cwd 隔离)
 * @returns {Object} { bm25, semantic, context, project, workflow }
 */
function loadWeights(cwd) {
  try {
    const file = getWeightsFile(cwd);
    if (fs.existsSync(file)) {
      const data = JSON.parse(fs.readFileSync(file, 'utf8'));
      if (data.weights) return { ...DEFAULT_WEIGHTS, ...data.weights };
    }
  } catch {}
  return { ...DEFAULT_WEIGHTS };
}

/**
 * 投影到概率单纯形 (权重之和=1, 每个 ∈ [MIN, MAX])
 * V01 修复: 迭代 clamp+归一化，确保投影后所有约束同时满足
 */
/**
 * 标准约束单纯形投影 (Duchi et al. 2008 变体)
 * 保证: sum(w) = 1.0 且 w[k] ∈ [MIN_WEIGHT, MAX_WEIGHT]
 * 算法: 排序 → 阈值查找 → 投影 → box clamp → 精确余数分配
 */
function projectToSimplex(w) {
  const keys = Object.keys(w).sort(); // 确定性排序
  const n = keys.length;

  // Step 1: 不带 box 约束的单纯形投影 (Duchi 2008)
  const vals = keys.map(k => w[k]);
  vals.sort((a, b) => b - a); // 降序
  let cumSum = 0;
  let rho = 0;
  for (let j = 0; j < n; j++) {
    cumSum += vals[j];
    if (vals[j] - (cumSum - 1) / (j + 1) > 0) rho = j + 1;
  }
  const theta = (keys.reduce((s, k) => s + w[k], 0) - 1) / rho;
  for (const k of keys) {
    w[k] = Math.max(0, w[k] - theta);
  }

  // Step 2: Box 约束 clamp [MIN_WEIGHT, MAX_WEIGHT]
  for (const k of keys) {
    w[k] = Math.max(MIN_WEIGHT, Math.min(MAX_WEIGHT, w[k]));
  }

  // Step 3: 精确余数分配到离边界最远的维度
  for (const k of keys) {
    w[k] = Math.round(w[k] * 1000) / 1000;
  }
  let residual = 1.0 - keys.reduce((s, k) => s + w[k], 0);
  residual = Math.round(residual * 1000) / 1000;
  if (Math.abs(residual) > 0) {
    // 找离边界最远的维度来吸收残差
    let bestKey = keys[0];
    let bestRoom = 0;
    for (const k of keys) {
      const room = residual > 0
        ? MAX_WEIGHT - w[k]  // 需要增加，找上界余量最大的
        : w[k] - MIN_WEIGHT; // 需要减少，找下界余量最大的
      if (room > bestRoom) { bestRoom = room; bestKey = k; }
    }
    w[bestKey] = Math.round((w[bestKey] + residual) * 1000) / 1000;
    w[bestKey] = Math.max(MIN_WEIGHT, Math.min(MAX_WEIGHT, w[bestKey]));
  }
  return w;
}

/**
 * 加载反馈数据中的纠正条目
 */
function loadCorrections() {
  if (!fs.existsSync(FEEDBACK_FILE)) return [];
  return fs.readFileSync(FEEDBACK_FILE, 'utf8')
    .split('\n').filter(Boolean)
    .map(l => { try { return JSON.parse(l); } catch { return null; } })
    .filter(f => f && f.routedTo && f.correctedTo && f.routedTo !== f.correctedTo && f.routedTo !== 'unknown');
}

/**
 * 为每条纠正模拟各信号分数
 * 因为历史纠正没有保存各信号分数，使用当前引擎重新计算
 */
function simulateSignals(query, skillName, index, analyzer, semanticScorer) {
  const signals = { bm25: 0, semantic: 0, context: 0, project: 0, workflow: 0 };

  // BM25 分数
  try {
    const bm25Params = analyzer.buildBM25Params ? analyzer.buildBM25Params(index) : null;
    const queryTokens = analyzer.tokenize(query);
    const skill = index.skills.find(s => s.name === skillName);
    if (skill && bm25Params) {
      const { totalScore } = analyzer.scoreSkill(skill, queryTokens, bm25Params);
      signals.bm25 = totalScore;
    }
  } catch {}

  // 语义分数
  try {
    if (semanticScorer) {
      const results = semanticScorer.semanticScore(query, index);
      const match = results.find(r => r.name === skillName);
      if (match) signals.semantic = match.score;
    }
  } catch {}

  // context/project/workflow 无法回溯，保持 0
  return signals;
}

/**
 * 在线梯度下降学习融合权重
 * 思路: 对每条纠正，计算正确技能和错误技能的信号向量差异，
 *       沿着提升正确技能分数的方向调整权重
 */
function learnFusionWeights(options = {}) {
  const dryRun = options.dryRun || false;
  const corrections = loadCorrections();

  if (corrections.length < 2) {
    return { status: 'skip', reason: '纠正不足2条', count: corrections.length };
  }

  // 加载依赖
  let analyzer, semanticScorer;
  try { analyzer = require('./route-analyzer.js'); } catch { return { status: 'error', reason: 'route-analyzer 不可用' }; }
  try { semanticScorer = require('./semantic-scorer.js'); } catch { semanticScorer = null; }

  let index;
  try { index = JSON.parse(fs.readFileSync(INDEX_FILE, 'utf8')); } catch { return { status: 'error', reason: 'skills-index.json 不可用' }; }

  const weights = loadWeights();
  const now = Date.now();
  let totalGradient = { bm25: 0, semantic: 0, context: 0, project: 0, workflow: 0 };
  let effectiveSamples = 0;

  for (const fb of corrections) {
    // 时间衰减
    const age = now - new Date(fb.ts).getTime();
    if (isNaN(age) || age < 0) continue;
    const decay = Math.pow(0.5, age / DECAY_HALF_LIFE);

    // 类型权重
    const typeFactor = fb.type === 'observed' ? 0.8 : (fb.type === 'implicit' ? 0.5 : 1.0);
    const sampleWeight = decay * typeFactor;
    if (sampleWeight < 0.01) continue;

    // 模拟正确技能和错误技能的信号
    const correctSignals = simulateSignals(fb.query, fb.correctedTo, index, analyzer, semanticScorer);
    const wrongSignals = simulateSignals(fb.query, fb.routedTo, index, analyzer, semanticScorer);

    // 梯度: 正确技能信号 - 错误技能信号 (希望提升正确技能的权重组合分数)
    for (const key of Object.keys(totalGradient)) {
      totalGradient[key] += sampleWeight * (correctSignals[key] - wrongSignals[key]);
    }
    effectiveSamples += sampleWeight;
  }

  if (effectiveSamples < 1) {
    return { status: 'skip', reason: '有效样本不足', effectiveSamples };
  }

  // 归一化梯度
  for (const key of Object.keys(totalGradient)) {
    totalGradient[key] /= effectiveSamples;
  }

  // 梯度更新 + W1 权重衰减 (L2 正则化拉回 DEFAULT_WEIGHTS)
  const newWeights = { ...weights };
  for (const key of Object.keys(newWeights)) {
    newWeights[key] += LEARNING_RATE * totalGradient[key];
    newWeights[key] += WEIGHT_DECAY * (DEFAULT_WEIGHTS[key] - newWeights[key]);
  }

  // 投影到约束空间
  const projected = projectToSimplex(newWeights);

  // 计算权重变化量
  const deltas = {};
  let totalDelta = 0;
  for (const key of Object.keys(projected)) {
    deltas[key] = Math.round((projected[key] - weights[key]) * 1000) / 1000;
    totalDelta += Math.abs(deltas[key]);
  }

  const result = {
    status: 'ok',
    corrections: corrections.length,
    effectiveSamples: Math.round(effectiveSamples * 10) / 10,
    previousWeights: weights,
    newWeights: projected,
    deltas,
    totalDelta: Math.round(totalDelta * 1000) / 1000,
    gradient: Object.fromEntries(
      Object.entries(totalGradient).map(([k, v]) => [k, Math.round(v * 1000) / 1000])
    ),
    dryRun,
  };

  if (!dryRun && totalDelta > 0.005) {
    if (!fs.existsSync(DEBUG_DIR)) fs.mkdirSync(DEBUG_DIR, { recursive: true });
    const output = {
      generated: new Date().toISOString(),
      weights: projected,
      meta: {
        corrections: corrections.length,
        effectiveSamples: result.effectiveSamples,
        gradient: result.gradient,
        previousWeights: weights,
      },
    };
    // P1-2 修复: 使用文件锁保护写入，防止与 applyImplicitWeights 竞态
    // 根因守卫 + cooldown: 连续 2 周期命中才真正 reset，避免单周期误报抖动
    const wVals = Object.values(result.newWeights || {});
    let degen = 0;
    for (let i = 0; i < wVals.length; i++) {
      for (let j = i + 1; j < wVals.length; j++) {
        if (Math.abs(wVals[i] - wVals[j]) < 0.01) degen++;
      }
    }
    const bm25Val = (result.newWeights && result.newWeights.bm25) || 1;
    const DEGEN_COOLDOWN_FILE = path.join(DEBUG_DIR, 'degen-counter.json');
    const hitDegen = degen >= 3 || bm25Val <= 0.06;
    let consecutiveHits = 0;
    try {
      if (fs.existsSync(DEGEN_COOLDOWN_FILE)) {
        const c = JSON.parse(fs.readFileSync(DEGEN_COOLDOWN_FILE, 'utf8'));
        if (typeof c.hits === 'number') consecutiveHits = c.hits;
      }
    } catch {}
    if (hitDegen) {
      consecutiveHits += 1;
      try {
        const _tmp = DEGEN_COOLDOWN_FILE + '.tmp.' + process.pid;
        fs.writeFileSync(_tmp, JSON.stringify({ hits: consecutiveHits, degen, bm25: bm25Val, ts: new Date().toISOString() }));
        fs.renameSync(_tmp, DEGEN_COOLDOWN_FILE);
      } catch {}
      if (consecutiveHits >= 2) {
        try {
          process.stderr.write('[fusion-weight] 连续 ' + consecutiveHits + ' 周期退化命中，reset 到 DEFAULT_WEIGHTS\n');
          atomicResetWeightsFile(FUSION_WEIGHTS_FILE, 'degen-consecutive-' + consecutiveHits);
          // 重置计数器
          try { fs.unlinkSync(DEGEN_COOLDOWN_FILE); } catch {}
        } catch {}
        return Object.assign({}, result, { status: 'reset-on-degeneracy', weights: Object.assign({}, DEFAULT_WEIGHTS) });
      }
      // 单周期命中: 记录但不 reset (cooldown 防抖)
      try { process.stderr.write('[fusion-weight] 退化单周期 (' + consecutiveHits + '/2)，等待下次确认\n'); } catch {}
    } else {
      // 未命中: 清零计数器 (连续性要求)
      try { if (fs.existsSync(DEGEN_COOLDOWN_FILE)) fs.unlinkSync(DEGEN_COOLDOWN_FILE); } catch {}
    }
    safeWriteFusionWeights(FUSION_WEIGHTS_FILE, output);
  }

  return result;
}

/**
 * 重置为默认权重
 */
function resetWeights() {
  atomicResetWeightsFile(FUSION_WEIGHTS_FILE, 'manual-reset');
  return { status: 'reset', weights: DEFAULT_WEIGHTS };
}

/**
 * 将 implicit-feedback.js 的输出回流到 fusion-weights.json (F3-4)
 *
 * 修复问题: implicit-feedback 只写 route-feedback.jsonl，未触发融合权重更新。
 * 本函数从 route-feedback.jsonl 读取反馈信号，将其转化为 PGD 梯度输入，
 * 调用 learnFusionWeights() 更新 fusion-weights.json。
 *
 * 反馈权重规则（来自 strategic-evolution-v6.md S1-Phase1）:
 *   confirmed       → 权重向当前方向微调 (正向梯度, weight factor 0.5)
 *   corrected       → 权重向正确技能方向调整 (weight factor 1.0)
 *   timeout-confirm → 弱信号确认 (weight factor 0.1)
 *   observed        → 直接观测，最高可信度 (weight factor 0.8)
 *
 * @param {Object} [options]
 * @param {boolean} [options.dryRun=false] - 仅预览，不写文件
 * @param {number} [options.minNewFeedback=3] - 新反馈条数不足时跳过
 * @param {string} [options.cwd] - 工作目录（per-cwd 权重隔离）
 * @returns {Object} { status, applied, skipped, reason, newWeights, totalDelta }
 */
function applyImplicitWeights(options = {}) {
  const dryRun = options.dryRun || false;
  const minNewFeedback = options.minNewFeedback || 3;
  const cwd = options.cwd || null;

  try {
    // XC6 修复: 如果 learnFusionWeights 在同一 Stop 周期内已运行，
    // 先读取最新权重（包含 learnFusionWeights 写入的结果），在此基础上叠加 implicit 梯度，
    // 而非用 applyImplicitWeights 结果覆盖 learnFusionWeights 的结果。
    // 通过 loadWeights() 获取最新状态（下方已调用），不再需要额外标记文件。

    // P2.4 watermark: 若反馈文件 size 未变化 (>=300 bytes 阈值 ~= 3 条新反馈)，跳过全量重算
    // 避免 1085+ 行反馈每次 Stop 都重放，语义不变 (仍然全量读取，只是跳过无新增的周期)
    const WATERMARK_FILE = path.join(DEBUG_DIR, 'implicit-feedback-watermark.json');
    const MIN_SIZE_DELTA = 300;
    let currentSize = 0;
    try { currentSize = fs.existsSync(FEEDBACK_FILE) ? fs.statSync(FEEDBACK_FILE).size : 0; } catch {}
    if (!options.ignoreWatermark && currentSize > 0) {
      try {
        if (fs.existsSync(WATERMARK_FILE)) {
          const wm = JSON.parse(fs.readFileSync(WATERMARK_FILE, 'utf8'));
          if (typeof wm.lastSize === 'number') {
            // RT-V3+V4 修复: 文件被 truncate → 用 overwrite 代替 unlink 消除 unlink-race
            if (currentSize < wm.lastSize) {
              try {
                const _tmp = WATERMARK_FILE + '.tmp.' + process.pid;
                fs.writeFileSync(_tmp, JSON.stringify({ lastSize: 0, ts: new Date().toISOString(), reason: 'truncate-reset' }));
                fs.renameSync(_tmp, WATERMARK_FILE);
              } catch {}
            } else if (currentSize - wm.lastSize < MIN_SIZE_DELTA) {
              return { status: 'skip', reason: 'watermark no-new-feedback', lastSize: wm.lastSize, currentSize };
            }
          }
        }
      } catch {}
    }

    // 读取 route-feedback.jsonl（含 implicit 反馈和 explicit 纠正）
    if (!fs.existsSync(FEEDBACK_FILE)) {
      return { status: 'skip', reason: 'route-feedback.jsonl 不存在', applied: 0 };
    }

    const allFeedback = fs.readFileSync(FEEDBACK_FILE, 'utf8')
      .split('\n').filter(Boolean)
      .map(l => { try { return JSON.parse(l); } catch { return null; } })
      .filter(f => f && f.ts && f.routedTo);

    // RT-V3+V4 修复: 反馈已完整读入内存 → tmp+rename 原子更新 watermark (防并发读取半字节)
    try {
      const _wmTmp = WATERMARK_FILE + '.tmp.' + process.pid;
      fs.writeFileSync(_wmTmp, JSON.stringify({ lastSize: currentSize, ts: new Date().toISOString() }));
      fs.renameSync(_wmTmp, WATERMARK_FILE);
    } catch {}

    if (allFeedback.length === 0) {
      return { status: 'skip', reason: '反馈文件为空', applied: 0 };
    }

    // 只处理 implicit 和 observed 类型的反馈（explicit 已由 learnFusionWeights 消费）
    const implicitFeedback = allFeedback.filter(f =>
      f.type === 'implicit' || f.type === 'observed'
    );

    if (implicitFeedback.length < minNewFeedback) {
      return {
        status: 'skip',
        reason: `隐式反馈条数不足 (${implicitFeedback.length} < ${minNewFeedback})`,
        applied: 0,
      };
    }

    // 加载当前权重
    const currentWeights = loadWeights(cwd);
    const now = Date.now();

    // 计算加权平均梯度
    // 策略: 对 confirmed/timeout-confirm 施加微弱正向梯度（不改变方向）
    //       对 corrected/observed-correct 施加明确的梯度（提升正确技能的信号分量）
    let totalGradient = { bm25: 0, semantic: 0, context: 0, project: 0, workflow: 0 };
    let totalWeight = 0;

    // 加载依赖（用于重新计算信号分数）
    let analyzer, semanticScorer, index;
    try { analyzer = require('./route-analyzer.js'); } catch { analyzer = null; }
    try { semanticScorer = require('./semantic-scorer.js'); } catch { semanticScorer = null; }
    try { index = JSON.parse(fs.readFileSync(INDEX_FILE, 'utf8')); } catch { index = null; }

    for (const fb of implicitFeedback) {
      // 时间衰减（7天半衰期）
      const age = now - new Date(fb.ts).getTime();
      if (isNaN(age) || age < 0) continue;
      const decay = Math.pow(0.5, age / DECAY_HALF_LIFE);

      // 类型权重
      let typeFactor;
      switch (fb.implicit) {
        case 'observed-correct':  typeFactor = 0.8; break;
        case 'correct':           typeFactor = 1.0; break;
        case 'confirm':           typeFactor = 0.5; break;
        case 'observed-confirm':  typeFactor = 0.5; break;
        case 'timeout-confirm':   typeFactor = fb.weight || 0.1; break;
        default:
          // 根据 type 判断
          typeFactor = (fb.routedTo !== fb.correctedTo) ? 1.0 : 0.5;
      }

      const sampleWeight = decay * typeFactor;
      if (sampleWeight < 0.005) continue;

      // 只有纠正类型才需要计算信号差（确认类型梯度为 0，不改变权重方向）
      const isCorrected = fb.routedTo !== fb.correctedTo;

      if (isCorrected && analyzer && index) {
        // 模拟正确技能和错误技能的信号分数
        const correctSignals = simulateSignals(
          fb.query || '', fb.correctedTo, index, analyzer, semanticScorer
        );
        const wrongSignals = simulateSignals(
          fb.query || '', fb.routedTo, index, analyzer, semanticScorer
        );

        for (const key of Object.keys(totalGradient)) {
          totalGradient[key] += sampleWeight * (correctSignals[key] - wrongSignals[key]);
        }
      }
      // P1-1 修复: confirmed 类型不计入 totalWeight，防止梯度稀释导致学习停滞
      if (isCorrected) {
        totalWeight += sampleWeight;
      }
    }

    if (totalWeight < 0.1) {
      return { status: 'skip', reason: '有效样本权重不足', applied: 0 };
    }

    // 归一化梯度
    for (const key of Object.keys(totalGradient)) {
      totalGradient[key] /= totalWeight;
    }

    // 应用梯度更新（保守学习率，使用 LEARNING_RATE 的一半避免与 learnFusionWeights 叠加）
    // W1: 同步使用 WEIGHT_DECAY 的一半，与 implicitLR 成比例
    const implicitLR = LEARNING_RATE * 0.5;
    const implicitDecay = WEIGHT_DECAY * 0.5;
    const newWeights = { ...currentWeights };
    for (const key of Object.keys(newWeights)) {
      newWeights[key] += implicitLR * (totalGradient[key] || 0);
      newWeights[key] += implicitDecay * (DEFAULT_WEIGHTS[key] - newWeights[key]);
    }

    // 投影到概率单纯形
    const projected = projectToSimplex(newWeights);

    // 计算变化量
    const deltas = {};
    let totalDelta = 0;
    for (const key of Object.keys(projected)) {
      deltas[key] = Math.round((projected[key] - currentWeights[key]) * 1000) / 1000;
      totalDelta += Math.abs(deltas[key]);
    }
    totalDelta = Math.round(totalDelta * 1000) / 1000;

    // 变化量过小则跳过（避免频繁写文件）
    if (totalDelta < 0.003) {
      return {
        status: 'skip',
        reason: `梯度变化量过小 (${totalDelta})，跳过写入`,
        applied: implicitFeedback.length,
        totalDelta,
      };
    }

    // 写入 fusion-weights.json（非 dry-run 时）
    if (!dryRun) {
      const weightsFile = getWeightsFile(cwd);
      if (!fs.existsSync(DEBUG_DIR)) fs.mkdirSync(DEBUG_DIR, { recursive: true });
      const output = {
        generated: new Date().toISOString(),
        weights: projected,
        meta: {
          source: 'applyImplicitWeights',
          implicitFeedbackCount: implicitFeedback.length,
          effectiveWeight: Math.round(totalWeight * 10) / 10,
          gradient: Object.fromEntries(
            Object.entries(totalGradient).map(([k, v]) => [k, Math.round(v * 1000) / 1000])
          ),
          previousWeights: currentWeights,
        },
      };
      // P1-2 修复: 使用文件锁保护写入，防止与 learnFusionWeights 竞态
      safeWriteFusionWeights(weightsFile, output);
    }

    return {
      status: 'ok',
      applied: implicitFeedback.length,
      effectiveWeight: Math.round(totalWeight * 10) / 10,
      previousWeights: currentWeights,
      newWeights: projected,
      deltas,
      totalDelta,
      gradient: Object.fromEntries(
        Object.entries(totalGradient).map(([k, v]) => [k, Math.round(v * 1000) / 1000])
      ),
      dryRun,
    };
  } catch (err) {
    // fail-open: 任何异常不影响主流程
    return { status: 'error', reason: err.message, applied: 0 };
  }
}

/**
 * 初始化引导: 若 fusion-weights.json 不存在，写入默认权重
 * 确保 route-interceptor-bundle 首次运行时有权重可读
 */
function bootstrapWeights(cwd) {
  const file = cwd ? getWeightsFile(cwd) : FUSION_WEIGHTS_FILE;
  if (fs.existsSync(file)) return { status: 'exists' };
  if (!fs.existsSync(DEBUG_DIR)) fs.mkdirSync(DEBUG_DIR, { recursive: true });
  const output = {
    generated: new Date().toISOString(),
    weights: { ...DEFAULT_WEIGHTS },
    meta: { source: 'bootstrap', corrections: 0 },
  };
  safeWriteFusionWeights(file, output);
  return { status: 'bootstrapped', weights: DEFAULT_WEIGHTS };
}

/**
 * H2 修复: 原子化 bootstrap + learn + apply 权重更新
 * 用 sentinel 文件检测"半写入"状态 (Stop hook 被 timeout kill)
 *
 * - 检测到 30s 内的 sentinel → 跳过 (并发写入保护)
 * - 检测到 >30s 的 stale sentinel → 清除后正常跑 (上次 kill 残留)
 * - 正常流程: 串联 bootstrap → learn → apply，过程中维护 sentinel
 */
function atomicWeightUpdate(options = {}) {
  const sentinel = FUSION_WEIGHTS_FILE + '.writing';
  const now = Date.now();

  if (fs.existsSync(sentinel)) {
    try {
      const age = now - fs.statSync(sentinel).mtimeMs;
      if (age > 30000) {
        // Stale sentinel (上次写入被 kill) → 清除
        try {
          process.stderr.write('[fusion-weight] stale sentinel 清除 (age=' + Math.round(age/1000) + 's)\n');
        } catch {}
        try { fs.unlinkSync(sentinel); } catch {}
      } else {
        return { status: 'skip', reason: 'concurrent-write', age };
      }
    } catch {}
  }

  try {
    if (!fs.existsSync(DEBUG_DIR)) fs.mkdirSync(DEBUG_DIR, { recursive: true });
    fs.writeFileSync(sentinel, String(process.pid) + '@' + now);

    const bootResult = bootstrapWeights();
    const learnResult = learnFusionWeights(options);
    const applyResult = applyImplicitWeights(options);

    return {
      status: 'ok',
      bootstrap: bootResult && bootResult.status,
      learn: learnResult && learnResult.status,
      apply: applyResult && applyResult.status,
    };
  } catch (err) {
    return { status: 'error', reason: err.message };
  } finally {
    try { if (fs.existsSync(sentinel)) fs.unlinkSync(sentinel); } catch {}
  }
}

// 模块导出
if (typeof module !== 'undefined') {
  module.exports = {
    loadWeights, projectToSimplex, learnFusionWeights,
    resetWeights, applyImplicitWeights, bootstrapWeights, atomicWeightUpdate,
    DEFAULT_WEIGHTS, FUSION_WEIGHTS_FILE,
  };
}

// CLI 入口
if (require.main === module) {
  const args = process.argv.slice(2);
  const jsonMode = args.includes('--json');
  const dryRun = args.includes('--dry-run');

  if (args.includes('--reset')) {
    const r = resetWeights();
    console.log(jsonMode ? JSON.stringify(r, null, 2) : '融合权重已重置为默认值');
    process.exit(0);
  }

  const result = learnFusionWeights({ dryRun });

  if (jsonMode) {
    console.log(JSON.stringify(result, null, 2));
  } else {
    console.log('=== 融合权重自适应学习 ===');
    if (result.status === 'skip') {
      console.log(`跳过: ${result.reason}`);
    } else if (result.status === 'error') {
      console.log(`错误: ${result.reason}`);
    } else {
      console.log(`纠正样本: ${result.corrections}, 有效样本: ${result.effectiveSamples}`);
      console.log(`梯度: ${JSON.stringify(result.gradient)}`);
      console.log(`\n权重变化:`);
      for (const [k, v] of Object.entries(result.deltas)) {
        const arrow = v > 0 ? '↑' : v < 0 ? '↓' : '=';
        console.log(`  ${k.padEnd(10)} ${result.previousWeights[k]} → ${result.newWeights[k]} (${arrow}${Math.abs(v)})`);
      }
      console.log(`\n总变化量: ${result.totalDelta}${result.dryRun ? ' (dry-run)' : ''}`);
    }
  }
}