@oar-sh/oar 0.9.15 → 0.9.17

package/server/migrations/0021-conversation-group-agent-marks.mjs

@@ -0,0 +1,77 @@
+'use strict';
+
+/**
+ * Migration: what an agent's update_session may do to a session group.
+ *
+ * - `conversation_groups.agent_made` is 1 for a group update_session made
+ *   (a name the relay did not have). Only such a group goes once an agent
+ *   takes its last member out.
+ * - `conversation_groups.kept_empty_at` is set when an agent took the last
+ *   member out of a group the owner made: the group stays (empty), the boot
+ *   repair and the sweep leave it alone, and agents can still name it. The
+ *   mark goes as soon as a member joins again.
+ *
+ * Additive and idempotent. Safe to run on every boot. Rolling back needs no
+ * data change: older code ignores both columns (its boot repair removes an
+ * empty group, as it always did).
+ *
+ * Usage: node server/migrations/0021-conversation-group-agent-marks.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+function tableExists(db, name) {
+  return !!db
+    .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`)
+    .get(name);
+}
+
+export function migrateConversationGroupAgentMarks(db) {
+  if (!tableExists(db, 'conversation_groups')) {
+    throw new Error('conversation_groups is missing (migration 0014 has not run)');
+  }
+  const present = new Set(db.prepare(`PRAGMA table_info(conversation_groups)`).all().map((column) => column.name));
+  let columnsAdded = 0;
+  if (!present.has('agent_made')) {
+    db.exec(`ALTER TABLE conversation_groups ADD COLUMN agent_made INTEGER`);
+    columnsAdded += 1;
+  }
+  if (!present.has('kept_empty_at')) {
+    db.exec(`ALTER TABLE conversation_groups ADD COLUMN kept_empty_at TEXT`);
+    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 migrateConversationGroupAgentMarks(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 0021 on ${dbPath}`);
+    console.log(result.applied
+      ? `  group agent marks: columns added ${result.columnsAdded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0021 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0022-relay-schedules.mjs

@@ -0,0 +1,142 @@
+'use strict';
+
+/**
+ * Migration: relay schedules (services/relay-schedule-service.mjs).
+ *
+ * `relay_schedules`: one row per schedule an agent set with remote_relay's
+ * `schedule`.
+ *
+ * - `conversation_id`: the session the prompt goes to.
+ * - `created_by_conversation_id`: the conversation whose agent set it (the
+ *   same one for a schedule of its own).
+ * - `at`: the first time asked for, or NULL; `every_minutes`: the interval
+ *   of a repeating schedule, or NULL; `once`: 1 when it ends after firing.
+ * - `next_fire_at`: when it fires next. Written in the same transaction as
+ *   the queue row a firing creates, so a restart neither loses a firing nor
+ *   repeats it; the timers are rebuilt from it at boot.
+ * - `last_fired_at`, `fired_count`, `last_message_id` (the message its last
+ *   firing queued: a repeat waits while that one is still pending),
+ *   `skipped_count`.
+ * - `origin_json`: the provenance its messages carry (the turn that set it,
+ *   with that turn's hops), so a schedule cannot reset the hop count;
+ *   NULL when a user's own turn set it for its own conversation.
+ * - `held_since`: a firing into another session waits for the user (the
+ *   agents' loop guard of the conversation that set it is used up).
+ * - `ended_at`, `end_reason`: unscheduled, fired (once), archived, deleted.
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0022-relay-schedules.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+export const RELAY_SCHEDULE_COLUMNS = Object.freeze([
+  'id',
+  'conversation_id',
+  'created_by_conversation_id',
+  'title',
+  'text',
+  'at',
+  'every_minutes',
+  'once',
+  'next_fire_at',
+  'last_fired_at',
+  'fired_count',
+  'skipped_count',
+  'last_message_id',
+  'created_at',
+  'ended_at',
+  'end_reason',
+  'origin_json',
+  'held_since',
+]);
+
+// Added after the table's first form: added by ALTER where it lacks them.
+const LATER_COLUMNS = Object.freeze([['origin_json', 'TEXT'], ['held_since', 'TEXT']]);
+
+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 relaySchedulesTableProblem(db) {
+  if (!tableExists(db, 'relay_schedules')) return 'no relay_schedules table';
+  const present = new Set(db.prepare(`PRAGMA table_info(relay_schedules)`).all().map((column) => column.name));
+  const missing = RELAY_SCHEDULE_COLUMNS.filter((name) => !present.has(name));
+  return missing.length ? `relay_schedules lacks ${missing.join(', ')}` : '';
+}
+
+export function migrateRelaySchedules(db) {
+  let tablesAdded = 0;
+  if (!tableExists(db, 'relay_schedules')) {
+    db.exec(`
+      CREATE TABLE relay_schedules (
+        id                          TEXT PRIMARY KEY,
+        conversation_id             TEXT NOT NULL,
+        created_by_conversation_id  TEXT NOT NULL,
+        title                       TEXT,
+        text                        TEXT NOT NULL,
+        at                          TEXT,
+        every_minutes               INTEGER CHECK (every_minutes IS NULL OR every_minutes > 0),
+        once                        INTEGER NOT NULL DEFAULT 1 CHECK (once IN (0, 1)),
+        next_fire_at                TEXT,
+        last_fired_at               TEXT,
+        fired_count                 INTEGER NOT NULL DEFAULT 0,
+        skipped_count               INTEGER NOT NULL DEFAULT 0,
+        last_message_id             TEXT,
+        created_at                  TEXT NOT NULL,
+        ended_at                    TEXT,
+        end_reason                  TEXT,
+        origin_json                 TEXT,
+        held_since                  TEXT,
+        CHECK (once = 1 OR every_minutes IS NOT NULL)
+      )
+    `);
+    tablesAdded += 1;
+  }
+  const present = new Set(db.prepare(`PRAGMA table_info(relay_schedules)`).all().map((column) => column.name));
+  let columnsAdded = 0;
+  for (const [name, type] of LATER_COLUMNS) {
+    if (present.has(name)) continue;
+    db.exec(`ALTER TABLE relay_schedules ADD COLUMN ${name} ${type}`);
+    columnsAdded += 1;
+  }
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_relay_schedules_active ON relay_schedules(ended_at, next_fire_at)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_relay_schedules_conversation ON relay_schedules(conversation_id, ended_at)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_relay_schedules_creator ON relay_schedules(created_by_conversation_id, ended_at)`);
+  return { applied: tablesAdded > 0 || columnsAdded > 0, tablesAdded, 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 migrateRelaySchedules(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 0022 on ${dbPath}`);
+    console.log(result.applied ? `  relay schedules: tables added ${result.tablesAdded}, columns added ${result.columnsAdded}` : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0022 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0023-relay-asks.mjs

@@ -0,0 +1,141 @@
+'use strict';
+
+/**
+ * Migration: questions that don't block (services/relay-ask-service.mjs).
+ *
+ * `relay_asks`: one row per question an agent asked the owner with
+ * remote_relay's `ask`. Not a `relay_questions` row: those belong to a turn
+ * (queue_id) that waits on them; an ask belongs to a session and blocks
+ * nothing.
+ *
+ * - `relay_id`: 'self' for an ask kept here (its session lives on this
+ *   relay); a paired relay's registry id for this relay's copy of an ask its
+ *   agent put on that relay (a mirror: `remote_id` is the ask's id there, and
+ *   this relay looks for the answer until it has it).
+ * - `conversation_id`: the session the ask is in (on that relay for a
+ *   mirror, `conversation_title` its title there).
+ * - `created_by`: the conversation here whose agent asked (NULL when a paired
+ *   relay's agent did; `creator_json` then names that relay and its
+ *   conversation, `{ relayId, relayName, conversationId, conversationTitle }`).
+ * - `question`, `options_json`, `recommendation`, `detail`, `urgency`
+ *   ('normal' | 'now'): as the agent wrote them, checked
+ *   (shared/relay-asks.mjs).
+ * - `status`: pending, answered, dismissed, withdrawn (by the agent that
+ *   asked), cancelled (its session was archived or deleted); `answer`,
+ *   `choice`, `answered_at`, `answered_via` (the relay whose Inbox it came
+ *   from, NULL for this relay's own UI).
+ * - `notified_at`: when the asking side was told the outcome (for a mirror:
+ *   when its creator here got question_answered).
+ *
+ * Additive and idempotent. Safe to run on every boot.
+ *
+ * Usage: node server/migrations/0023-relay-asks.mjs [path/to/copilot.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+
+export const RELAY_ASK_COLUMNS = Object.freeze([
+  'id',
+  'relay_id',
+  'remote_id',
+  'conversation_id',
+  'conversation_title',
+  'created_by',
+  'creator_json',
+  'question',
+  'options_json',
+  'recommendation',
+  'detail',
+  'urgency',
+  'status',
+  'answer',
+  'choice',
+  'answered_at',
+  'answered_via',
+  'notified_at',
+  'created_at',
+  '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 relayAsksTableProblem(db) {
+  if (!tableExists(db, 'relay_asks')) return 'no relay_asks table';
+  const present = new Set(db.prepare(`PRAGMA table_info(relay_asks)`).all().map((column) => column.name));
+  const missing = RELAY_ASK_COLUMNS.filter((name) => !present.has(name));
+  return missing.length ? `relay_asks lacks ${missing.join(', ')}` : '';
+}
+
+export function migrateRelayAsks(db) {
+  let tablesAdded = 0;
+  if (!tableExists(db, 'relay_asks')) {
+    db.exec(`
+      CREATE TABLE relay_asks (
+        id                  TEXT PRIMARY KEY,
+        relay_id            TEXT NOT NULL DEFAULT 'self',
+        remote_id           TEXT,
+        conversation_id     TEXT NOT NULL,
+        conversation_title  TEXT,
+        created_by          TEXT,
+        creator_json        TEXT,
+        question            TEXT NOT NULL,
+        options_json        TEXT,
+        recommendation      TEXT,
+        detail              TEXT,
+        urgency             TEXT NOT NULL DEFAULT 'normal' CHECK (urgency IN ('normal', 'now')),
+        status              TEXT NOT NULL DEFAULT 'pending'
+                            CHECK (status IN ('pending', 'answered', 'dismissed', 'withdrawn', 'cancelled')),
+        answer              TEXT,
+        choice              TEXT,
+        answered_at         TEXT,
+        answered_via        TEXT,
+        notified_at         TEXT,
+        created_at          TEXT NOT NULL,
+        updated_at          TEXT NOT NULL,
+        CHECK (relay_id = 'self' OR remote_id IS NOT NULL)
+      )
+    `);
+    tablesAdded += 1;
+  }
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_relay_asks_status ON relay_asks(relay_id, status, created_at)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_relay_asks_conversation ON relay_asks(conversation_id, status)`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_relay_asks_creator ON relay_asks(created_by, status)`);
+  db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_relay_asks_remote ON relay_asks(relay_id, remote_id) WHERE remote_id IS NOT NULL`);
+  return { applied: tablesAdded > 0, 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 migrateRelayAsks(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 0023 on ${dbPath}`);
+    console.log(result.applied ? `  relay asks: tables added ${result.tablesAdded}` : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0023 failed: ${err?.message || err}`);
+    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);
+  }
+}