evolcore 0.0.32 → 0.0.34

package/dist/paths.js

@@ -208,6 +208,26 @@ export function channelStatePath(channelKey, ...parts) {
 export function agentTriggersDir(aid) {
     return path.join(agentDir(aid), 'triggers');
 }
+/** 话题数据的统一根目录：索引、摘要、续读锚点、跨会话收件箱都收在这里。 */
+export function agentThreadsDir(aid) {
+    return path.join(agentDataDir(aid), 'threads');
+}
+export function agentThreadIndexPath(aid) {
+    return path.join(agentThreadsDir(aid), 'index.json');
+}
+export function agentThreadSummariesDir(aid) {
+    return path.join(agentThreadsDir(aid), 'summaries');
+}
+export function agentThreadSummaryPath(aid, sessionId) {
+    return path.join(agentThreadSummariesDir(aid), `${sessionId}.summary.jsonl`);
+}
+/** Thread Context 收件箱：跨话题发送后在目标会话侧留下的注入提醒。 */
+export function agentThreadInboxDir(aid) {
+    return path.join(agentThreadsDir(aid), 'inbox');
+}
+export function agentThreadInboxPath(aid, targetSessionId) {
+    return path.join(agentThreadInboxDir(aid), `${targetSessionId}.jsonl`);
+}
 function stripTrailingWindowsSeparators(value) {
     const stripped = value.replace(/[\\/]+$/g, '');
     // Keep a drive-root separator. `C:` is a drive-relative path on Windows.
@@ -414,8 +434,81 @@ export function kitsSchemasDir() {
 export function eckDebugDir() {
     return path.join(resolveRoot(), 'data', 'eck-debug');
 }
+export function debugSessionsDir() {
+    return path.join(resolveRoot(), 'data', 'debug-sessions');
+}
 export function getPackageRoot() {
     // import.meta.dirname is available in Node.js 21.2+ and always returns
     // the correct OS-native path, regardless of Git Bash or MSYS2 environment.
     return path.resolve(import.meta.dirname, '..');
 }
+// ── FileIntegrityStore 路径 ──
+export function integrityDir() {
+    return path.join(resolveRoot(), 'data', 'integrity');
+}
+export function integrityDbPath() {
+    return path.join(integrityDir(), 'file-integrity.db');
+}
+export function integritySnapshotDir() {
+    return path.join(integrityDir(), 'snapshots');
+}
+/**
+ * 判断当前是否为开发仓运行模式。
+ * 与 ec start 显示的安装类型保持口径一致：包路径包含 node_modules 则为安装模式，否则为开发仓。
+ * 调用方据此决定是否跳过 FileIntegrityStore 的 verify 调用。
+ *
+ * 唯一覆盖来源是 `ec start --as-mode` 写下的一次性文件（见 asModeOverridePath），
+ * 由 daemon 启动时读取并立即删除。**不读环境变量**——环境变量会被 restart 之类的
+ * 路径静默继承，导致模式在操作者不知情的情况下改变。
+ */
+export function isDevMode() {
+    if (!_asModeResolved) {
+        _asModeResolved = true;
+        _asModeOverride = consumeAsModeOverride();
+    }
+    if (_asModeOverride)
+        return _asModeOverride === 'dev';
+    return !getPackageRoot().includes('node_modules');
+}
+/**
+ * `ec start --as-mode <mode>` 的一次性覆盖文件。
+ *
+ * 走文件而不是环境变量：环境变量会被 `ec restart`（全量继承 process.env）
+ * 静默带进新 daemon，操作者不重启终端就撤不掉。文件由 CLI 在启动前写入，
+ * daemon 首次调用 isDevMode() 时读走并删除，只影响这一次启动。
+ */
+export function asModeOverridePath() {
+    return path.join(resolveRoot(), 'data', 'daemon', 'as-mode.override');
+}
+/**
+ * 本次进程的覆盖值。**必须缓存**：文件读一次就删，若每次都去读，
+ * 第二次调用起就会悄悄退回按包路径判断——模式在进程运行中途改变是最坏的情况。
+ */
+let _asModeResolved = false;
+let _asModeOverride = null;
+/** 仅供测试：清掉缓存，让下一次 isDevMode() 重新读覆盖文件。 */
+export function _resetAsModeCache() {
+    _asModeResolved = false;
+    _asModeOverride = null;
+}
+/**
+ * 读出并删除覆盖文件（一次性）。返回 null 表示没有覆盖。
+ * 只应由 daemon 启动流程（或 isDevMode 的首次求值）调用一次。
+ */
+export function consumeAsModeOverride() {
+    const file = asModeOverridePath();
+    if (!fs.existsSync(file))
+        return null;
+    let value = null;
+    try {
+        value = fs.readFileSync(file, 'utf-8').trim();
+    }
+    catch {
+        value = null;
+    }
+    try {
+        fs.rmSync(file, { force: true });
+    }
+    catch { /* ignore */ }
+    return value === 'dev' || value === 'install' ? value : null;
+}

package/dist/response-system/engines/v1/proactive-flow.js

@@ -12,20 +12,18 @@ const STATE_KEY = 'proactive';
 const SNAPSHOT_KEY = 'proactive:continuation';
 const OWNER_KEY = 'proactive:owner';
 const SNAPSHOT_MAX_AGE_MS = 30 * 60 * 1_000;
-const TOOL_REPORT_INTERVAL = 20;
+/** 计数器初值与提示档位：计数 = 该值时放行并提示，> 该值时只放行意图表达 */
+export const INTENT_GATE_INTERVAL = 15;
+const TOOL_REPORT_INTERVAL = INTENT_GATE_INTERVAL;
+/** 队列未读提醒长度跨轮次持久化的 sessionState key（问题3修复） */
+const QUEUE_REMINDER_SESSION_KEY = 'proactive:lastQueueReminderLen';
+/** 熔断已触发标记，存 sessionState 供 afterProcess 发渠道消息（F5修复） */
+const CIRCUIT_BREAK_SESSION_KEY = 'proactive:circuitBreak';
+/** 单轮内允许的最大违规次数；超过后触发熔断而非继续注入提醒（问题1/2修复） */
+export const VIOLATION_CIRCUIT_BREAK_THRESHOLD = 2;
 const SEND_RECEIPT_RE = /["']?(?:message[_ -]?id|handoff[_ -]?id)["']?\s*[:=]\s*["']?([A-Za-z0-9][A-Za-z0-9._:-]*)/gi;
 const HANDOFF_TEXT_RECEIPT_RE = /\bhandoff\s+(h-[A-Za-z0-9._-]+)/i;
 const RETURN_CONTENT_RE = /["']?(?:return[_ -]?content|returnContent)["']?\s*[:=]\s*["']?([^}\n,]*)/i;
-function hasRequiredReturnFlag(toolInput) {
-    if (!toolInput || typeof toolInput !== 'object')
-        return false;
-    const input = toolInput;
-    const commandValues = ['command', 'cmd', 'script'].flatMap(key => {
-        const value = input[key];
-        return typeof value === 'string' ? [value] : [];
-    });
-    return commandValues.some(command => /(?:^|\s)--return(?:=|\s+)['"]?required(?:['"]?)(?=\s|$)/i.test(command));
-}
 function hasSuccessfulSendReceipt(result, isError, requiresBusinessReturn = false) {
     if (isError === true)
         return false;
@@ -137,6 +135,57 @@ function hasSuccessfulSendReceipt(result, isError, requiresBusinessReturn = fals
         return true;
     return false;
 }
+function sendHint(state) {
+    return state.chatType === 'group'
+        ? { cmdHint: 'ec group send', target: '群里' }
+        : { cmdHint: 'ec msg send', target: '对方' };
+}
+/**
+ * 结算当前轮：本轮有意图表达成功 → 清零（不再 +1）；否则 +1。
+ * 被拒绝的调用不会产生成功回执，因此不能触发清零。
+ */
+function settleRound(state) {
+    if (!state.roundOpen)
+        return;
+    state.roundOpen = false;
+    state.roundPending = 0;
+    state.roundCounter = state.roundHasIntentSuccess ? 0 : state.roundCounter + 1;
+}
+/**
+ * 进入一轮。turn 为 runner 提供的模型返回序号：
+ * - 有 turn：同一 turn 视为同一轮；turn 变化时先结算上一轮
+ * - 无 turn（runner 不支持）：已有未结算的轮则沿用，结算由飞行数归零触发
+ */
+function beginRound(state, turn) {
+    if (typeof turn === 'number' && Number.isFinite(turn)) {
+        state.turnAware = true;
+        // 先由拿不到 turn 的调用开了轮：认领这个 turn，而不是当成新轮结算
+        if (state.roundOpen && state.roundTurn === undefined) {
+            state.roundTurn = turn;
+            return;
+        }
+        if (state.roundOpen && state.roundTurn === turn)
+            return;
+        settleRound(state);
+    }
+    else if (state.roundOpen) {
+        return;
+    }
+    state.roundOpen = true;
+    state.roundTurn = typeof turn === 'number' ? turn : undefined;
+    state.roundStartCounter = state.roundCounter;
+    state.roundPending = 0;
+    state.roundHasIntentAttempt = false;
+    state.roundHasIntentSuccess = false;
+    state.roundWarned = false;
+}
+/** 新输入（新消息、插入消息、队列合并、续跑、任务恢复）到来：计数重置为初值 */
+export function resetIntentCounter(state) {
+    state.roundOpen = false;
+    state.roundPending = 0;
+    state.roundTurn = undefined;
+    state.roundCounter = INTENT_GATE_INTERVAL;
+}
 function isHumanFacingMessage(message) {
     if (message.source === 'trigger')
         return false;
@@ -161,7 +210,17 @@ function buildState(message, cfg) {
         firstSendRequired: preTool1stMsgChk && humanFacing,
         toolReportRequired: toolUseReminder && humanFacing,
         toolReportInterval: TOOL_REPORT_INTERVAL,
-        toolReportPending: false,
+        violationCount: 0,
+        intentGateRequired: (preTool1stMsgChk || toolUseReminder) && humanFacing,
+        roundCounter: INTENT_GATE_INTERVAL,
+        roundOpen: false,
+        roundStartCounter: INTENT_GATE_INTERVAL,
+        roundTurn: undefined,
+        turnAware: false,
+        roundPending: 0,
+        roundHasIntentAttempt: false,
+        roundHasIntentSuccess: false,
+        roundWarned: false,
     };
 }
 function normalizedThread(threadId) {
@@ -169,7 +228,10 @@ function normalizedThread(threadId) {
 }
 function isResumableTerminal(terminal) {
     return terminal?.status === 'interrupted' && terminal.reason === 'daemon_restart'
-        || terminal?.status === 'cancelled' && (terminal.reason === 'stop' || terminal.reason === 'explicit_cancel');
+        || terminal?.status === 'cancelled' && (terminal.reason === 'stop'
+            || terminal.reason === 'explicit_cancel'
+        // 熔断中断走 agent.interrupt() 默认路径，reason 为 explicit_cancel，此处已覆盖
+        );
 }
 function canRestoreSnapshot(ctx, state, snapshot) {
     const previous = ctx.previousTurnState;
@@ -182,7 +244,7 @@ function canRestoreSnapshot(ctx, state, snapshot) {
     const age = Date.now() - snapshot.finishedAt;
     if (!Number.isFinite(age) || age < 0 || age > SNAPSHOT_MAX_AGE_MS
         || !Number.isSafeInteger(snapshot.toolCount) || snapshot.toolCount < 0
-        || typeof snapshot.firstToolDone !== 'boolean' || typeof snapshot.toolReportPending !== 'boolean'
+        || typeof snapshot.firstToolDone !== 'boolean'
         || snapshot.sessionId !== ctx.session.id || snapshot.selfAid !== ctx.session.selfAID
         || snapshot.channel !== ctx.session.channel || snapshot.channelId !== ctx.session.channelId
         || snapshot.chatType !== ctx.message.chatType || snapshot.chatType !== ctx.session.chatType
@@ -230,10 +292,10 @@ function saveContinuation(ctx) {
         finishedAt: terminal.finishedAt,
         firstToolDone: state.firstToolDone,
         toolCount: state.toolCount,
-        toolReportPending: state.toolReportPending,
         firstSendRequired: state.firstSendRequired,
         toolReportRequired: state.toolReportRequired,
         toolReportInterval: state.toolReportInterval,
+        violationCount: state.violationCount, // F4修复：跨续跑保留违规计数
     };
     ctx.sessionState.set(SNAPSHOT_KEY, snapshot);
 }
@@ -265,10 +327,25 @@ export const proactiveFlow = {
         const state = buildState(ctx.message, ctx.modeConfig ?? {});
         const snapshot = ctx.sessionState?.get(SNAPSHOT_KEY);
         ctx.sessionState?.delete(SNAPSHOT_KEY);
-        if (snapshot && canRestoreSnapshot(ctx, state, snapshot)) {
+        const snapshotRestored = snapshot && canRestoreSnapshot(ctx, state, snapshot);
+        if (snapshotRestored) {
             state.firstToolDone = snapshot.firstToolDone;
             state.toolCount = snapshot.toolCount;
-            state.toolReportPending = state.toolReportRequired && snapshot.toolReportPending;
+            // F4修复：跨续跑恢复违规计数，防止每次续跑都重置熔断配额
+            if (typeof snapshot.violationCount === 'number')
+                state.violationCount = snapshot.violationCount;
+            // 轮次计数不恢复：续跑/任务恢复属于新输入，buildState 已置为初值
+        }
+        else if (snapshot) {
+            // F8修复：快照存在但恢复失败（channel/chatType 变化等），
+            // 状态已不连续，清除过期的队列提醒长度，避免错误抑制新轮次的提醒
+            ctx.sessionState?.delete(QUEUE_REMINDER_SESSION_KEY);
+        }
+        // 问题3修复：从 sessionState 恢复跨轮次的队列提醒长度，
+        // 避免每轮重置为 0 后队列 ≥ 3 就反复触发未读提醒。
+        const persistedQueueLen = ctx.sessionState?.get(QUEUE_REMINDER_SESSION_KEY);
+        if (typeof persistedQueueLen === 'number' && persistedQueueLen > 0) {
+            state.lastQueueReminderLen = persistedQueueLen;
         }
         ctx.state.set(STATE_KEY, state);
         ctx.sessionState?.set(OWNER_KEY, state);
@@ -279,109 +356,121 @@ export const proactiveFlow = {
         if (!state)
             return undefined;
         return {
-            policyHook: (toolName, toolInput) => {
+            policyHook: (toolName, toolInput, meta) => {
                 // Codex only invokes this hook for local tool paths. Hosted tools stay
-                // enabled and do not satisfy or clear the pending first-send gate.
+                // enabled and do not satisfy the intent gate.
                 const isSendCommand = ctx.isSendCommand(toolName, toolInput);
-                if (!isSendCommand && ((state.firstSendRequired && !state.firstToolDone) || state.toolReportPending)) {
-                    const sendFailure = ctx.describeSendCommandFailure?.(toolName, toolInput);
-                    if (sendFailure)
-                        return { block: true, policyCode: 'proactive_send_invalid', reason: sendFailure };
+                const { cmdHint, target } = sendHint(state);
+                beginRound(state, meta?.turn);
+                // 意图表达工具始终放行；是否清零看执行结果（onToolResult）
+                if (isSendCommand) {
+                    state.roundHasIntentAttempt = true;
+                    return undefined;
                 }
-                if (state.firstSendRequired && !state.firstToolDone) {
-                    if (!isSendCommand) {
-                        const cmdHint = state.chatType === 'group' ? 'ec group send' : 'ec msg send';
-                        const target = state.chatType === 'group' ? '群里' : '对方';
-                        return {
-                            block: true,
-                            policyCode: 'proactive_first_send_required',
-                            reason: `请先用 ${cmdHint} 向${target}说明你的意图，再执行其他工具`,
-                        };
+                // 非 send 命令：先检查格式是否"像 send 但解析失败"（F2修复：计入违规）
+                const sendFailure = ctx.describeSendCommandFailure?.(toolName, toolInput);
+                if (sendFailure) {
+                    state.violationCount++;
+                    if (state.violationCount >= VIOLATION_CIRCUIT_BREAK_THRESHOLD) {
+                        return { block: true, policyCode: 'proactive_circuit_break', reason: `连续违规 ${state.violationCount} 次，任务已中断，请重新描述需求` };
                     }
+                    return { block: true, policyCode: 'proactive_send_invalid', reason: sendFailure };
                 }
-                if (state.toolReportPending) {
-                    if (!isSendCommand) {
-                        const cmdHint = state.chatType === 'group' ? 'ec group send' : 'ec msg send';
-                        const target = state.chatType === 'group' ? '群里' : '对方';
-                        return {
-                            block: true,
-                            policyCode: 'proactive_tool_report_required',
-                            reason: `工具调用已达到 ${state.toolCount} 次，请先用 ${cmdHint} 向${target}汇报当前情况和下一步意图，再执行其他工具`,
-                        };
+                if (!state.intentGateRequired)
+                    return undefined;
+                // 计数 < 15：本条消息内已有意图表达，放行
+                if (state.roundStartCounter < INTENT_GATE_INTERVAL)
+                    return undefined;
+                // 计数 = 15：全部放行，提示下一轮先做意图表达（本轮已有发送则不提示）
+                if (state.roundStartCounter === INTENT_GATE_INTERVAL) {
+                    if (!state.roundHasIntentAttempt && !state.roundWarned) {
+                        state.roundWarned = true;
+                        state.pendingRoundReminder = `⚠️ 本轮未包含意图表达，下一轮必须先用 ${cmdHint} 向${target}说明当前情况和下一步意图，否则其他工具会被拒绝。`;
                     }
+                    return undefined;
+                }
+                // 计数 ≥ 16：只放行意图表达，其他调用全部拒绝
+                state.violationCount++;
+                if (state.violationCount >= VIOLATION_CIRCUIT_BREAK_THRESHOLD) {
+                    return { block: true, policyCode: 'proactive_circuit_break', reason: `连续违规 ${state.violationCount} 次，任务已中断，请重新描述需求` };
                 }
-                return undefined;
+                return {
+                    block: true,
+                    policyCode: 'proactive_intent_required',
+                    reason: `上一轮未包含意图表达，本轮只允许 ${cmdHint}；请先向${target}说明当前情况和下一步意图，再执行其他工具`,
+                };
             },
         };
     },
-    // ─── onToolUse：队列未读提醒 + 工具汇报提醒 ───
+    // ─── onToolUse：轮次计数 + 队列未读提醒 + 工具汇报提醒 ───
     onToolUse(ctx) {
         const state = ctx.state.get(STATE_KEY);
         if (!state)
             return;
-        // PreToolUse 和 tool_use 都发生在命令执行前，不能推进发送门禁。
-        // 只有成功的 tool_result 携带明确回执时才提交状态。
+        // 轮次追踪：按模型返回序号进轮，每次工具调用开始时 pending+1
+        beginRound(state, ctx.modelTurn);
+        state.roundPending++;
+        // 15 档提示由 policyHook 写入，这里注入给模型
+        if (state.pendingRoundReminder) {
+            ctx.injectToModel(state.pendingRoundReminder);
+            ctx.recordReminder?.({ kind: 'tool_report', text: state.pendingRoundReminder, toolCount: state.roundStartCounter });
+            state.pendingRoundReminder = undefined;
+        }
         const isAllowedTool = ctx.isSendCommand(ctx.toolName, ctx.toolInput);
         if (!state.toolUseReminder)
             return;
-        // 工具计数（排除表态命令白名单）
+        // 非发送工具才计入 toolCount（仅审计）
         if (state.toolReportRequired && !isAllowedTool)
             state.toolCount++;
-        // 队列未读变化提醒：首次达到 3 条立即提醒，后续复用工具汇报的计数间隔，
-        // 避免连续工具调用时每次队列数量变化都重复注入。
+        // 队列未读变化提醒
         const queueLen = ctx.getQueueLength();
         const queueChanged = queueLen !== state.lastQueueReminderLen;
-        const toolReportDue = state.toolReportRequired
-            && !isAllowedTool
-            && state.toolCount > 0
-            && state.toolCount % state.toolReportInterval === 0;
         let queueReminder;
         const queueReminderDue = state.lastQueueReminderLen === 0
             ? queueLen >= 3
-            : toolReportDue;
+            : false; // 汇报间隔改由轮次控制
         if (queueLen === 0) {
             state.lastQueueReminderLen = 0;
+            ctx.sessionState?.delete(QUEUE_REMINDER_SESSION_KEY);
         }
         else if (queueChanged && queueReminderDue) {
             state.lastQueueReminderLen = queueLen;
+            ctx.sessionState?.set(QUEUE_REMINDER_SESSION_KEY, queueLen);
             queueReminder = queueLen >= 5
                 ? `⚠️ 有 ${queueLen} 条消息未读，请尽快完成当前任务，或使用 ec ctl queue 读取后同步处理。`
                 : `⚠️ 有 ${queueLen} 条消息未读，可使用 ec ctl queue 读取。`;
             ctx.recordReminder?.({ kind: 'queue_unread', text: queueReminder, queueLength: queueLen });
-        }
-        if (queueReminder && !toolReportDue) {
             ctx.injectToModel(queueReminder);
         }
-        // 每 N 次工具调用警告
-        // 只有计数推进到新阈值时才提醒；发送工具不能重新打开已解除的汇报门禁。
-        if (toolReportDue) {
-            state.toolReportPending = true;
-            const cmdHint = state.chatType === 'group' ? 'ec group send' : 'ec msg send';
-            const target = state.chatType === 'group' ? '群里' : '对方';
-            const reportMsg = `⚠️ 工具调用已达到 ${state.toolCount} 次，请立即用 ${cmdHint} 向${target}汇报当前情况和下一步意图。`;
-            ctx.recordReminder?.({ kind: 'tool_report', text: reportMsg, toolCount: state.toolCount });
-            ctx.injectToModel(queueReminder ? `${queueReminder}\n${reportMsg}` : reportMsg);
-        }
     },
-    // ─── onToolResult：成功发送回执后解除门禁 ───
+    // ─── onToolResult：轮次推进 + 成功发送回执后更新标志位 ───
     onToolResult(ctx) {
         const state = ctx.state.get(STATE_KEY);
         if (!state)
             return;
-        if (!ctx.isSendCommand(ctx.toolName, ctx.toolInput))
-            return;
-        const requiresBusinessReturn = hasRequiredReturnFlag(ctx.toolInput)
-            && (typeof ctx.result === 'string'
-                ? HANDOFF_TEXT_RECEIPT_RE.test(ctx.result)
-                : !!ctx.result && typeof ctx.result === 'object'
-                    && ('handoff_id' in ctx.result || 'handoffId' in ctx.result));
-        HANDOFF_TEXT_RECEIPT_RE.lastIndex = 0;
-        if (!hasSuccessfulSendReceipt(ctx.result, ctx.isError || !!ctx.error, requiresBusinessReturn))
-            return;
-        if (state.firstSendRequired && !state.firstToolDone)
-            state.firstToolDone = true;
-        if (state.toolReportPending)
-            state.toolReportPending = false;
+        const isSend = ctx.isSendCommand(ctx.toolName, ctx.toolInput);
+        // tool_use 事件可能先于 PreToolUse 到达，15 档提示在这里补注入
+        if (state.pendingRoundReminder) {
+            ctx.injectToModel(state.pendingRoundReminder);
+            ctx.recordReminder?.({ kind: 'tool_report', text: state.pendingRoundReminder, toolCount: state.roundStartCounter });
+            state.pendingRoundReminder = undefined;
+        }
+        // 先记成功，再结算：被拒绝/失败的调用不能触发清零
+        const succeeded = !ctx.isError && !ctx.error
+            && ctx.executionState !== 'blocked' && ctx.executionState !== 'failed'
+            && ctx.decision !== 'deny' && ctx.executed !== false;
+        if (isSend && succeeded) {
+            state.roundHasIntentSuccess = true;
+            if (!state.firstToolDone)
+                state.firstToolDone = true;
+            state.violationCount = 0;
+        }
+        // 轮次追踪：pending-1。拿得到模型返回序号时由下一轮 beginRound 结算；
+        // 拿不到时（runner 不提供 turn）退回飞行数归零结算
+        if (state.roundPending > 0)
+            state.roundPending--;
+        if (state.roundPending === 0 && !state.turnAware)
+            settleRound(state);
     },
     // ─── onComplete：标志位检查 ───
     async onComplete(ctx) {

package/dist/stats/billing.js

@@ -180,24 +180,36 @@ function loadSpecs(evolcoreHome) {
     _specCacheTs = now;
     return _specCache;
 }
-/** 取模型在 ts 时刻的能力参数。找不到时返回默认值。
- *  带窗口后缀的 ID 复用基础模型的参数行，但窗口由后缀决定（网关的权威声明）。 */
-export function resolveModelSpec(evolcoreHome, model, ts) {
+export function findModelSpec(evolcoreHome, model, ts = Date.now()) {
     const specs = loadSpecs(evolcoreHome);
-    const t = ts ?? Date.now();
     const suffixWindow = parseModelId(model).contextWindow;
     for (const key of modelLookupKeys(evolcoreHome, model)) {
-        const candidates = specs.filter(s => s.model === key && s.effective_from <= t);
+        const candidates = specs.filter(spec => spec.model === key && spec.effective_from <= ts);
         if (!candidates.length)
             continue;
-        const row = candidates.reduce((a, b) => a.effective_from >= b.effective_from ? a : b);
+        const row = candidates.reduce((a, b) => a.effective_from > b.effective_from ? a : b);
         if (suffixWindow === undefined || suffixWindow === row.context_window)
             return row;
         // 后缀声明的窗口覆盖基础行，输入上限按原行的预留比例等比缩放。
         const ratio = row.context_window > 0 ? row.max_input_tokens / row.context_window : 0.9;
         return { ...row, model, context_window: suffixWindow, max_input_tokens: Math.floor(suffixWindow * ratio) };
     }
+    return undefined;
+}
+/** 取模型在 ts 时刻的能力参数。找不到时返回 fallback 或默认值。
+ *  带窗口后缀的 ID 复用基础模型的参数行，但窗口由后缀决定（网关的权威声明）。 */
+export function resolveModelSpec(evolcoreHome, model, ts, fallback) {
+    const spec = findModelSpec(evolcoreHome, model, ts);
+    if (spec)
+        return spec;
+    const suffixWindow = parseModelId(model).contextWindow;
     // 默认值
-    const contextWindow = suffixWindow ?? 200000;
-    return { model, effective_from: 0, context_window: contextWindow, max_input_tokens: Math.floor(contextWindow * 0.9), max_output_tokens: 8192 };
+    const contextWindow = suffixWindow ?? fallback?.context_window ?? 200000;
+    return {
+        model,
+        effective_from: 0,
+        context_window: contextWindow,
+        max_input_tokens: Math.floor(contextWindow * 0.9),
+        max_output_tokens: fallback?.max_output_tokens ?? 8192,
+    };
 }