@cc-monitoring/proxy-core 0.4.0 → 0.4.2

package/dist/utils/__tests__/request-writer.test.js

@@ -2,7 +2,7 @@ import { mkdtempSync, rmSync } from 'fs';
 import { tmpdir } from 'os';
 import path from 'path';
 import { configureDbPath, initDatabase, closeDatabase, getDatabase } from '../db.js';
-import { createRequestRecorder, recordIteration, listRequestDB, interruptStaleRequestsOnStartup } from '../request-writer.js';
+import { createRequestRecorder, recordIteration, listRequestDB, interruptStaleRequestsOnStartup, repairClosedRequests, isStreamCompleteEvents, reconstructUsageFromEvents } from '../request-writer.js';
 import { pushNewRequest } from '../../server/data-push.js';
 jest.mock('../../server/data-push.js', () => ({ pushNewRequest: jest.fn() }));
 const pushMock = pushNewRequest;
@@ -136,6 +136,62 @@ describe('request-writer', () => {
         expect(summary.requestId).toBe(cloudId);
         expect(summary.pendingId).toBe(`${meta.sessionId}:${meta.localRequestId}`);
     });
+    it('complete() migration leaves pre-existing events of another session with the same localRequestId untouched', async () => {
+        const meta = makeMeta('residue');
+        counter += 1;
+        const cloudId = `cloud_${counter}`;
+        const oldSession = 'sess_old_residue';
+        // recorder 创建之前：相同 localRequestId、不同 session_id 的历史残留事件
+        const preIns = getDatabase().prepare('INSERT INTO response_events (request_id, session_id, event_index, event_data) VALUES (?, ?, ?, ?)');
+        preIns.run(meta.localRequestId, oldSession, 0, '"old0"');
+        preIns.run(meta.localRequestId, oldSession, 1, '"old1"');
+        const rec = createRequestRecorder(meta);
+        await rec.pending();
+        for (let i = 0; i < 3; i++) {
+            rec.appendEvent({ type: 'chunk', seq: i });
+        }
+        await rec.complete({ cloudRequestId: cloudId, statusCode: 200 });
+        // 预写事件 request_id 不变（未被迁走）
+        const staleRows = getEventRows(meta.localRequestId, oldSession);
+        expect(staleRows).toHaveLength(2);
+        expect(staleRows.map(r => [r.request_id, r.event_index])).toEqual([
+            [meta.localRequestId, 0],
+            [meta.localRequestId, 1]
+        ]);
+        // 本 recorder 的事件迁到 cloudId，localId 下无事件残留
+        expect(getEventRows(meta.localRequestId, meta.sessionId)).toHaveLength(0);
+        const moved = getEventRows(cloudId, meta.sessionId);
+        expect(moved).toHaveLength(3);
+        expect(moved.map(r => r.event_index)).toEqual([0, 1, 2]);
+    });
+    it('complete() migration leaves same-session historical events with the same localRequestId untouched', async () => {
+        const meta = makeMeta('sameresidue');
+        counter += 1;
+        const cloudId = `cloud_${counter}`;
+        // recorder 创建之前：相同 localRequestId、相同 session_id 的历史残留
+        // （模拟 req-N 计数器复用后同 session 残留）。用不与新请求重叠的 event_index，
+        // 避免唯一索引 + INSERT OR IGNORE 干扰本用例对迁移行为的验证。
+        const preIns = getDatabase().prepare('INSERT INTO response_events (request_id, session_id, event_index, event_data) VALUES (?, ?, ?, ?)');
+        preIns.run(meta.localRequestId, meta.sessionId, 50, '"old0"');
+        preIns.run(meta.localRequestId, meta.sessionId, 51, '"old1"');
+        const rec = createRequestRecorder(meta);
+        await rec.pending();
+        for (let i = 0; i < 3; i++) {
+            rec.appendEvent({ type: 'chunk', seq: i });
+        }
+        await rec.complete({ cloudRequestId: cloudId, statusCode: 200 });
+        // 预写的 2 行 request_id 仍为 localRequestId（未被迁走）
+        const staleRows = getEventRows(meta.localRequestId, meta.sessionId);
+        expect(staleRows).toHaveLength(2);
+        expect(staleRows.map(r => [r.request_id, r.event_index])).toEqual([
+            [meta.localRequestId, 50],
+            [meta.localRequestId, 51]
+        ]);
+        // recorder 自己的事件迁到 cloudId
+        const moved = getEventRows(cloudId, meta.sessionId);
+        expect(moved).toHaveLength(3);
+        expect(moved.map(r => r.event_index)).toEqual([0, 1, 2]);
+    });
     it('fail() updates the pending row status/error/closed_at and pushes completed', async () => {
         const meta = makeMeta('fail');
         const rec = createRequestRecorder(meta);
@@ -240,8 +296,10 @@ describe('request-writer', () => {
         const open = requests.find(r => r.requestId === openMeta.localRequestId);
         expect(closed).toBeTruthy();
         expect(closed.closedAt).toEqual(expect.any(String));
+        expect(closed.error).toBe('boom');
         expect(open).toBeTruthy();
         expect(open.closedAt).toBeUndefined();
+        expect(open.error).toBeUndefined();
     });
     it('interruptStaleRequestsOnStartup() marks aged orphan rows and leaves fresh/completed rows untouched', async () => {
         // 超龄无主行：已收到响应头（200），时间戳回拨到 6 分钟前
@@ -264,8 +322,9 @@ describe('request-writer', () => {
         getDatabase()
             .prepare('UPDATE requests SET timestamp = ? WHERE request_id = ? AND session_id = ?')
             .run(new Date(Date.now() - 6 * 60000).toISOString(), doneMeta.localRequestId, doneMeta.sessionId);
-        const count = interruptStaleRequestsOnStartup();
-        expect(count).toBe(1);
+        const { completed, interrupted } = interruptStaleRequestsOnStartup();
+        expect(completed).toBe(0);
+        expect(interrupted).toBe(1);
         const oldRow = getRequestRow(oldMeta.localRequestId, oldMeta.sessionId);
         expect(oldRow.closed_at).toBeTruthy();
         expect(oldRow.error).toBe('interrupted: proxy restarted');
@@ -277,4 +336,206 @@ describe('request-writer', () => {
         const doneRow = getRequestRow(doneMeta.localRequestId, doneMeta.sessionId);
         expect(doneRow.closed_at).toBeNull();
     });
+    it('harvests an aged pending row ending with message_stop as completed: completed_at set, closed_at/error empty, tokens backfilled', async () => {
+        const meta = makeMeta('stopcomplete');
+        const rec = createRequestRecorder(meta);
+        await rec.pending();
+        rec.headers({ statusCode: 200 });
+        rec.appendEvent({
+            type: 'message_start',
+            usage: { input_tokens: 100, cache_read_input_tokens: 10, cache_creation_input_tokens: 2, output_tokens: 1 }
+        });
+        // 17 内容事件：总事件数 20（整批落库），message_start 在尾部 10 条窗口之外，
+        // 依赖定向 SQL 取锚点事件
+        for (let i = 0; i < 17; i++) {
+            rec.appendEvent({ type: 'content_block_delta', seq: i });
+        }
+        rec.appendEvent({ type: 'message_delta', usage: { output_tokens: 50 } });
+        rec.appendEvent({ type: 'message_stop' });
+        getDatabase()
+            .prepare('UPDATE requests SET timestamp = ? WHERE request_id = ? AND session_id = ?')
+            .run(new Date(Date.now() - 6 * 60000).toISOString(), meta.localRequestId, meta.sessionId);
+        const { completed, interrupted } = interruptStaleRequestsOnStartup();
+        expect(completed).toBe(1);
+        expect(interrupted).toBe(0);
+        const row = getRequestRow(meta.localRequestId, meta.sessionId);
+        expect(row.completed_at).toBeTruthy();
+        expect(row.closed_at).toBeNull();
+        expect(row.error).toBeNull();
+        expect(row.status_code).toBe(200);
+        expect(row.response_time).toBeGreaterThan(0);
+        expect(row.input_tokens).toBe(100);
+        expect(row.output_tokens).toBe(50);
+        expect(row.cache_read_tokens).toBe(10);
+        expect(row.cache_creation_tokens).toBe(2);
+    });
+    it('aged row without message_stop stays interrupted but tokens are backfilled when usage is recoverable', async () => {
+        const meta = makeMeta('stopmissing');
+        const rec = createRequestRecorder(meta);
+        await rec.pending();
+        rec.headers({ statusCode: 200 });
+        rec.appendEvent({
+            type: 'message_start',
+            usage: { input_tokens: 30, cache_read_input_tokens: 3, cache_creation_input_tokens: 1 }
+        });
+        for (let i = 0; i < 18; i++) {
+            rec.appendEvent({ type: 'content_block_delta', seq: i });
+        }
+        rec.appendEvent({ type: 'message_delta', usage: { output_tokens: 12 } });
+        getDatabase()
+            .prepare('UPDATE requests SET timestamp = ? WHERE request_id = ? AND session_id = ?')
+            .run(new Date(Date.now() - 6 * 60000).toISOString(), meta.localRequestId, meta.sessionId);
+        const { completed, interrupted } = interruptStaleRequestsOnStartup();
+        expect(completed).toBe(0);
+        expect(interrupted).toBe(1);
+        const row = getRequestRow(meta.localRequestId, meta.sessionId);
+        expect(row.closed_at).toBeTruthy();
+        expect(row.error).toBe('interrupted: proxy restarted');
+        expect(row.completed_at).toBeNull();
+        expect(row.input_tokens).toBe(30);
+        expect(row.output_tokens).toBe(12);
+        expect(row.cache_read_tokens).toBe(3);
+        expect(row.cache_creation_tokens).toBe(1);
+    });
+    it('reconstructUsageFromEvents merges message_start base with message_delta into all four fields (field-level, not overwrite)', () => {
+        const usage = reconstructUsageFromEvents([
+            { type: 'message_start', usage: { input_tokens: 100, output_tokens: 1, cache_read_input_tokens: 80, cache_creation_input_tokens: 5 } },
+            { type: 'content_block_delta' },
+            { type: 'message_delta', usage: { output_tokens: 42 } }
+        ]);
+        expect(usage).toEqual({
+            input_tokens: 100,
+            output_tokens: 42,
+            cache_read_input_tokens: 80,
+            cache_creation_input_tokens: 5
+        });
+    });
+    it('message_delta cache fields are merged too, and undefined is returned when no usage exists', () => {
+        const usage = reconstructUsageFromEvents([
+            { type: 'message_start', usage: { input_tokens: 10 } },
+            { type: 'message_delta', usage: { output_tokens: 4, cache_read_input_tokens: 2 } }
+        ]);
+        expect(usage).toEqual({ input_tokens: 10, output_tokens: 4, cache_read_input_tokens: 2 });
+        expect(reconstructUsageFromEvents([{ type: 'content_block_delta' }])).toBeUndefined();
+    });
+    it('OpenAI-style: choices[0].finish_reason non-empty marks complete, and a chunk with usage backfills tokens', async () => {
+        expect(isStreamCompleteEvents([
+            { choices: [{ delta: { role: 'assistant' }, finish_reason: null }] }
+        ])).toBe(false);
+        expect(isStreamCompleteEvents([
+            { choices: [{ delta: {}, finish_reason: 'stop' }] }
+        ])).toBe(true);
+        const usage = reconstructUsageFromEvents([
+            { choices: [{ delta: { content: 'hi' }, finish_reason: null }] },
+            { choices: [{ delta: {}, finish_reason: 'stop' }], usage: { prompt_tokens: 9, completion_tokens: 17 } }
+        ]);
+        expect(usage).toEqual({ input_tokens: 9, output_tokens: 17 });
+        // 端到端：OpenAI 超龄行（事件 event_type 为 NULL）走完成语义并回填
+        const meta = makeMeta('openaistop');
+        const rec = createRequestRecorder(meta);
+        await rec.pending();
+        rec.headers({ statusCode: 200 });
+        for (let i = 0; i < 19; i++) {
+            rec.appendEvent({ choices: [{ delta: { content: 'x' }, finish_reason: null }] });
+        }
+        rec.appendEvent({ choices: [{ delta: {}, finish_reason: 'stop' }], usage: { prompt_tokens: 9, completion_tokens: 17 } });
+        getDatabase()
+            .prepare('UPDATE requests SET timestamp = ? WHERE request_id = ? AND session_id = ?')
+            .run(new Date(Date.now() - 6 * 60000).toISOString(), meta.localRequestId, meta.sessionId);
+        const { completed, interrupted } = interruptStaleRequestsOnStartup();
+        expect(completed).toBe(1);
+        expect(interrupted).toBe(0);
+        const row = getRequestRow(meta.localRequestId, meta.sessionId);
+        expect(row.completed_at).toBeTruthy();
+        expect(row.closed_at).toBeNull();
+        expect(row.input_tokens).toBe(9);
+        expect(row.output_tokens).toBe(17);
+    });
+    it('interrupt() also backfills recoverable token columns', async () => {
+        const meta = makeMeta('interrupttokens');
+        const rec = createRequestRecorder(meta);
+        await rec.pending();
+        rec.appendEvent({
+            type: 'message_start',
+            usage: { input_tokens: 20, cache_read_input_tokens: 4, cache_creation_input_tokens: 1 }
+        });
+        for (let i = 0; i < 20; i++) {
+            rec.appendEvent({ type: 'content_block_delta', seq: i });
+        }
+        rec.appendEvent({ type: 'message_delta', usage: { output_tokens: 7 } });
+        pushMock.mockClear();
+        rec.interrupt({ statusCode: 200, error: 'stream interrupted: socket hang up' });
+        const row = getRequestRow(meta.localRequestId, meta.sessionId);
+        expect(row.closed_at).toBeTruthy();
+        expect(row.error).toBe('stream interrupted: socket hang up');
+        expect(row.input_tokens).toBe(20);
+        expect(row.output_tokens).toBe(7);
+        expect(row.cache_read_tokens).toBe(4);
+        expect(row.cache_creation_tokens).toBe(1);
+        const completedCalls = pushMock.mock.calls.filter(c => c[1] === 'completed');
+        expect(completedCalls[0][0].usage).toEqual(expect.objectContaining({ output_tokens: 7 }));
+    });
+    it('repairClosedRequests recovers closed complete rows, fills tokens, and is idempotent', async () => {
+        // 完整但被旧逻辑误标中断的行：message_stop 已入库，token 全 NULL
+        const completeMeta = makeMeta('repaircomplete');
+        const completeRec = createRequestRecorder(completeMeta);
+        await completeRec.pending();
+        completeRec.appendEvent({
+            type: 'message_start',
+            usage: { input_tokens: 15, cache_read_input_tokens: 2, cache_creation_input_tokens: 1 }
+        });
+        for (let i = 0; i < 20; i++) {
+            completeRec.appendEvent({ type: 'content_block_delta', seq: i });
+        }
+        completeRec.appendEvent({ type: 'message_delta', usage: { output_tokens: 6 } });
+        completeRec.appendEvent({ type: 'message_stop' });
+        completeRec.interrupt({ statusCode: 200, error: 'interrupted: proxy restarted' });
+        // 模拟旧版本中断行：清空 token 列（旧 interrupt 不回填 usage）
+        getDatabase()
+            .prepare(`UPDATE requests SET
+        input_tokens = NULL, output_tokens = NULL,
+        cache_read_tokens = NULL, cache_creation_tokens = NULL
+        WHERE request_id = ? AND session_id = ?`)
+            .run(completeMeta.localRequestId, completeMeta.sessionId);
+        // 真正中断的行：无 message_stop，但 usage 可恢复
+        const brokenMeta = makeMeta('repairbroken');
+        const brokenRec = createRequestRecorder(brokenMeta);
+        await brokenRec.pending();
+        brokenRec.appendEvent({
+            type: 'message_start',
+            usage: { input_tokens: 8, cache_read_input_tokens: 1 }
+        });
+        for (let i = 0; i < 20; i++) {
+            brokenRec.appendEvent({ type: 'content_block_delta', seq: i });
+        }
+        brokenRec.appendEvent({ type: 'message_delta', usage: { output_tokens: 3 } });
+        brokenRec.interrupt({ statusCode: 200, error: 'interrupted: proxy restarted' });
+        // 模拟旧版本中断行：清空 token 列
+        getDatabase()
+            .prepare(`UPDATE requests SET
+        input_tokens = NULL, output_tokens = NULL,
+        cache_read_tokens = NULL, cache_creation_tokens = NULL
+        WHERE request_id = ? AND session_id = ?`)
+            .run(brokenMeta.localRequestId, brokenMeta.sessionId);
+        const first = repairClosedRequests();
+        expect(first.recovered).toBe(1);
+        expect(first.tokensFilled).toBe(2);
+        const recoveredRow = getRequestRow(completeMeta.localRequestId, completeMeta.sessionId);
+        expect(recoveredRow.closed_at).toBeNull();
+        expect(recoveredRow.error).toBeNull();
+        expect(recoveredRow.completed_at).toBeTruthy();
+        expect(recoveredRow.input_tokens).toBe(15);
+        expect(recoveredRow.output_tokens).toBe(6);
+        const brokenRow = getRequestRow(brokenMeta.localRequestId, brokenMeta.sessionId);
+        expect(brokenRow.closed_at).toBeTruthy();
+        expect(brokenRow.input_tokens).toBe(8);
+        expect(brokenRow.output_tokens).toBe(3);
+        // 幂等：第二次不产生任何变更，行状态保持
+        const second = repairClosedRequests();
+        expect(second).toEqual({ recovered: 0, tokensFilled: 0 });
+        const rerunRecovered = getRequestRow(completeMeta.localRequestId, completeMeta.sessionId);
+        expect(rerunRecovered.completed_at).toBe(recoveredRow.completed_at);
+        const rerunBroken = getRequestRow(brokenMeta.localRequestId, brokenMeta.sessionId);
+        expect(rerunBroken.closed_at).toBe(brokenRow.closed_at);
+    });
 });

package/dist/utils/__tests__/stats-aggregator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/__tests__/stats-aggregator.test.js

@@ -0,0 +1,114 @@
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import path from 'path';
+import { configureDbPath, initDatabase, closeDatabase, getDatabase } from '../db.js';
+import { aggregateStats, getStatsData, getTodayStats } from '../stats-aggregator.js';
+let counter = 0;
+// 直接往 requests 表插行，绕过 request-writer，聚焦聚合口径
+function insertRequest(opts) {
+    counter += 1;
+    getDatabase()
+        .prepare(`
+      INSERT INTO requests (
+        request_id, session_id, timestamp, method, path, status_code, response_time,
+        model, input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, closed_at
+      ) VALUES (?, ?, ?, 'POST', '/v1/messages', 200, 100, ?, ?, ?, ?, ?, ?)
+    `)
+        .run(`req_${counter}`, `sess_${counter}`, opts.timestamp, opts.model ?? null, opts.inputTokens ?? null, opts.outputTokens ?? null, opts.cacheReadTokens ?? null, opts.cacheCreationTokens ?? null, opts.closedAt ?? null);
+}
+function hourKeyOf(iso) {
+    const d = new Date(iso);
+    return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, '0')}-${String(d.getUTCDate()).padStart(2, '0')}-${String(d.getUTCHours()).padStart(2, '0')}`;
+}
+describe('stats-aggregator', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = mkdtempSync(path.join(tmpdir(), 'ccm-stats-'));
+        configureDbPath(path.join(tempDir, 'test.db'));
+        initDatabase();
+    });
+    afterEach(() => {
+        closeDatabase();
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('P0: requests 源行删除后重算，冻结的 hourly 快照同步消失', () => {
+        const ts = new Date(Date.now() - 2 * 3600000).toISOString();
+        const key = hourKeyOf(ts);
+        insertRequest({ timestamp: ts, inputTokens: 100, outputTokens: 20 });
+        aggregateStats();
+        let stats = getStatsData();
+        expect(stats.hourly[key]).toBeTruthy();
+        expect(stats.hourly[key].input_tokens).toBe(100);
+        expect(stats.hourly[key].request_count).toBe(1);
+        // 模拟 cleanOldRequestsDB 把源行删掉
+        getDatabase().prepare('DELETE FROM requests').run();
+        aggregateStats();
+        stats = getStatsData();
+        expect(stats.hourly[key]).toBeUndefined();
+    });
+    it('P2: closed_at 非空的中断行仍计入 aggregateStats 与 getTodayStats', () => {
+        const ts = new Date().toISOString();
+        const key = hourKeyOf(ts);
+        insertRequest({
+            timestamp: ts,
+            inputTokens: 100,
+            outputTokens: 50,
+            cacheReadTokens: 10,
+            cacheCreationTokens: 3,
+            closedAt: new Date().toISOString(),
+            model: 'claude-interrupted'
+        });
+        aggregateStats();
+        const entry = getStatsData().hourly[key];
+        expect(entry).toBeTruthy();
+        expect(entry.input_tokens).toBe(100);
+        expect(entry.output_tokens).toBe(50);
+        expect(entry.cache_read_tokens).toBe(10);
+        expect(entry.cache_creation_tokens).toBe(3);
+        expect(entry.request_count).toBe(1);
+        const since = new Date(Date.now() - 3600000).toISOString();
+        const today = getTodayStats(since);
+        expect(today.input_tokens).toBe(100);
+        expect(today.output_tokens).toBe(50);
+        expect(today.cache_read_tokens).toBe(10);
+        expect(today.request_count).toBe(1);
+        expect(today.models['claude-interrupted']).toBe(1);
+    });
+    it('P1: aggregateStats(1) 只保留 1 天窗口，无参仍为 30 天窗口', () => {
+        const nowIso = new Date().toISOString();
+        const oldIso = new Date(Date.now() - 2 * 86400000).toISOString();
+        const nowKey = hourKeyOf(nowIso);
+        const oldKey = hourKeyOf(oldIso);
+        insertRequest({ timestamp: nowIso, inputTokens: 1 });
+        insertRequest({ timestamp: oldIso, inputTokens: 2 });
+        aggregateStats(1);
+        let stats = getStatsData();
+        expect(stats.hourly[nowKey]).toBeTruthy();
+        expect(stats.hourly[oldKey]).toBeUndefined();
+        aggregateStats();
+        stats = getStatsData();
+        expect(stats.hourly[nowKey]).toBeTruthy();
+        expect(stats.hourly[oldKey]).toBeTruthy();
+    });
+    describe('P1b: aggregateStats 的 windowDays 分支（截断与回退）', () => {
+        // 31 天前落在 30 天窗口外、40 天窗口内：保留它意味着窗口被放宽到 40，
+        // 删除它才是「截断/回退为 30」；2 天前始终在窗口内。
+        it.each([
+            [40, '超过 30 截断为 30'],
+            [0, '0 回退默认 30'],
+            [-3, '负数回退默认 30'],
+            [1.5, '非整数回退默认 30']
+        ])('maxDays = %s（%s）：2 天前保留，31 天前删除', (maxDays, _desc) => {
+            const recentIso = new Date(Date.now() - 2 * 86400000).toISOString();
+            const oldIso = new Date(Date.now() - 31 * 86400000).toISOString();
+            const recentKey = hourKeyOf(recentIso);
+            const oldKey = hourKeyOf(oldIso);
+            insertRequest({ timestamp: recentIso, inputTokens: 2 });
+            insertRequest({ timestamp: oldIso, inputTokens: 31 });
+            aggregateStats(maxDays);
+            const stats = getStatsData();
+            expect(stats.hourly[recentKey]).toBeTruthy();
+            expect(stats.hourly[oldKey]).toBeUndefined();
+        });
+    });
+});

package/dist/utils/db-maintenance.d.ts

@@ -0,0 +1,8 @@
+import Database from 'better-sqlite3';
+export interface VacuumResult {
+    autoVacuumBefore: number;
+    pagesBefore: number;
+    pagesAfter: number;
+    pageSize: number;
+}
+export declare function vacuumDatabase(db: Database.Database): VacuumResult;

package/dist/utils/db-maintenance.js

@@ -0,0 +1,18 @@
+// 回收空闲页。auto_vacuum 不是 INCREMENTAL 时，pragma 修改只对新建库生效，
+// 已有库必须先 VACUUM 全库重写才能让 pragma 生效；之后例行调用走
+// incremental_vacuum，只还页不重写，代价低。
+export function vacuumDatabase(db) {
+    const autoVacuumBefore = db.pragma('auto_vacuum', { simple: true }) ?? 0;
+    const pagesBefore = db.pragma('page_count', { simple: true });
+    const pageSize = db.pragma('page_size', { simple: true });
+    if (autoVacuumBefore !== 2) {
+        db.pragma('auto_vacuum = INCREMENTAL');
+        // 首次：全库重写，pragma 在重写后生效
+        db.exec('VACUUM');
+    }
+    else {
+        db.pragma('incremental_vacuum');
+    }
+    const pagesAfter = db.pragma('page_count', { simple: true });
+    return { autoVacuumBefore, pagesBefore, pagesAfter, pageSize };
+}

package/dist/utils/db.d.ts

@@ -11,5 +11,6 @@ export declare function applySchemaV8(db: Database.Database): void;
 export declare function applySchemaV9(db: Database.Database): void;
 export declare function applySchemaV10(db: Database.Database): void;
 export declare function applySchemaV11(db: Database.Database): void;
+export declare function applySchemaV12(db: Database.Database): void;
 export declare function closeDatabase(): void;
 export declare function getDatabase(): Database.Database;

package/dist/utils/db.js

@@ -76,6 +76,10 @@ export function initDatabase() {
         applySchemaV11(db);
         db.prepare('INSERT OR REPLACE INTO schema_version (version) VALUES (11)').run();
     }
+    if (currentVersion < 12) {
+        applySchemaV12(db);
+        db.prepare('INSERT OR REPLACE INTO schema_version (version) VALUES (12)').run();
+    }
     return db;
 }
 export function applySchemaV2(db) {
@@ -304,6 +308,64 @@ export function applySchemaV11(db) {
       ON learn_tasks(slug) WHERE status = 'running'
   `);
 }
+export function applySchemaV12(db) {
+    // response_events 历史上存在 (request_id, session_id, event_index) 三元组重复行
+    // （request_id 计数器重启复用所致）和 requests 表无对应行的孤儿事件；清理后加
+    // 唯一索引硬守。生产库约 800 万行：先一次性把待删行号收集进临时表，再按主键
+    // 分批删除（每批 5000 行、独立事务），避免单个巨型事务长时间锁库。
+    //
+    // 注意：不能用 `GROUP BY ... HAVING COUNT(*) > 1 AND id != MIN(id)` 直接选行——
+    // SQLite 裸列 id 在该计划下取 MIN(id) 所在行，HAVING 恒假，实测删除 0 行。
+    const batchSize = 5000;
+    db.exec('DROP TABLE IF EXISTS temp.ids_to_purge');
+    db.exec('CREATE TEMP TABLE ids_to_purge (id INTEGER PRIMARY KEY)');
+    // a) 去重：每组 (request_id, session_id, event_index) 保留 MIN(id)，其余入临时表
+    db.prepare(`
+    INSERT INTO ids_to_purge
+    SELECT id FROM response_events
+    WHERE id NOT IN (
+      SELECT MIN(id) FROM response_events
+      GROUP BY request_id, session_id, event_index
+    )
+  `).run();
+    purgeResponseEventsBatched(db, batchSize);
+    // b) 孤儿事件：requests 表中无对应 request_id
+    db.prepare(`
+    INSERT INTO ids_to_purge
+    SELECT re.id FROM response_events re
+    WHERE NOT EXISTS (
+      SELECT 1 FROM requests r WHERE r.request_id = re.request_id
+    )
+  `).run();
+    purgeResponseEventsBatched(db, batchSize);
+    db.exec('DROP TABLE IF EXISTS temp.ids_to_purge');
+    // c) 唯一索引（IF NOT EXISTS，幂等）
+    db.exec(`
+    CREATE UNIQUE INDEX IF NOT EXISTS uq_response_events
+      ON response_events(request_id, session_id, event_index)
+  `);
+}
+// 按临时表 ids_to_purge 收集的行号分批删除 response_events；每批同时剪除临时表中
+// 已处理的行号，整批包在一个事务里，循环直到没有可删行。
+function purgeResponseEventsBatched(db, batchSize) {
+    const deleteEvents = db.prepare(`
+    DELETE FROM response_events
+    WHERE id IN (SELECT id FROM ids_to_purge ORDER BY id LIMIT ?)
+  `);
+    const pruneTemp = db.prepare(`
+    DELETE FROM ids_to_purge
+    WHERE id IN (SELECT id FROM ids_to_purge ORDER BY id LIMIT ?)
+  `);
+    const runBatch = db.transaction(() => {
+        const info = deleteEvents.run(batchSize);
+        pruneTemp.run(batchSize);
+        return info.changes;
+    });
+    while (true) {
+        if (runBatch() === 0)
+            break;
+    }
+}
 export function closeDatabase() {
     if (db) {
         db.close();

package/dist/utils/request-writer.d.ts

@@ -37,6 +37,7 @@ export interface RequestSummary {
     userAgent?: string;
     usage?: TokenUsage;
     closedAt?: string;
+    error?: string;
 }
 export interface RequestRecorder {
     pending(): Promise<void>;
@@ -83,6 +84,20 @@ interface LoadedRequest {
         error?: string;
     };
 }
+/**
+ * 判断事件集合是否构成一条完整返回的流。
+ * Claude：出现 type === 'message_stop'。
+ * OpenAI 兼容：chunk 内 choices[0].finish_reason 非空
+ * （[DONE] 不入库，不能作为 DB 判定依据）。
+ */
+export declare function isStreamCompleteEvents(events: any[] | undefined): boolean;
+/**
+ * 从事件集合按字段合并重建 usage，不做整体覆盖。
+ * Claude：message_start.usage（input_tokens / cache_*）为底；
+ * message_delta.usage 的字段优先（output_tokens 为主，cache 字段也合入）。
+ * OpenAI：取带 .usage 的 chunk（prompt_tokens/completion_tokens）。
+ */
+export declare function reconstructUsageFromEvents(events: any[] | undefined): TokenUsage | undefined;
 export declare function createRequestRecorder(meta: RecordedRequest): RequestRecorder;
 export declare function recordIteration(meta: RecordedRequest & {
     response: {
@@ -97,7 +112,14 @@ export declare function listRequestDB(limit?: number, before?: string): Promise<
     hasMore: boolean;
 }>;
 export declare function cleanOldRequestsDB(daysToKeep?: number): Promise<void>;
-export declare function interruptStaleRequestsOnStartup(maxAgeMs?: number): number;
+export declare function interruptStaleRequestsOnStartup(maxAgeMs?: number): {
+    completed: number;
+    interrupted: number;
+};
+export declare function repairClosedRequests(): {
+    recovered: number;
+    tokensFilled: number;
+};
 export declare function loadSessionHistory(sessionId: string): {
     messages: any[];
     system?: any;