@oar-sh/oar 0.9.16 → 0.9.17

package/server/deepseek-worker/deepseek-session-worker.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// DeepSeek session worker: the Claude session worker with its CLI pointed at
+// DeepSeek's Anthropic-compatible endpoint (deepseek-claude-backend.mjs). The
+// relay's launch puts the key in DEEPSEEK_API_KEY (through the owner-only
+// secret file under tmux) and names the worker's own Claude Code state
+// directory in DEEPSEEK_CLAUDE_CONFIG_DIR.
+import fs from 'node:fs';
+
+import { installWorkerLogFile, installWorkerLogRedaction } from '../../shared/worker-runtime/worker-log-file.mjs';
+import { runClaudeSessionWorker } from '../claude-worker/claude-session-worker-main.mjs';
+import { createDeepSeekClaudeBackend } from './deepseek-claude-backend.mjs';
+
+installWorkerLogFile();
+// The key never shows in this worker's console or log, whatever the CLI or
+// the agent prints (installed after the log file, so its copy is redacted too).
+installWorkerLogRedaction({ secrets: [process.env.DEEPSEEK_API_KEY] });
+
+const backend = createDeepSeekClaudeBackend({ env: process.env });
+
+// The worker reads the CLI's state too (the transcript a resume needs, the
+// workflow files): it has to look where its CLI writes, never in the host's
+// ~/.claude. The directory holds sessions, so only this user may open it.
+if (backend.configDir) {
+  fs.mkdirSync(backend.configDir, { recursive: true, mode: 0o700 });
+  try { fs.chmodSync(backend.configDir, 0o700); } catch {}
+  process.env.CLAUDE_CONFIG_DIR = backend.configDir;
+}
+
+runClaudeSessionWorker({
+  logTag: 'deepseek-worker',
+  workerName: 'deepseek-session-worker',
+  defaultModel: String(process.env.DEEPSEEK_RELAY_MODEL || '').trim() || backend.defaultModel,
+  backend,
+}).catch((error) => {
+  console.error('deepseek-session-worker fatal:', error?.stack || error?.message || error);
+  process.exit(1);
+});

package/server/migrations/0024-deepseek-usage-totals.mjs

@@ -0,0 +1,151 @@
+'use strict';
+
+/**
+ * Migration: DeepSeek usage totals (services/plan-usage-service.mjs, the
+ * DeepSeek card in Check Usage).
+ *
+ * `deepseek_usage_totals`: one row per DeepSeek model this relay's DeepSeek
+ * turns used, summed over every turn the workers reported
+ * (POST /api/deepseek-plan-usage). A row only ever grows.
+ *
+ * - `model`: the model's id as the CLI reported it, without Claude Code's
+ *   `[1m]` suffix, lower case.
+ * - `hit_tokens`, `miss_tokens`, `output_tokens`: input DeepSeek served from
+ *   its cache, input it did not, and output.
+ * - `turn_count`: the reports that named the model.
+ * - `cost_usd`, `cost_cny`: the estimate from shared/deepseek-pricing.mjs at
+ *   the price of each turn's own time (peak or off-peak); NULL while no turn
+ *   of the model could be priced (a model the price table does not know).
+ * - `first_seen_at`, `last_seen_at`: the earliest and latest turn time.
+ *
+ * `deepseek_usage_checkpoints`: what a worker last reported per
+ * (conversation, Claude Code session, model). A worker reports the CLI's
+ * running totals, and a CLI resumed on a session starts from that session's
+ * earlier totals, so the relay books only what a report adds to the totals
+ * last reported for the session: a restarted worker or a resumed CLI books
+ * nothing twice, and a new session starts from zero. A total below the
+ * checkpoint is a CLI counting from zero again: that report is booked in
+ * full and the checkpoint starts over from it.
+ *
+ * - `conversation_id`, `native_session_id` (the CLI's session id), `model`.
+ * - `hit_tokens`, `miss_tokens`, `output_tokens`: the totals last reported.
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0024-deepseek-usage-totals.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+export const DEEPSEEK_USAGE_TOTALS_TABLE = 'deepseek_usage_totals';
+export const DEEPSEEK_USAGE_CHECKPOINTS_TABLE = 'deepseek_usage_checkpoints';
+
+export const DEEPSEEK_USAGE_TOTALS_COLUMNS = Object.freeze([
+  'model',
+  'hit_tokens',
+  'miss_tokens',
+  'output_tokens',
+  'turn_count',
+  'cost_usd',
+  'cost_cny',
+  'first_seen_at',
+  'last_seen_at',
+  'updated_at',
+]);
+
+export const DEEPSEEK_USAGE_CHECKPOINT_COLUMNS = Object.freeze([
+  'conversation_id',
+  'native_session_id',
+  'model',
+  'hit_tokens',
+  'miss_tokens',
+  'output_tokens',
+  'updated_at',
+]);
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+/** What keeps the service from using the table: '' when nothing does. */
+export function deepseekUsageTotalsTableProblem(db) {
+  for (const [table, columns] of [
+    [DEEPSEEK_USAGE_TOTALS_TABLE, DEEPSEEK_USAGE_TOTALS_COLUMNS],
+    [DEEPSEEK_USAGE_CHECKPOINTS_TABLE, DEEPSEEK_USAGE_CHECKPOINT_COLUMNS],
+  ]) {
+    if (!tableExists(db, table)) return `no ${table} table`;
+    const present = new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((column) => column.name));
+    const missing = columns.filter((name) => !present.has(name));
+    if (missing.length) return `${table} lacks ${missing.join(', ')}`;
+  }
+  return '';
+}
+
+export function migrateDeepSeekUsageTotals(db) {
+  let tablesAdded = 0;
+  if (!tableExists(db, DEEPSEEK_USAGE_CHECKPOINTS_TABLE)) {
+    db.exec(`
+      CREATE TABLE ${DEEPSEEK_USAGE_CHECKPOINTS_TABLE} (
+        conversation_id    TEXT NOT NULL,
+        native_session_id  TEXT NOT NULL,
+        model              TEXT NOT NULL,
+        hit_tokens         INTEGER NOT NULL DEFAULT 0,
+        miss_tokens        INTEGER NOT NULL DEFAULT 0,
+        output_tokens      INTEGER NOT NULL DEFAULT 0,
+        updated_at         TEXT NOT NULL,
+        PRIMARY KEY (conversation_id, native_session_id, model)
+      )
+    `);
+    tablesAdded += 1;
+  }
+  if (tableExists(db, DEEPSEEK_USAGE_TOTALS_TABLE)) return { applied: tablesAdded > 0, tablesAdded };
+  db.exec(`
+    CREATE TABLE ${DEEPSEEK_USAGE_TOTALS_TABLE} (
+      model          TEXT PRIMARY KEY,
+      hit_tokens     INTEGER NOT NULL DEFAULT 0,
+      miss_tokens    INTEGER NOT NULL DEFAULT 0,
+      output_tokens  INTEGER NOT NULL DEFAULT 0,
+      turn_count     INTEGER NOT NULL DEFAULT 0,
+      cost_usd       REAL,
+      cost_cny       REAL,
+      first_seen_at  TEXT NOT NULL,
+      last_seen_at   TEXT NOT NULL,
+      updated_at     TEXT NOT NULL
+    )
+  `);
+  tablesAdded += 1;
+  return { applied: true, tablesAdded };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateDeepSeekUsageTotals(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0024 on ${dbPath}`);
+    console.log(result.applied ? `  deepseek usage totals: tables added ${result.tablesAdded}` : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0024 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0025-deepseek-usage-requests-daily.mjs

@@ -0,0 +1,179 @@
+'use strict';
+
+/**
+ * Migration: DeepSeek web search and fetch counts, the daily spend, and the
+ * balance reference (services/plan-usage-service.mjs, the DeepSeek card in
+ * Check Usage). Builds on 0024.
+ *
+ * `deepseek_usage_totals` gains four columns:
+ * - `search_requests`, `fetch_requests`: Claude Code's web searches and
+ *   fetches on DeepSeek's Search API, counted from the first turn.
+ * - `tools_cost_usd`, `tools_cost_cny`: what those cost, from
+ *   shared/deepseek-pricing.mjs: 0 before DeepSeek started charging for
+ *   them (2026-10-31 16:00 UTC), flat per request after. `cost_usd` and
+ *   `cost_cny` stay the token estimate alone.
+ *
+ * `deepseek_usage_days`: the same sums per UTC day and model, booked in the
+ * same transaction as the totals, for the card's daily spend chart and this
+ * month's spend against the budget. History starts with this migration.
+ * - `day`: `YYYY-MM-DD` in UTC, from the turn's time.
+ * - the token, request, turn and cost columns as in the totals.
+ *
+ * `deepseek_balance_reference`: per currency, the balance after the latest
+ * top-up as the card's meter reads it (balance left of the last top-up).
+ * - `reference_total`: the balance after the latest rise; before the first
+ *   rise is seen, the highest balance seen.
+ * - `last_total`: the balance last read, to see the next rise.
+ * - `reference_at`: when the reference was set.
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0025-deepseek-usage-requests-daily.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+import { DEEPSEEK_USAGE_TOTALS_TABLE, migrateDeepSeekUsageTotals } from './0024-deepseek-usage-totals.mjs';
+
+export const DEEPSEEK_USAGE_DAYS_TABLE = 'deepseek_usage_days';
+export const DEEPSEEK_BALANCE_REFERENCE_TABLE = 'deepseek_balance_reference';
+
+// Added to deepseek_usage_totals, with their DDL.
+export const DEEPSEEK_USAGE_REQUEST_COLUMNS = Object.freeze([
+  ['search_requests', 'INTEGER NOT NULL DEFAULT 0'],
+  ['fetch_requests', 'INTEGER NOT NULL DEFAULT 0'],
+  ['tools_cost_usd', 'REAL NOT NULL DEFAULT 0'],
+  ['tools_cost_cny', 'REAL NOT NULL DEFAULT 0'],
+]);
+
+export const DEEPSEEK_USAGE_DAYS_COLUMNS = Object.freeze([
+  'day',
+  'model',
+  'hit_tokens',
+  'miss_tokens',
+  'output_tokens',
+  'search_requests',
+  'fetch_requests',
+  'turn_count',
+  'cost_usd',
+  'cost_cny',
+  'tools_cost_usd',
+  'tools_cost_cny',
+  'updated_at',
+]);
+
+export const DEEPSEEK_BALANCE_REFERENCE_COLUMNS = Object.freeze([
+  'currency',
+  'reference_total',
+  'last_total',
+  'reference_at',
+  'updated_at',
+]);
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+function columnNames(db, table) {
+  return new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((column) => column.name));
+}
+
+/** What keeps the service from using the columns and tables: '' when nothing does. */
+export function deepseekUsageRequestsDailyProblem(db) {
+  if (!tableExists(db, DEEPSEEK_USAGE_TOTALS_TABLE)) return `no ${DEEPSEEK_USAGE_TOTALS_TABLE} table`;
+  const totals = columnNames(db, DEEPSEEK_USAGE_TOTALS_TABLE);
+  const missingColumns = DEEPSEEK_USAGE_REQUEST_COLUMNS.map(([name]) => name).filter((name) => !totals.has(name));
+  if (missingColumns.length) return `${DEEPSEEK_USAGE_TOTALS_TABLE} lacks ${missingColumns.join(', ')}`;
+  for (const [table, columns] of [
+    [DEEPSEEK_USAGE_DAYS_TABLE, DEEPSEEK_USAGE_DAYS_COLUMNS],
+    [DEEPSEEK_BALANCE_REFERENCE_TABLE, DEEPSEEK_BALANCE_REFERENCE_COLUMNS],
+  ]) {
+    if (!tableExists(db, table)) return `no ${table} table`;
+    const present = columnNames(db, table);
+    const missing = columns.filter((name) => !present.has(name));
+    if (missing.length) return `${table} lacks ${missing.join(', ')}`;
+  }
+  return '';
+}
+
+export function migrateDeepSeekUsageRequestsDaily(db) {
+  // The columns go on 0024's table: a database that skipped 0024 gets it first.
+  migrateDeepSeekUsageTotals(db);
+  let columnsAdded = 0;
+  let tablesAdded = 0;
+  const present = columnNames(db, DEEPSEEK_USAGE_TOTALS_TABLE);
+  for (const [name, ddl] of DEEPSEEK_USAGE_REQUEST_COLUMNS) {
+    if (present.has(name)) continue;
+    db.exec(`ALTER TABLE ${DEEPSEEK_USAGE_TOTALS_TABLE} ADD COLUMN ${name} ${ddl}`);
+    columnsAdded += 1;
+  }
+  if (!tableExists(db, DEEPSEEK_USAGE_DAYS_TABLE)) {
+    db.exec(`
+      CREATE TABLE ${DEEPSEEK_USAGE_DAYS_TABLE} (
+        day              TEXT NOT NULL,
+        model            TEXT NOT NULL,
+        hit_tokens       INTEGER NOT NULL DEFAULT 0,
+        miss_tokens      INTEGER NOT NULL DEFAULT 0,
+        output_tokens    INTEGER NOT NULL DEFAULT 0,
+        search_requests  INTEGER NOT NULL DEFAULT 0,
+        fetch_requests   INTEGER NOT NULL DEFAULT 0,
+        turn_count       INTEGER NOT NULL DEFAULT 0,
+        cost_usd         REAL,
+        cost_cny         REAL,
+        tools_cost_usd   REAL NOT NULL DEFAULT 0,
+        tools_cost_cny   REAL NOT NULL DEFAULT 0,
+        updated_at       TEXT NOT NULL,
+        PRIMARY KEY (day, model)
+      )
+    `);
+    tablesAdded += 1;
+  }
+  if (!tableExists(db, DEEPSEEK_BALANCE_REFERENCE_TABLE)) {
+    db.exec(`
+      CREATE TABLE ${DEEPSEEK_BALANCE_REFERENCE_TABLE} (
+        currency         TEXT PRIMARY KEY,
+        reference_total  REAL NOT NULL,
+        last_total       REAL NOT NULL,
+        reference_at     TEXT NOT NULL,
+        updated_at       TEXT NOT NULL
+      )
+    `);
+    tablesAdded += 1;
+  }
+  return { applied: columnsAdded + tablesAdded > 0, columnsAdded, tablesAdded };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateDeepSeekUsageRequestsDaily(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0025 on ${dbPath}`);
+    console.log(result.applied
+      ? `  deepseek usage requests and daily: columns added ${result.columnsAdded}, tables added ${result.tablesAdded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0025 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0026-deepseek-usage-served-models.mjs

@@ -0,0 +1,222 @@
+'use strict';
+
+/**
+ * Migration: DeepSeek usage rows booked under a Claude model name are folded
+ * into the DeepSeek model that served them (services/plan-usage-service.mjs,
+ * the DeepSeek card in Check Usage). Builds on 0024 and 0025.
+ *
+ * A DeepSeek chat runs Claude Code. Before the CLI's model aliases were pinned
+ * to the chat's model, a sub-agent asked for as "opus" went to DeepSeek as
+ * `claude-opus-5-5`, which DeepSeek's Anthropic-compatible endpoint serves
+ * with V4 Pro (and `claude-sonnet*` / `claude-haiku*` with Flash). Such
+ * turns were booked under the Claude name and, as shared/deepseek-pricing.mjs
+ * prices only DeepSeek's ids, without a price.
+ *
+ * For each of `deepseek_usage_totals`, `deepseek_usage_days` and
+ * `deepseek_usage_checkpoints`, every row whose model name
+ * shared/deepseek-models.mjs maps to a DeepSeek model (`deepseekServedModel`)
+ * is added to that model's row (created when there is none) and deleted:
+ * tokens, requests and turns are summed; `first_seen_at` / `last_seen_at`
+ * widen. The folded tokens are priced at the DeepSeek model's price for the
+ * row's last turn time (`last_seen_at` of a totals row, `updated_at` of a
+ * daily row: peak or off-peak by that time, as the rows keep no per-turn
+ * times), the folded requests at the request price for that time, and the
+ * amounts are added to the target's costs. A checkpoint is a CLI session's
+ * running total per model, so the Claude-named and the DeepSeek-named
+ * checkpoints of one session add up to what the session reports once its
+ * worker names the DeepSeek model.
+ *
+ * Idempotent: a database without such rows is left as it is. Safe to run on
+ * every boot.
+ *
+ * Usage: node server/migrations/0026-deepseek-usage-served-models.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import Database from 'better-sqlite3';
+
+import { DEEPSEEK_USAGE_CHECKPOINTS_TABLE, DEEPSEEK_USAGE_TOTALS_TABLE } from './0024-deepseek-usage-totals.mjs';
+import { DEEPSEEK_USAGE_DAYS_TABLE, migrateDeepSeekUsageRequestsDaily } from './0025-deepseek-usage-requests-daily.mjs';
+import { deepseekServedModel } from '../../shared/deepseek-models.mjs';
+import { estimateCost, estimateSearchCost } from '../../shared/deepseek-pricing.mjs';
+
+/** The DeepSeek model a stored model name is folded into, or '' when the row stays. */
+export function deepseekFoldedModel(model) {
+  const name = String(model ?? '').trim();
+  const served = deepseekServedModel(name);
+  return served && served !== name ? served : '';
+}
+
+function foldableRows(db, table) {
+  return db.prepare(`SELECT * FROM ${table}`).all()
+    .map((row) => ({ row, target: deepseekFoldedModel(row.model) }))
+    .filter((entry) => entry.target);
+}
+
+/** The rows the service would still read under a Claude name: '' when none. */
+export function deepseekUsageServedModelsProblem(db) {
+  for (const table of [DEEPSEEK_USAGE_TOTALS_TABLE, DEEPSEEK_USAGE_DAYS_TABLE, DEEPSEEK_USAGE_CHECKPOINTS_TABLE]) {
+    const count = foldableRows(db, table).length;
+    if (count) return `${table} holds ${count} row(s) under a model name DeepSeek served with another model`;
+  }
+  return '';
+}
+
+const count = (value) => Math.max(0, Math.round(Number(value) || 0));
+const money = (value) => (value === null || value === undefined ? null : Number(value));
+
+/** The folded row's token and request costs at the target model's price for `at`. */
+function repriced(target, row, at) {
+  const tokens = { hitTokens: count(row.hit_tokens), missTokens: count(row.miss_tokens), outputTokens: count(row.output_tokens) };
+  const tokenCount = tokens.hitTokens + tokens.missTokens + tokens.outputTokens;
+  const requests = { searchRequests: count(row.search_requests), fetchRequests: count(row.fetch_requests) };
+  return {
+    costUsd: tokenCount > 0 ? estimateCost({ model: target, at, currency: 'USD', ...tokens }) : null,
+    costCny: tokenCount > 0 ? estimateCost({ model: target, at, currency: 'CNY', ...tokens }) : null,
+    toolsCostUsd: estimateSearchCost({ at, currency: 'USD', ...requests }) || 0,
+    toolsCostCny: estimateSearchCost({ at, currency: 'CNY', ...requests }) || 0,
+  };
+}
+
+const sumCost = (current, added) => (added === null ? money(current) : (Number(current) || 0) + added);
+
+function foldTotals(db) {
+  const entries = foldableRows(db, DEEPSEEK_USAGE_TOTALS_TABLE);
+  const get = db.prepare(`SELECT * FROM ${DEEPSEEK_USAGE_TOTALS_TABLE} WHERE model = ?`);
+  const put = db.prepare(`
+    INSERT OR REPLACE INTO ${DEEPSEEK_USAGE_TOTALS_TABLE} (
+      model, hit_tokens, miss_tokens, output_tokens, search_requests, fetch_requests, turn_count,
+      cost_usd, cost_cny, tools_cost_usd, tools_cost_cny, first_seen_at, last_seen_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const remove = db.prepare(`DELETE FROM ${DEEPSEEK_USAGE_TOTALS_TABLE} WHERE model = ?`);
+  for (const { row, target } of entries) {
+    const into = get.get(target) || {};
+    const price = repriced(target, row, row.last_seen_at);
+    const earliest = [into.first_seen_at, row.first_seen_at].filter(Boolean).sort()[0];
+    const latest = [into.last_seen_at, row.last_seen_at].filter(Boolean).sort().at(-1);
+    put.run(
+      target,
+      count(into.hit_tokens) + count(row.hit_tokens),
+      count(into.miss_tokens) + count(row.miss_tokens),
+      count(into.output_tokens) + count(row.output_tokens),
+      count(into.search_requests) + count(row.search_requests),
+      count(into.fetch_requests) + count(row.fetch_requests),
+      count(into.turn_count) + count(row.turn_count),
+      sumCost(into.cost_usd ?? null, price.costUsd),
+      sumCost(into.cost_cny ?? null, price.costCny),
+      (Number(into.tools_cost_usd) || 0) + price.toolsCostUsd,
+      (Number(into.tools_cost_cny) || 0) + price.toolsCostCny,
+      earliest,
+      latest,
+      [into.updated_at, row.updated_at].filter(Boolean).sort().at(-1),
+    );
+    remove.run(row.model);
+  }
+  return entries.length;
+}
+
+function foldDays(db) {
+  const entries = foldableRows(db, DEEPSEEK_USAGE_DAYS_TABLE);
+  const get = db.prepare(`SELECT * FROM ${DEEPSEEK_USAGE_DAYS_TABLE} WHERE day = ? AND model = ?`);
+  const put = db.prepare(`
+    INSERT OR REPLACE INTO ${DEEPSEEK_USAGE_DAYS_TABLE} (
+      day, model, hit_tokens, miss_tokens, output_tokens, search_requests, fetch_requests, turn_count,
+      cost_usd, cost_cny, tools_cost_usd, tools_cost_cny, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const remove = db.prepare(`DELETE FROM ${DEEPSEEK_USAGE_DAYS_TABLE} WHERE day = ? AND model = ?`);
+  for (const { row, target } of entries) {
+    const into = get.get(row.day, target) || {};
+    const price = repriced(target, row, row.updated_at);
+    put.run(
+      row.day,
+      target,
+      count(into.hit_tokens) + count(row.hit_tokens),
+      count(into.miss_tokens) + count(row.miss_tokens),
+      count(into.output_tokens) + count(row.output_tokens),
+      count(into.search_requests) + count(row.search_requests),
+      count(into.fetch_requests) + count(row.fetch_requests),
+      count(into.turn_count) + count(row.turn_count),
+      sumCost(into.cost_usd ?? null, price.costUsd),
+      sumCost(into.cost_cny ?? null, price.costCny),
+      (Number(into.tools_cost_usd) || 0) + price.toolsCostUsd,
+      (Number(into.tools_cost_cny) || 0) + price.toolsCostCny,
+      [into.updated_at, row.updated_at].filter(Boolean).sort().at(-1),
+    );
+    remove.run(row.day, row.model);
+  }
+  return entries.length;
+}
+
+function foldCheckpoints(db) {
+  const entries = foldableRows(db, DEEPSEEK_USAGE_CHECKPOINTS_TABLE);
+  const get = db.prepare(`
+    SELECT * FROM ${DEEPSEEK_USAGE_CHECKPOINTS_TABLE} WHERE conversation_id = ? AND native_session_id = ? AND model = ?
+  `);
+  const put = db.prepare(`
+    INSERT OR REPLACE INTO ${DEEPSEEK_USAGE_CHECKPOINTS_TABLE} (
+      conversation_id, native_session_id, model, hit_tokens, miss_tokens, output_tokens, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?)
+  `);
+  const remove = db.prepare(`
+    DELETE FROM ${DEEPSEEK_USAGE_CHECKPOINTS_TABLE} WHERE conversation_id = ? AND native_session_id = ? AND model = ?
+  `);
+  for (const { row, target } of entries) {
+    const into = get.get(row.conversation_id, row.native_session_id, target) || {};
+    put.run(
+      row.conversation_id,
+      row.native_session_id,
+      target,
+      count(into.hit_tokens) + count(row.hit_tokens),
+      count(into.miss_tokens) + count(row.miss_tokens),
+      count(into.output_tokens) + count(row.output_tokens),
+      [into.updated_at, row.updated_at].filter(Boolean).sort().at(-1),
+    );
+    remove.run(row.conversation_id, row.native_session_id, row.model);
+  }
+  return entries.length;
+}
+
+export function migrateDeepSeekUsageServedModels(db) {
+  // The rows live in 0024's and 0025's tables: a database without them gets
+  // them first (and then has nothing to fold).
+  migrateDeepSeekUsageRequestsDaily(db);
+  const result = db.transaction(() => ({
+    totalsFolded: foldTotals(db),
+    daysFolded: foldDays(db),
+    checkpointsFolded: foldCheckpoints(db),
+  }))();
+  return { applied: result.totalsFolded + result.daysFolded + result.checkpointsFolded > 0, ...result };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateDeepSeekUsageServedModels(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0026 on ${dbPath}`);
+    console.log(result.applied
+      ? `  deepseek usage served models: totals folded ${result.totalsFolded}, days folded ${result.daysFolded}, checkpoints folded ${result.checkpointsFolded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0026 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0027-deepseek-usage-checkpoint-runs.mjs

@@ -0,0 +1,101 @@
+'use strict';
+
+/**
+ * Migration: the DeepSeek usage checkpoint learns which worker process its
+ * totals came from, and keeps the process's web search and fetch counts
+ * (services/plan-usage-service.mjs, the DeepSeek card in Check Usage).
+ * Builds on 0024.
+ *
+ * `deepseek_usage_checkpoints` gains three columns:
+ * - `run_id`: the id the worker gives each Claude Code process it spawns
+ *   (`runId` of a `POST /api/deepseek-plan-usage` body); '' for a report
+ *   from an older worker. Running totals only grow within one process, so
+ *   a report below the checkpoint under the SAME run id is a stale one (a
+ *   retried or reordered post) and books nothing, while one under a NEW run
+ *   id is a process that started counting over, booked in full. Before, any
+ *   drop was taken as a fresh run and booked in full: a reordered pair of
+ *   reports booked the turns before them twice.
+ * - `search_requests`, `fetch_requests`: the process's running counts of
+ *   web searches and fetches, which a worker with a run id reports in place
+ *   of the turn's counts, so a repeated post adds nothing.
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0027-deepseek-usage-checkpoint-runs.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+import { DEEPSEEK_USAGE_CHECKPOINTS_TABLE, migrateDeepSeekUsageTotals } from './0024-deepseek-usage-totals.mjs';
+
+// Added to deepseek_usage_checkpoints, with their DDL.
+export const DEEPSEEK_USAGE_CHECKPOINT_RUN_COLUMNS = Object.freeze([
+  ['run_id', "TEXT NOT NULL DEFAULT ''"],
+  ['search_requests', 'INTEGER NOT NULL DEFAULT 0'],
+  ['fetch_requests', 'INTEGER NOT NULL DEFAULT 0'],
+]);
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+function columnNames(db, table) {
+  return new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((column) => column.name));
+}
+
+/** What keeps the service from using the columns: '' when nothing does. */
+export function deepseekUsageCheckpointRunsProblem(db) {
+  if (!tableExists(db, DEEPSEEK_USAGE_CHECKPOINTS_TABLE)) return `no ${DEEPSEEK_USAGE_CHECKPOINTS_TABLE} table`;
+  const present = columnNames(db, DEEPSEEK_USAGE_CHECKPOINTS_TABLE);
+  const missing = DEEPSEEK_USAGE_CHECKPOINT_RUN_COLUMNS.map(([name]) => name).filter((name) => !present.has(name));
+  if (missing.length) return `${DEEPSEEK_USAGE_CHECKPOINTS_TABLE} lacks ${missing.join(', ')}`;
+  return '';
+}
+
+export function migrateDeepSeekUsageCheckpointRuns(db) {
+  // The columns go on 0024's table: a database that skipped 0024 gets it first.
+  migrateDeepSeekUsageTotals(db);
+  let columnsAdded = 0;
+  const present = columnNames(db, DEEPSEEK_USAGE_CHECKPOINTS_TABLE);
+  for (const [name, ddl] of DEEPSEEK_USAGE_CHECKPOINT_RUN_COLUMNS) {
+    if (present.has(name)) continue;
+    db.exec(`ALTER TABLE ${DEEPSEEK_USAGE_CHECKPOINTS_TABLE} ADD COLUMN ${name} ${ddl}`);
+    columnsAdded += 1;
+  }
+  return { applied: columnsAdded > 0, columnsAdded };
+}
+
+function defaultDbPath() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..', 'data', 'copilot.db');
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateDeepSeekUsageCheckpointRuns(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const dbPath = process.argv[2] ? path.resolve(process.argv[2]) : defaultDbPath();
+  try {
+    const result = migrate(dbPath);
+    console.log(`Migration 0027 on ${dbPath}`);
+    console.log(result.applied
+      ? `  deepseek usage checkpoint runs: columns added ${result.columnsAdded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0027 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}