dsh-subagent-profile 0.4.0 → 0.5.1

package/lib/core/evolution-engine.mjs

@@ -10,14 +10,22 @@
 // 持久化 → 资产 draft→proposed；通过/拒绝两分支都写 suggestion-apply 审计。
 // 串行化：进程级按身份键单写锁（同键排队，跨键并行）；候选池恒 system-trust
 // 白名单（不叠加逃生舱放行集）；apply 只改新方案默认值，per-call 优先级不变。
+// 金丝雀：apply 冻结基线（聚合 + 逐条分）与完整配置快照；观察期 K 次相关派发后
+// 判定（跌破基线下沿 → 回滚建议只读挂面板，绝不自动回滚）；回滚需 human_confirmed，
+// 恢复快照 + suggestion-rollback 审计。滞后/回滚冷却在 evolution-lag.mjs，判定与
+// 回滚本体在 evolution-canary.mjs，cold-start 状态经 evolutionStatus 暴露。
 
-import { join } from 'node:path';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
 import { sanitizeProfile } from './pure.mjs';
+import { parseDispatchRecords } from './evolution-summary.mjs';
 import { assertCostGuard } from './cost-guard.mjs';
-import { profileFingerprint, sourceConfigFromKey } from './evolution-draft.mjs';
+import { matchingRegistryProfiles, profileFingerprint, sourceConfigFromKey } from './evolution-draft.mjs';
 import { createEvolutionAssets } from './evolution-assets.mjs';
-import { computeAdvice, readSummaries, recentDispatchDetails } from './evolution-advice.mjs';
-import { generateCandidates, regenerateCandidates, matchingRegistryProfiles } from './evolution-generate.mjs';
+import { computeAdvice, readSummaries, recentDispatchDetails, writeBackCooldowns, writeBackStreaks } from './evolution-advice.mjs';
+import { generateCandidates, regenerateCandidates } from './evolution-generate.mjs';
+import { CANARY_K, captureBaseline, captureFromSnapshot, evaluateCanary, executeRollback, evolutionStatusOf, holdoutBacktest, skippedGates } from './evolution-canary.mjs';
+import { LAG_N, bumpStreak, createLagStreaks, directionOf, rollbackCooldownBlocks } from './evolution-lag.mjs';
 
 // --- 三道闸（apply 口径，对齐派发守卫同源逻辑）-------------------------------
 
@@ -85,11 +93,7 @@ async function assessApplyGates(deps, config) {
 }
 
 // --- 审计（suggestion-apply）--------------------------------------------------
-
-function skippedGates(reason) {
-  const skipped = { verdict: 'skipped', reason };
-  return { whitelist: skipped, cost: skipped, intersection: skipped, approval: 'never' };
-}
+// skippedGates 与金丝雀域同源（evolution-canary.mjs），apply/回滚审计闸位口径一致。
 
 // suggestion-apply 事件：from/to/axis/direction/gates/human_confirmed/
 // baseline_snapshot 字段级齐备；拒绝分支附 reason。
@@ -122,8 +126,22 @@ function currentFingerprint(deps, asset) {
   return { ok: true, value: profileFingerprint({ profileKey: asset.profile_key, from, registryEntries: registry }) };
 }
 
-// 单次应用（在身份键锁内执行）：确认 → 观察期隔离 → 指纹校验 → 三道闸 →
-// 落写 + 持久化 → 资产转 proposed；每个拒绝/通过分支都写审计。
+// 应用数据充分性（冷启动门）：该身份键聚合样本不足 3 → 拒绝应用（数据地基
+// 缺失时应用/防退化不可用，状态经 evolutionStatus 暴露）。
+function applyDataReadiness(deps, asset) {
+  const summaries = deps.getSummaries();
+  if (summaries === null) return { ok: false, reason: '聚合数据缺失，暂不支持应用（需积累派发数据）' };
+  const l1 = summaries.l1 !== null && typeof summaries.l1 === 'object' ? summaries.l1 : {};
+  const group = l1[asset.profile_key];
+  if (group === null || typeof group !== 'object') return { ok: false, reason: '聚合组缺失，暂不支持应用' };
+  const n = Number.isFinite(group.confidence?.n) ? group.confidence.n : (Number.isFinite(group.deployments_total) ? group.deployments_total : 0);
+  if (n < 3) return { ok: false, reason: `派发数据不足（当前 ${n} 次，需 ≥3），暂不支持应用` };
+  return { ok: true };
+}
+
+// 单次应用（在身份键锁内执行）：确认 → 观察期隔离 → 指纹校验 → 数据充分性 →
+// 三道闸 → 基线/快照冻结 → 落写 + 持久化 → 资产转 proposed（挂金丝雀初值）；
+// 每个拒绝/通过分支都写审计。
 async function applyOnce(deps, asset, humanConfirmed) {
   const audit = (entry) => deps.evoLedger.recordGovernanceAudit(entry);
   const reject = (reason, extra = {}) => {
@@ -150,6 +168,8 @@ async function applyOnce(deps, asset, humanConfirmed) {
   if (fingerprint.value !== asset.profile_fingerprint) {
     return expireAndReject('候选指纹失配：方案已被编辑或聚合数据已变化，需重新生成');
   }
+  const data = applyDataReadiness(deps, asset);
+  if (!data.ok) return reject(data.reason);
   if (deps.store.profiles.has(asset.config?.id)) {
     return reject('候选 profile id 已存在（请先删除或改名）');
   }
@@ -163,13 +183,57 @@ async function applyOnce(deps, asset, humanConfirmed) {
     const detail = warnings.map((w) => `${w.field}：${w.reason}`).join('；');
     return reject(`写入被拒绝：${detail}`, { gates: gates.gates });
   }
+  return applyWrite(deps, asset, clean, gates, audit);
+}
+
+// 落写 + 基线/快照冻结 + 资产转 proposed（挂金丝雀初值）+ 通过审计。基线/快照
+// 在写前冻结：fromSnapshot = 完整配置快照（回滚恢复依据）、baseline = apply 时刻
+// 聚合 + 逐条分（金丝雀下沿构造依据），时间隔离防自补偿。
+async function applyWrite(deps, asset, clean, gates, audit) {
+  const now = Date.now();
+  const fromSnapshot = captureFromSnapshot(deps.store, asset.profile_key, now);
+  const baseline = captureBaseline({
+    summaries: deps.getSummaries(),
+    records: deps.getDispatchRecords?.() ?? [],
+    profileKey: asset.profile_key,
+    now,
+  });
   deps.store.profiles.set(clean.id, { ...clean, persisted: true });
   const persisted = deps.store.persistProfiles();
-  deps.assets.transition(asset.id, 'proposed', { applied_at: Date.now() });
+  deps.assets.transition(asset.id, 'proposed', {
+    applied_at: now,
+    fromSnapshot,
+    baseline_metrics: { sampleN: baseline.sampleN ?? null, weighted_success: baseline.weighted_success ?? null },
+    applied_config: { ...clean },
+    canary: { k: 0, kTotal: CANARY_K, appliedAt: now, baseline, samples: [], verdict: null, stalled: false, insufficient: false },
+  });
   audit(applyAuditEntry(asset, { profileId: clean.id, gates: gates.gates, humanConfirmed: true }));
   return { ok: true, id: clean.id, persisted: persisted?.persisted === true, state: 'proposed', checks: gates.checks };
 }
 
+// 台账轮转封存件文件名（与 evolution-persistence 轮转同口径）。
+const ARCHIVE_PATTERN = /^dispatch-(\d+)-(\d+)(?:-\d+)?\.jsonl$/;
+
+// 派发台账只读解析（金丝雀基线/样本数据源）：活动台账 + 轮转封存件合并读取，观察
+// 期跨轮转不丢样本；单文件缺失/损坏跳过，整体缺失回退空表，fail-soft。
+function readDispatchRecords(file) {
+  if (typeof file !== 'string') return [];
+  const dir = dirname(file);
+  const names = [basename(file)];
+  try {
+    for (const name of readdirSync(dir)) if (ARCHIVE_PATTERN.test(name)) names.push(name);
+  } catch { /* 目录读失败只读活动台账 */ }
+  const records = [];
+  for (const name of names) {
+    const path = join(dir, name);
+    if (!existsSync(path)) continue;
+    try {
+      records.push(...parseDispatchRecords(readFileSync(path, 'utf8').split('\n')).records);
+    } catch { /* 单文件读失败跳过，不影响其余 */ }
+  }
+  return records;
+}
+
 // 进程级按身份键单写锁：同键 apply 排队（并发只生效一次），跨键并行。
 function withApplyLock(locks, key, fn) {
   const previous = locks.get(key) ?? Promise.resolve();
@@ -187,10 +251,87 @@ function applyCandidate(deps, locks, { assetId, humanConfirmed }) {
   return withApplyLock(locks, key, () => applyOnce(deps, deps.assets.get(assetId), humanConfirmed === true));
 }
 
+// 决议入口（受控路由专用；回滚=撤销已确认应用，keep=显式保留）：读资产 → 身份键
+// 锁内执行（与 apply 共用同一锁串行化）。不受 apply 开关门限制——决议是闭环收口路径。
+function rollbackCandidate(deps, locks, { assetId, humanConfirmed, action = 'rollback' }) {
+  const asset = deps.assets.get(assetId);
+  if (asset === undefined) return { ok: false, reason: '回滚资产不存在（可能已过期或被清理）' };
+  const key = typeof asset.profile_key === 'string' ? asset.profile_key : assetId;
+  return withApplyLock(locks, key, () => executeRollback(deps, deps.assets.get(assetId), humanConfirmed === true, action));
+}
+
+// 金丝雀推进入口：遍历观察期（proposed + 金丝雀未终）资产逐条判定；幂等，可安全
+// 随 /list 与资产列表多次调用。
+function evaluateCanaries(deps, now = Date.now()) {
+  const results = [];
+  for (const asset of deps.assets.list()) {
+    if (asset !== null && typeof asset === 'object' && asset.state === 'proposed') {
+      results.push(evaluateCanary(deps, asset, now));
+    }
+  }
+  return results;
+}
+
+// 候选生成前置闸（滞后防振荡）：cooldown 优先抑制（回滚冷却轮不计数），连续同方向
+// 建议不足 N 次不产候选；人工强制键（重新生成候选）豁免。
+async function generateWithLag(deps, input) {
+  const advice = Array.isArray(input?.advice) ? input.advice : [];
+  const summaries = input?.summaries ?? deps.getSummaries?.() ?? null;
+  const now = Date.now();
+  const gated = [];
+  const lagSkipped = [];
+  for (const item of advice) {
+    if (item === null || typeof item !== 'object') continue;
+    const forced = typeof input?.forceProfileKey === 'string' && input.forceProfileKey === item.profileKey;
+    if (!forced && rollbackCooldownBlocks(deps.assets.list(), item.profileKey, directionOf(item), now)) {
+      lagSkipped.push({ profileKey: item.profileKey, reason: 'rollback-cooldown' });
+      continue;
+    }
+    if (!forced && bumpStreak(deps.streaks, item, summaries, now) < LAG_N) {
+      lagSkipped.push({ profileKey: item.profileKey, reason: 'lag-not-reached' });
+      continue;
+    }
+    gated.push(item);
+  }
+  const result = await generateCandidates(deps, { advice: gated, summaries, forceProfileKey: input?.forceProfileKey });
+  return {
+    generated: result.generated ?? [],
+    skipped: [...lagSkipped, ...(result.skipped ?? [])],
+    ...(result.reason !== undefined ? { reason: result.reason } : {}),
+  };
+}
+
+// 引擎构造（从装配层拆出守行门）：注入读台账/streak 落盘/回滚冷却注入/回滚建议提醒等闭环依赖。
+function buildEngine({ ctx, store, catalog, assets, evoLedger, adviceWhitelist, logger, getEvolutionAdvice, applyEnabled, summariesFile, dispatchFile, pluginVersion, mintRollbackReminder }) {
+  return createEvolutionEngine({
+    store,
+    catalog,
+    assets,
+    evoLedger,
+    whitelist: adviceWhitelist,
+    logger,
+    getApplyEnabled: () => applyEnabled,
+    getAdviceEnabled: getEvolutionAdvice,
+    getAllowFailOpen: () => store.getAllowFailOpen(),
+    getLlm: () => ctx.get('llm'),
+    getSummaries: () => readSummaries(summariesFile, logger, { onLoss: () => evoLedger.markMigrationLoss() }),
+    getCandidateMode: () => store.loadCandidateMode(),
+    getCandidateTtlH: () => store.loadCandidateTtlH(),
+    getDispatchRecords: () => readDispatchRecords(dispatchFile),
+    saveStreaks: (list) => writeBackStreaks(summariesFile, list, logger),
+    injectRollbackCooldown: (profileKey, untilTs) => {
+      const data = readSummaries(summariesFile, logger, { onLoss: () => evoLedger.markMigrationLoss() });
+      writeBackCooldowns(summariesFile, data, [[profileKey, untilTs]], logger);
+    },
+    mintRollbackReminder,
+    pluginVersion,
+  });
+}
+
 // 进化装配 helper：资产域 + 引擎 + 建议/候选生成 helper。adviceSource 是
 // /list（建议面板数据）的唯一入口——computeAdvice 之后随建议链开关把建议推导
 // 成候选资产（换代判定按用户设置），避免多处重复生成；生成失败只 warn 不影响
-// 建议展示（fail-soft）。注入段文本走 buildAdviceText。
+// 建议展示（fail-soft）。面板文本走 renderAdviceText/buildAdviceText（模型侧注入下架）。
 export function createEvolutionAssembly({
   ctx,
   home,
@@ -199,6 +340,7 @@ export function createEvolutionAssembly({
   evoLedger,
   adviceWhitelist,
   getEvolutionAdvice,
+  getReminderStore,
   pluginVersion,
 }) {
   const logger = ctx.logger;
@@ -206,23 +348,15 @@ export function createEvolutionAssembly({
   const applyEnabled = store.loadApplyEnabled();
   const summariesFile = join(home, 'subagent-evolution', 'summaries.json');
   const dispatchFile = join(home, 'subagent-evolution', 'dispatch.jsonl');
-  const engine = createEvolutionEngine({
-    store,
-    catalog,
-    assets,
-    evoLedger,
-    whitelist: adviceWhitelist,
-    logger,
-    getApplyEnabled: () => applyEnabled,
-    getAdviceEnabled: getEvolutionAdvice,
-    getAllowFailOpen: () => store.getAllowFailOpen(),
-    getLlm: () => ctx.get('llm'),
-    getSummaries: () => readSummaries(summariesFile, logger, { onLoss: () => evoLedger.markMigrationLoss() }),
-    getCandidateMode: () => store.loadCandidateMode(),
-    getCandidateTtlH: () => store.loadCandidateTtlH(),
-    pluginVersion,
-  });
+  const engine = buildEngine({ ctx, store, catalog, assets, evoLedger, adviceWhitelist, logger, getEvolutionAdvice, applyEnabled, summariesFile, dispatchFile, pluginVersion, mintRollbackReminder: getReminderStore });
   const adviceSource = async () => {
+    // 金丝雀判定先于建议/候选生成：观察期满自动出 verdict（回滚建议只读挂面板），
+    // 失败只 warn 不阻断建议展示（fail-soft）。
+    try {
+      engine.evaluateCanaries();
+    } catch (error) {
+      logger.warn(`[dsh-subagent-profile] 金丝雀判定失败：${error instanceof Error ? error.message : String(error)}`);
+    }
     const result = computeAdvice({ summariesFile, dispatchFile, whitelist: adviceWhitelist, logger, onLoss: () => evoLedger.markMigrationLoss() });
     // 候选生成与建议链开关同生共死（同一 getter）：面板开才生成与下发候选，
     // 面板关不悄悄生成；apply 开关只门应用写路径。
@@ -257,13 +391,24 @@ export function createEvolutionEngine({
   pluginVersion,
   getCandidateMode = () => 'auto',
   getCandidateTtlH = () => 24,
+  getDispatchRecords = () => [],
+  saveStreaks = () => {},
+  injectRollbackCooldown = () => {},
+  getHoldoutBacktest = () => holdoutBacktest,
+  mintRollbackReminder = () => {},
 }) {
-  const deps = { store, catalog, assets, evoLedger, whitelist, logger, getApplyEnabled, getAdviceEnabled, getAllowFailOpen, getLlm, getSummaries, pluginVersion, getCandidateMode, getCandidateTtlH, assessGates: (config) => assessApplyGates(deps, config) };
   const applyLocks = new Map();
+  const streaks = createLagStreaks({ save: (list) => saveStreaks(list) });
+  const deps = { store, catalog, assets, evoLedger, whitelist, logger, getApplyEnabled, getAdviceEnabled, getAllowFailOpen, getLlm, getSummaries, pluginVersion, getCandidateMode, getCandidateTtlH, getDispatchRecords, saveStreaks, injectRollbackCooldown, getHoldoutBacktest, mintRollbackReminder, streaks, assessGates: (config) => assessApplyGates(deps, config) };
   return {
     list: () => assets.list(),
-    generate: (input) => generateCandidates(deps, input),
+    generate: (input) => generateWithLag(deps, input),
     regenerate: (input) => regenerateCandidates(deps, input),
     apply: (input) => applyCandidate(deps, applyLocks, input),
+    rollback: (input) => rollbackCandidate(deps, applyLocks, input),
+    evaluateCanaries: (now = Date.now()) => evaluateCanaries(deps, now),
+    evolutionStatus: () => evolutionStatusOf({ getApplyEnabled: deps.getApplyEnabled, summaries: deps.getSummaries() }),
+    backtest: (records, candidateConfig, opts) => deps.getHoldoutBacktest()(records, candidateConfig, opts),
+    purgeCandidates: () => assets.purgeAll(),
   };
 }

package/lib/core/evolution-generate.mjs

@@ -4,34 +4,13 @@
 // 审计）再产新一代；手动维护不自动换代、不自动过期，只经「重新生成候选」刷新
 // （留审计）。纯函数 + 注入 deps，零 IO、零 LLM。
 
-import { sanitizeProfile } from './pure.mjs';
-import { profileKeyOf } from './evolution-summary.mjs';
-import { buildEvolutionCandidates, profileFingerprint, sourceConfigFromKey } from './evolution-draft.mjs';
+import { buildEvolutionCandidates, matchingRegistryProfiles, profileFingerprint, sourceConfigFromKey } from './evolution-draft.mjs';
 import { candidateExpired, candidateExpiryOf, dataFingerprintOf, dataSignificantlyChanged, expireAuditEntry, refreshAuditEntry } from './evolution-renewal.mjs';
+import { observationPeriodBlocked } from './evolution-lag.mjs';
 
 // 候选总量护栏：evolution 资产数达到 20 条即跳过生成并 warn（阈值待实测后校准）。
 const ASSET_CAP = 20;
 
-// 存量 profile 的 L1 身份键（与聚合层同口径：persona/toolFilter 只认存在性）。
-function keyCfg(profile) {
-  const cfg = {};
-  if (typeof profile.preset === 'string' && profile.preset !== '' && profile.preset !== 'inherit') cfg.preset = profile.preset;
-  if (typeof profile.provider === 'string' && profile.provider !== '') cfg.provider = profile.provider;
-  if (typeof profile.model === 'string' && profile.model !== '') cfg.model = profile.model;
-  if (typeof profile.persona === 'string' && profile.persona.length > 0) cfg.persona_present = true;
-  if (profile.toolFilter !== undefined && profile.toolFilter !== null) cfg.toolFilter_present = true;
-  return cfg;
-}
-
-// 注册表中与该 L1 身份键匹配的方案（净化后快照）——指纹输入，编辑任一方案
-// 都会使候选过期。
-export function matchingRegistryProfiles(store, profileKey) {
-  const profiles = store.profiles instanceof Map ? [...store.profiles.values()] : [];
-  return profiles
-    .filter((p) => p !== null && typeof p === 'object' && profileKeyOf(keyCfg(p)) === profileKey)
-    .map((p) => sanitizeProfile(p, { strict: false }).clean);
-}
-
 // 单条候选 → 资产对象。baseline_snapshot 留档金丝雀基线（from + 生成时刻的加权分/
 // 样本数）；data_fingerprint 留档换代判定输入；expiry 按用户设置（手动维护或不自动
 // 过期档为 null，否则 = 生成时刻 + 有效期小时数）。
@@ -173,7 +152,12 @@ export async function generateCandidates(deps, { advice, summaries, forceProfile
 
 // 重新生成候选（人工触发）：该身份键所有未处置候选先转 expired，再产新一代；
 // 审计 suggestion-refresh 一条（人工触发即确认）。无当前建议时只清理不产新候选。
+// 观察期内（proposed + 金丝雀未终）同键 skip：换代会销毁观察/回滚依据，不清理、
+// 不产新一代、不写 refresh 审计（无动作即无留痕）。
 export async function regenerateCandidates(deps, { profileKey, advice, summaries }) {
+  if (observationPeriodBlocked(deps.assets.list(), profileKey)) {
+    return { expired: [], generated: [], skipped: [{ profileKey, reason: 'observation-period' }] };
+  }
   const unresolved = deps.assets.findUnresolved(profileKey);
   const expired = [];
   for (const entry of unresolved) {

package/lib/core/evolution-lag.mjs

@@ -0,0 +1,78 @@
+// lib/core/evolution-lag.mjs — 防振荡域（滞后计数 + 回滚冷却 + 观察期联动判据）。
+// 滞后 N：同 (profile_key, axis, direction) 连续 N 次同方向建议才放行候选生成
+// （N=2 初值，待实测后校准）；与建议链 10min cooldown 并存——cooldown 优先抑制，
+// 被抑制的建议不计入连续次数。回滚后冷却：rolled_back 资产进同键冷却，冷却期内
+// 不再产生同方向候选（闭环有界：同键 apply→rollback 往返最多 1 次进入冷却）。
+// 观察期联动：观察期内（proposed + 金丝雀未终）同键禁止换代与重生成候选；无
+// canary 字段的旧资产不阻断（保持既有「重新生成候选」通道）。
+// 本域纯函数 + 注入保存：streak 缓存驻内存，落盘由装配层注入 save（fail-soft）。
+
+// 滞后 N：连续同方向建议次数门槛（初值，待实测后校准）。
+export const LAG_N = 2;
+// 回滚后同键冷却时长（与建议链 cooldown 同值）。
+export const ROLLBACK_COOLDOWN_MS = 10 * 60 * 1000;
+
+// 建议方向 → 资产方向（down/up 与候选资产同口径）。
+export function directionOf(item) {
+  return item !== null && typeof item === 'object' && item.suggestion === '升' ? 'up' : 'down';
+}
+
+// 建议方向 → 资产轴（capability/budget）。
+export function axisOf(item) {
+  return item !== null && typeof item === 'object' && item.suggestion === '升' ? 'budget' : 'capability';
+}
+
+// 观察期是否进行中：proposed + 金丝雀未终且未因人工编辑失效。verdict 为 applied /
+// aborted-human-edit 或资产 invalid 时视为已终；regress 等待人工回滚期间仍阻断
+// （换代会销毁回滚建议依据，须先回滚或人工编辑）。
+export function observationPeriodActive(asset) {
+  if (asset === null || typeof asset !== 'object' || asset.state !== 'proposed' || asset.invalid === true) return false;
+  const canary = asset.canary;
+  if (canary === null || typeof canary !== 'object') return false;
+  return canary.verdict !== 'applied' && canary.verdict !== 'aborted-human-edit';
+}
+
+// 资产列表（完整资产）中是否存在同键观察期资产。
+export function observationPeriodBlocked(assetList, profileKey) {
+  return assetList.some((a) => a !== null && typeof a === 'object' && a.profile_key === profileKey && observationPeriodActive(a));
+}
+
+// 决议后冷却是否生效：同键同方向 rolled_back 资产（回滚决议）或带 cooldown_until
+// 的 applied 资产（显式保留决议）在冷却期内抑制候选生成——两种决议都是闭环终点，
+// 冷却口径一致（有界性：同键 apply→rollback 往返最多 1 次进入冷却）。
+export function rollbackCooldownBlocks(assetList, profileKey, direction, now, cooldownMs = ROLLBACK_COOLDOWN_MS) {
+  return assetList.some((a) => a !== null && typeof a === 'object' && a.profile_key === profileKey && a.direction === direction
+    && ((a.state === 'rolled_back' && Number.isFinite(a.rollback_at) && now - a.rollback_at < cooldownMs)
+      || (a.state === 'applied' && Number.isFinite(a.cooldown_until) && now < a.cooldown_until)));
+}
+
+// streak 键：身份键 + 轴 + 方向（连续同方向计数按此聚合）。
+function streakKeyOf(profileKey, axis, direction) {
+  return `${profileKey}\u0000${axis}\u0000${direction}`;
+}
+
+// 连续同方向建议计数：缓存未命中时读 summaries 里上次落盘的 streak（重启续数），
+// 方向翻转重置为 1；计数封顶 LAG_N（防无限增长）。save 注入为批量落盘（fail-soft）。
+export function bumpStreak(streaks, item, summaries, now) {
+  const profileKey = item.profileKey;
+  const axis = axisOf(item);
+  const direction = directionOf(item);
+  const key = streakKeyOf(profileKey, axis, direction);
+  let prev = streaks.cache.get(key);
+  if (prev === undefined) {
+    const l1 = summaries !== null && typeof summaries === 'object' && summaries.l1 !== null && typeof summaries.l1 === 'object' ? summaries.l1 : {};
+    const seeded = l1[profileKey]?.streak;
+    prev = seeded !== null && typeof seeded === 'object' && seeded.axis === axis && seeded.direction === direction ? seeded : null;
+  }
+  const count = prev !== null && typeof prev === 'object' && Number.isFinite(prev.count) ? Math.min(LAG_N, prev.count + 1) : 1;
+  const next = { profileKey, axis, direction, count, last_ts: now };
+  streaks.cache.set(key, next);
+  try { streaks.save([next]); } catch { /* 落盘失败不阻断生成（fail-soft） */ }
+  return count;
+}
+
+// streak 缓存工厂：save 注入落盘（装配层写回 summaries.json）；缓存驻内存供
+// 同进程连续轮次复用。
+export function createLagStreaks({ save = () => {} } = {}) {
+  return { cache: new Map(), save };
+}

package/lib/core/evolution-ledger.mjs

@@ -82,7 +82,7 @@ function cfgOf(merged, opts = {}) {
 
 // 记录静态元数据（写入即知的共享字段，不含 ts/v——由 record 落盘时补）。三分支各自
 // 在此基础上补 child_id 与 outcome 后调用 record。pluginVersion 由工厂闭包注入。
-function buildBase({ parent, args, merged, mode, pluginVersion }) {
+function buildBase({ parent, args, merged, mode, pluginVersion, effectiveModelSource }) {
   const prompt = typeof args?.prompt === 'string' ? args.prompt : '';
   const effectivePreset = mode === 'continuable' ? 'inherit' : (merged?.preset ?? 'inherit');
   // continuable 下宿主忽略 reasoningEffort（决策轨迹侧将其列入 ignored），生效栏
@@ -94,6 +94,9 @@ function buildBase({ parent, args, merged, mode, pluginVersion }) {
     session_id: parent?.session?.header?.id ?? null,
     parent_model: parent?.options?.model ?? null,
     parent_provider: parent?.options?.provider ?? null,
+    // 生效来源（call/profile/parent/default）：每次派发记录「生效路由是谁决定的」；
+    // 调用方未传时归一 null，保持 JSONL 行形状稳定。
+    effectiveModelSource: typeof effectiveModelSource === 'string' && effectiveModelSource !== '' ? effectiveModelSource : null,
     mode,
     origin: ORIGIN,
     requested: cfgOf(merged),