@oar-sh/oar 0.9.19 → 0.9.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oar-sh/oar",
-  "version": "0.9.19",
+  "version": "0.9.20",
   "type": "module",
   "description": "OAR — Open Agent Relay: drive your local coding agents from any browser",
   "license": "MIT",
@@ -25,6 +25,7 @@
     "!server/README.md",
     "!server/data/",
     "!server/logs/",
+    "!server/backups/",
     "!server/config.json",
     "!server/uploads/",
     "server/uploads/README.md",
@@ -43,8 +44,9 @@
     "preinstall": "node server/services/package-data-rescue-preinstall.mjs",
     "start": "node server/server.js",
     "copilot:relay": "gh copilot -- --allow-all",
-    "test": "node --import ./scripts/node-test-keep-alive.mjs --test \"server/**/*.test.mjs\" \"shared/**/*.test.mjs\" \".github/extensions/web-relay/**/*.test.mjs\" \"scripts/**/*.test.mjs\"",
+    "test": "node --import ./scripts/node-test-keep-alive.mjs --import ./scripts/node-test-worktree-guard.mjs --test \"server/**/*.test.mjs\" \"shared/**/*.test.mjs\" \".github/extensions/web-relay/**/*.test.mjs\" \"scripts/**/*.test.mjs\"",
     "test:agents:smoke": "node --test \"tests/agents/**/*.test.mjs\"",
+    "test:packed-update": "node --test tests/packed-update/packed-update.test.mjs",
     "test:e2e": "node tests/run-e2e.mjs",
     "setup:git": "node scripts/setup-git.mjs",
     "land": "node scripts/land.mjs",

package/server/claude-cloud-worker/claude-cloud-event-normalizer.mjs

@@ -1,4 +1,5 @@
 import { capThought } from '../../shared/thought-cap.mjs';
+import { tokenUsageModel } from '../../shared/turn-token-usage.mjs';
 import {
   compactBoundaryActivityAction,
   displayToolName,
@@ -68,6 +69,57 @@ export function readCloudResult(payload) {
   };
 }
 
+/**
+ * A cloud session's running token totals per model, for the token booking
+ * (POST /api/turn-token-usage with `sessionTotals`; the relay books what
+ * they grew by): `[{ model, inputTokens, cacheWriteTokens, cacheReadTokens,
+ * outputTokens, costUsd, costSource, costUnknown }]` out of a result's
+ * `modelUsage`. A field the entry does not carry is null, not 0. The cache
+ * fields of the session read (`sessionTokens`, readCloudSessionUsage) cover
+ * the whole session, so they stand in only when the session ran one model;
+ * with more, a missing field stays null. Model ids drop the `[1m]` tier.
+ */
+export function cloudSessionTokenTotals(modelUsage, sessionTokens = null) {
+  if (!modelUsage || typeof modelUsage !== 'object' || Array.isArray(modelUsage)) return [];
+  const count = (value) => {
+    const n = finiteOrNull(value);
+    return n === null || n < 0 ? null : Math.trunc(n);
+  };
+  const totals = new Map();
+  for (const [name, entry] of Object.entries(modelUsage)) {
+    const model = tokenUsageModel(name);
+    if (!model || !entry || typeof entry !== 'object') continue;
+    const costUsd = finiteOrNull(entry.costUSD);
+    const next = {
+      model,
+      inputTokens: count(entry.inputTokens),
+      cacheWriteTokens: count(entry.cacheCreationInputTokens),
+      cacheReadTokens: count(entry.cacheReadInputTokens),
+      outputTokens: count(entry.outputTokens),
+      costUsd: costUsd === null || costUsd < 0 ? null : costUsd,
+      costSource: null,
+      costUnknown: entry.costBasis === 'unknown',
+    };
+    const current = totals.get(model);
+    if (!current) {
+      totals.set(model, next);
+      continue;
+    }
+    for (const field of ['inputTokens', 'cacheWriteTokens', 'cacheReadTokens', 'outputTokens', 'costUsd']) {
+      if (next[field] !== null) current[field] = (current[field] ?? 0) + next[field];
+    }
+    current.costUnknown = current.costUnknown || next.costUnknown;
+  }
+  const entries = [...totals.values()];
+  if (entries.length === 1 && sessionTokens) {
+    const [only] = entries;
+    if (only.cacheWriteTokens === null) only.cacheWriteTokens = count(sessionTokens.cacheWriteTokens);
+    if (only.cacheReadTokens === null) only.cacheReadTokens = count(sessionTokens.cacheReadTokens);
+  }
+  for (const entry of entries) entry.costSource = entry.costUsd === null ? null : 'claude-code';
+  return entries;
+}
+
 /**
  * What `GET /v1/code/sessions/{id}` says after a turn, for the relay's usage
  * routes: the context occupancy in the shape `/api/claude-context-usage`
@@ -99,6 +151,14 @@ export function readCloudSessionUsage(sessionBody, { model = '' } = {}) {
     };
   return {
     contextUsage,
+    // The session's token totals over every model: what the token booking
+    // falls back on for the cache fields (cloudSessionTokenTotals).
+    tokens: {
+      inputTokens: finiteOrNull(usage.input_tokens),
+      outputTokens: finiteOrNull(usage.output_tokens),
+      cacheReadTokens: finiteOrNull(usage.cache_read_tokens),
+      cacheWriteTokens: finiteOrNull(usage.cache_write_tokens),
+    },
     costUsd: finiteOrNull(usage.cost_usd),
     sessionUrl: String(shape?.session_url || sessionBody?.sessionUrl || '').trim() || null,
     workerStatus: String(shape?.worker_status || '').trim().toLowerCase() || null,

package/server/claude-cloud-worker/claude-cloud-session-process.mjs

@@ -18,6 +18,7 @@ import {
 } from '../claude-worker/claude-turn-publisher.mjs';
 import { summarizeToolInput } from '../claude-worker/sdk-message-normalizer.mjs';
 import {
+  cloudSessionTokenTotals,
   createClaudeCloudEventNormalizer,
   readCloudResult,
   readCloudSessionUsage,
@@ -1180,6 +1181,32 @@ export function createClaudeCloudSessionRunner({
     state.contextUsage = usage.contextUsage;
     await publisher.publishContextUsage({ message, state, model, sdkSessionId });
     await publisher.publishPlanUsage({ message, state, sdkSessionId });
+    await publishTurnTokens(message, state, usage.tokens);
+  }
+
+  // A worker process names its run once: a turn requeued onto a restarted
+  // worker is another run of it (POST /api/turn-token-usage).
+  const tokenRunId = crypto.randomUUID();
+
+  /**
+   * The session's running token totals per model (the result's
+   * `modelUsage`), under the turn: the relay books what they grew by since
+   * the session's other turns. Advisory; nothing without `modelUsage`.
+   */
+  async function publishTurnTokens(message, state, sessionTokens) {
+    const sessionTotals = cloudSessionTokenTotals(state.result?.modelUsage, sessionTokens);
+    if (!sessionTotals.length || !session.id) return;
+    await api('POST', '/api/turn-token-usage', {
+      conversationId: message.conversationId,
+      turnId: String(message.id || ''),
+      runId: tokenRunId,
+      provider: 'claude-cloud',
+      nativeSessionId: session.id,
+      at: new Date().toISOString(),
+      sessionTotals,
+    }).catch((error) => {
+      dbg('turn token publish failed', error?.message || String(error));
+    });
   }
 
   async function finishTurn(t, outcome) {

package/server/claude-worker/claude-remote-relay-tool.mjs

@@ -75,6 +75,7 @@ export const REMOTE_RELAY_TOOL_ZOD_SHAPE = {
   group: z.string().nullable().optional().describe(FIELDS.group.description),
   auto_compact_window: number('auto_compact_window'),
   thinking_enabled: z.boolean().optional().describe(FIELDS.thinking_enabled.description),
+  planOnly: z.boolean().optional().describe(FIELDS.planOnly.description),
   thinking_display: choice('thinking_display', REMOTE_RELAY_THINKING_DISPLAYS),
   question_id: text('question_id'),
   // ask: the contract's validator refuses a question or detail that is too

package/server/claude-worker/claude-session-process.mjs

@@ -615,6 +615,9 @@ export function createClaudeSessionRunner({
     // Both Claude billings report to the Claude API booking; DeepSeek has
     // its own.
     ...(claudeBillingOf(workerKind) ? { billingUsageRoute: '/api/claude-api-usage', billingKind: workerKind } : {}),
+    // Every Claude-family worker books its turns' tokens.
+    turnTokenProvider: workerKind,
+    ...(typeof backend?.turnTokenCost === 'function' ? { turnTokenCost: backend.turnTokenCost } : {}),
     ...(backend
       ? {
           describeFailure: backend.describeFailure,

package/server/claude-worker/claude-turn-publisher.mjs

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import {
   CLAUDE_LIVE_FLAG_SETTINGS_CODE,
   CLAUDE_LIVE_FLAG_SETTINGS_GUIDANCE,
@@ -6,17 +7,12 @@ import {
   claudeFailureGuidance,
 } from './claude-turn-failure.mjs';
 import { countPlanLikeLines } from '../../shared/plan-lines.mjs';
+import { PLAN_BOARD_ACTIONS } from '../../shared/plan-board-actions.mjs';
 import { EMPTY_TURN_COMPLETION_NOTE } from '../../shared/empty-turn-completion.mjs';
 import { buildSteerSettleFailure, steerSettleFailureText } from '../../shared/steer-settle-failure.mjs';
 import { buildUsageLimitFailure } from '../../shared/claude-usage-limit.mjs';
 import { WORKING_DIRECTORY_MISSING_CODE, isWorkingDirectoryMissingError } from '../../shared/worker-runtime/working-directory.mjs';
-import { claudeBillingTotals, claudeSearchTotals, claudeToolRequests, claudeUsageTotals } from './claude-usage-totals.mjs';
-
-const PLAN_BOARD_ACTIONS = [
-  { id: 'autopilot', label: 'Implement in autopilot', mode: 'autopilot' },
-  { id: 'interactive', label: 'Stop here and prompt myself', mode: 'agent' },
-  { id: 'exit_only', label: 'Stop here', mode: 'agent' },
-];
+import { claudeBillingTotals, claudeSearchTotals, claudeTokenTotals, claudeToolRequests, claudeUsageTotals } from './claude-usage-totals.mjs';
 
 /**
  * The attempt-fencing echo for a row's write bodies. Every publish that names
@@ -96,6 +92,13 @@ export function createClaudeTurnPublisher({
   // `billingKind` is the worker's kind.
   billingUsageRoute = null,
   billingKind = null,
+  // The token booking (POST /api/turn-token-usage): the provider a
+  // turn's tokens are reported under (the worker's kind: 'claude',
+  // 'claude-api', 'deepseek'), null for none. `turnTokenCost(entry, at)`
+  // prices a model's share of a turn where Claude Code's own estimate does
+  // not fit (DeepSeek: `{ costUsd, costSource }`, costUsd null when unknown).
+  turnTokenProvider = null,
+  turnTokenCost = null,
 } = {}) {
   /** `{ code, stableCode }` of a failure code, in the backend's namespace. */
   function failureCodes(code) {
@@ -230,6 +233,9 @@ export function createClaudeTurnPublisher({
    * Advisory: a failure here must not disturb the turn's response.
    */
   async function publishPlanUsage({ message, state, sdkSessionId, runId = '', resumedSessionId = '' }) {
+    // Fire-and-forget: the token post never holds the reply (the counting
+    // itself runs at once, before the next result can arrive).
+    if (turnTokenProvider) void publishTurnTokens({ message, state, runId, resumedSessionId });
     if (billingUsageRoute) await publishBillingUsage({ message, state, sdkSessionId, runId, resumedSessionId });
     if (usageRoute) {
       await publishBackendUsage({ message, state, sdkSessionId, runId, resumedSessionId });
@@ -252,6 +258,20 @@ export function createClaudeTurnPublisher({
     });
   }
 
+  // Three trackers below measure a turn from the CLI's results, one per
+  // booking, and mirror each other's rules: `run` / runningCounts (DeepSeek's
+  // card), `billingRun` / billingCounts (the Claude API booking) and
+  // `tokenRun` / turnCounts (the token booking). Each keys on the
+  // process (`runId`) and the CLI session id, so a `/clear` starts over;
+  // takes a fresh process's `modelUsage` growth over the last result's, but
+  // a resumed process's first result (and a result without `modelUsage`) as
+  // its turn `usage` alone, the main loop, and a result without `modelUsage`
+  // raises the baseline by that `usage`, so the next result's growth does
+  // not count it again; lets the baseline only rise, so a late result of an
+  // older turn books nothing twice; and counts a turn state once. They differ only in what they keep: hits and misses (cache
+  // writes inside) for the first two, the four token kinds apart for the
+  // third. A change to one rule belongs in all three.
+
   // The CLI process's own token totals and web search and fetch counts per
   // model, counted from zero for each process (`runId`) and CLI session id
   // (a `/clear` changes it and starts the CLI's totals over). `lastSession`
@@ -475,7 +495,10 @@ export function createClaudeTurnPublisher({
         }));
       }
       // The baseline only rises: a late result of an older turn below it
-      // must not make the next one count twice.
+      // must not make the next one count twice. A result without
+      // `modelUsage` grew the CLI's running totals by its `usage`, as `run`
+      // has it: the baseline grows by it too, so the next result's growth
+      // does not book that turn again.
       if (hasModelUsage) {
         for (const entry of session) {
           const last = billingRun.lastSession.get(entry.model) || { hitTokens: 0, missTokens: 0, outputTokens: 0, costUsd: 0 };
@@ -486,6 +509,16 @@ export function createClaudeTurnPublisher({
             costUsd: Math.max(last.costUsd, entry.costUsd),
           });
         }
+      } else {
+        for (const entry of claudeBillingTotals(null, { usage: result.usage, model })) {
+          const last = billingRun.lastSession.get(entry.model) || { hitTokens: 0, missTokens: 0, outputTokens: 0, costUsd: 0 };
+          billingRun.lastSession.set(entry.model, {
+            hitTokens: last.hitTokens + entry.hitTokens,
+            missTokens: last.missTokens + entry.missTokens,
+            outputTokens: last.outputTokens + entry.outputTokens,
+            costUsd: last.costUsd,
+          });
+        }
       }
       billingRun.results += 1;
     }
@@ -496,6 +529,128 @@ export function createClaudeTurnPublisher({
     };
   }
 
+  // The token booking's counts, measured like billingRun above,
+  // with the four token kinds apart, then summed per turn: a turn's results
+  // (a stopped turn's, the steered rows it folded in) post the turn's total
+  // so far under its id, which the relay keeps the larger of. A worker
+  // without a process id names one for its own life, so a requeued turn on
+  // a restarted worker is a second run, not the same row.
+  const tokenRun = { key: '', results: 0, lastSession: new Map() };
+  const tokenStates = new WeakSet();
+  const turnTokens = new Map();
+  const ownRunId = randomUUID();
+  const TOKEN_FIELDS = ['inputTokens', 'cacheWriteTokens', 'cacheReadTokens', 'outputTokens'];
+  const TURN_TOKENS_KEPT = 20;
+
+  function turnCounts(state, result, { turnId, runId, sessionId, resumedSessionId, modelKey }) {
+    const model = result.model || state.responseModel;
+    const key = `${runId}\n${sessionId}`;
+    if (tokenRun.key !== key) {
+      tokenRun.key = key;
+      tokenRun.results = 0;
+      tokenRun.lastSession = new Map();
+    }
+    // Per run and turn: a turn re-run by a new CLI process (after a crash)
+    // is a second row at the relay, holding that run's tokens only.
+    const turnKey = `${runId}\n${turnId}`;
+    let turn = turnTokens.get(turnKey);
+    if (!turn) {
+      turn = new Map();
+      turnTokens.set(turnKey, turn);
+      while (turnTokens.size > TURN_TOKENS_KEPT) turnTokens.delete(turnTokens.keys().next().value);
+    }
+    if (!tokenStates.has(state)) {
+      tokenStates.add(state);
+      const at = new Date().toISOString();
+      const hasModelUsage = Boolean(result.modelUsage) && typeof result.modelUsage === 'object' && !Array.isArray(result.modelUsage);
+      const resumed = tokenRun.results === 0 && Boolean(resumedSessionId) && sessionId === resumedSessionId;
+      const session = hasModelUsage ? claudeTokenTotals(result.modelUsage, modelKey) : [];
+      const grown = !hasModelUsage || resumed
+        ? claudeTokenTotals(null, { usage: result.usage, model, ...modelKey })
+        : session.map((entry) => {
+          const last = tokenRun.lastSession.get(entry.model);
+          const delta = { model: entry.model, costUnknown: entry.costUnknown };
+          for (const field of TOKEN_FIELDS) delta[field] = Math.max(0, entry[field] - (last?.[field] || 0));
+          delta.costUsd = entry.costUsd === null ? null : Math.max(0, entry.costUsd - (last?.costUsd || 0));
+          return delta;
+        });
+      for (const entry of grown) {
+        const priced = typeof turnTokenCost === 'function' ? turnTokenCost(entry, at) : null;
+        const costUsd = priced ? priced.costUsd : entry.costUsd;
+        const costSource = priced ? priced.costSource : (entry.costUsd === null ? null : 'claude-code');
+        const current = turn.get(entry.model) || {
+          model: entry.model, inputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0, outputTokens: 0, costUsd: null, costSource: null, costUnknown: false,
+        };
+        for (const field of TOKEN_FIELDS) current[field] += entry[field];
+        if (costUsd !== null && costUsd !== undefined) current.costUsd = (current.costUsd ?? 0) + costUsd;
+        current.costSource = current.costSource || costSource;
+        // A backend's own price wins over Claude Code's word on it (DeepSeek's
+        // models are unknown to Claude Code's table, yet OAR prices them).
+        const unknown = priced ? priced.costUsd === null || priced.costUsd === undefined : (entry.costUnknown || costUsd === null || costUsd === undefined);
+        current.costUnknown = current.costUnknown || unknown;
+        turn.set(entry.model, current);
+      }
+      // The baseline only rises: a late result of an older turn below it
+      // must not make the next one count twice. A result without
+      // `modelUsage` grew the CLI's running totals by its `usage`, as `run`
+      // has it: the baseline grows by it too.
+      for (const entry of session) {
+        const last = tokenRun.lastSession.get(entry.model) || {};
+        const next = { costUsd: Math.max(last.costUsd || 0, entry.costUsd || 0) };
+        for (const field of TOKEN_FIELDS) next[field] = Math.max(last[field] || 0, entry[field]);
+        tokenRun.lastSession.set(entry.model, next);
+      }
+      if (!hasModelUsage) {
+        for (const entry of grown) {
+          const last = tokenRun.lastSession.get(entry.model) || {};
+          const next = { costUsd: last.costUsd || 0 };
+          for (const field of TOKEN_FIELDS) next[field] = (last[field] || 0) + entry[field];
+          tokenRun.lastSession.set(entry.model, next);
+        }
+      }
+      tokenRun.results += 1;
+    }
+    return [...turn.values()]
+      .filter((entry) => TOKEN_FIELDS.some((field) => entry[field] > 0) || entry.costUsd > 0)
+      .map((entry) => ({ ...entry }));
+  }
+
+  /**
+   * Ship the turn's tokens per model to the token booking: the
+   * turn's total so far, under the turn's id and the process's run id.
+   * Reasoning is not reported apart by Claude, so it is left out (NULL).
+   * Advisory and fire-and-forget: it never throws and nothing waits on it.
+   */
+  async function publishTurnTokens({ message, state, runId = '', resumedSessionId = '' }) {
+    try {
+      const result = state.result;
+      const turnId = String(message?.id || '').trim();
+      if (!turnId || !result) return;
+      const sessionId = String(result.sessionId || '').trim();
+      const modelKey = typeof usageModelKey === 'function' ? { modelKey: usageModelKey } : {};
+      const run = String(runId || '') || ownRunId;
+      const models = turnCounts(state, result, {
+        turnId,
+        runId: run,
+        sessionId,
+        resumedSessionId: String(resumedSessionId || '').trim(),
+        modelKey,
+      });
+      if (!models.length) return;
+      await api('POST', '/api/turn-token-usage', {
+        conversationId: message.conversationId,
+        turnId,
+        runId: run,
+        provider: turnTokenProvider,
+        ...(sessionId ? { nativeSessionId: sessionId } : {}),
+        at: new Date().toISOString(),
+        models,
+      });
+    } catch (error) {
+      dbg('turn token publish failed', error?.message || String(error));
+    }
+  }
+
   /**
    * Ship the turn's counts to the Claude API booking: the process's own
    * running totals (`runCounts`) and the CLI's session totals

package/server/claude-worker/claude-usage-totals.mjs

@@ -159,3 +159,61 @@ export function claudeBillingTotals(modelUsage, { usage = null, model = '' } = {
   }
   return [...totals.values()].filter((entry) => entry.hitTokens + entry.missTokens + entry.outputTokens > 0 || entry.costUsd > 0);
 }
+
+/**
+ * The CLI's totals per model with the four token kinds apart, for the token
+ * booking (POST /api/turn-token-usage): `[{ model, inputTokens,
+ * cacheWriteTokens, cacheReadTokens, outputTokens, costUsd, costUnknown }]`.
+ * `inputTokens` is fresh input (Anthropic counts cache reads and writes
+ * apart). Read like claudeBillingTotals: `modelUsage` (running totals, with
+ * Claude Code's cost estimate) or `usage` alone under the turn's model (no
+ * cost: `costUsd` null). `modelKey` maps the CLI's model names to the
+ * relay's, as in claudeUsageTotals; the `[1m]` tier is dropped. Models with
+ * no tokens and no cost are left out.
+ */
+export function claudeTokenTotals(modelUsage, {
+  usage = null,
+  model = '',
+  modelKey = (value) => String(value ?? '').trim(),
+} = {}) {
+  const totals = new Map();
+  const add = (name, entry) => {
+    const key = String(modelKey(name) ?? '').trim().toLowerCase().replace(/\[1m\]$/, '');
+    if (!key) return;
+    const current = totals.get(key) || {
+      model: key, inputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0, outputTokens: 0, costUsd: null, costUnknown: false,
+    };
+    current.inputTokens += entry.inputTokens;
+    current.cacheWriteTokens += entry.cacheWriteTokens;
+    current.cacheReadTokens += entry.cacheReadTokens;
+    current.outputTokens += entry.outputTokens;
+    if (entry.costUsd !== null) current.costUsd = (current.costUsd ?? 0) + entry.costUsd;
+    current.costUnknown = current.costUnknown || entry.costUnknown;
+    totals.set(key, current);
+  };
+  if (modelUsage && typeof modelUsage === 'object' && !Array.isArray(modelUsage)) {
+    for (const [name, entry] of Object.entries(modelUsage)) {
+      if (!entry || typeof entry !== 'object') continue;
+      add(name, {
+        inputTokens: count(entry.inputTokens),
+        cacheWriteTokens: count(entry.cacheCreationInputTokens),
+        cacheReadTokens: count(entry.cacheReadInputTokens),
+        outputTokens: count(entry.outputTokens),
+        costUsd: costOf(entry.costUSD),
+        costUnknown: entry.costBasis === 'unknown',
+      });
+    }
+  } else if (usage && typeof usage === 'object') {
+    add(model, {
+      inputTokens: count(usage.input_tokens),
+      cacheWriteTokens: count(usage.cache_creation_input_tokens),
+      cacheReadTokens: count(usage.cache_read_input_tokens),
+      outputTokens: count(usage.output_tokens),
+      costUsd: null,
+      costUnknown: false,
+    });
+  }
+  return [...totals.values()].filter((entry) => (
+    entry.inputTokens + entry.cacheWriteTokens + entry.cacheReadTokens + entry.outputTokens > 0 || entry.costUsd > 0
+  ));
+}

package/server/copilot-worker/copilot-plan-board.mjs

@@ -14,16 +14,13 @@
 // shape of the final prose. Both paths are wired — the hook is primary, the
 // text heuristic is the fallback — which is the Claude worker's arrangement.
 import { countPlanLikeLines } from '../../shared/plan-lines.mjs';
+import { PLAN_BOARD_ACTIONS } from '../../shared/plan-board-actions.mjs';
 
 /**
- * Kept identical across workers. `exit_only` dismisses; `autopilot` and
- * `interactive` queue a follow-up user message in the mapped relay mode.
+ * The one list every worker posts (shared/plan-board-actions.mjs): `exit_only`
+ * dismisses; the others queue a follow-up user message in the mapped mode.
  */
-export const PLAN_BOARD_ACTIONS = [
-  { id: 'autopilot', label: 'Implement in autopilot', mode: 'autopilot' },
-  { id: 'interactive', label: 'Stop here and prompt myself', mode: 'agent' },
-  { id: 'exit_only', label: 'Stop here', mode: 'agent' },
-];
+export { PLAN_BOARD_ACTIONS };
 
 /**
  * How many list-ish lines a final message needs before it is treated as a plan.

package/server/copilot-worker/copilot-sdk-event-normalizer.mjs

@@ -174,7 +174,7 @@ export function formatSubagentStats(data) {
  * figures keep the FIRST call's time-to-first-token (that is the number a user
  * experiences as "did it start answering").
  */
-function createUsageAccumulator() {
+function createUsageAccumulator({ debugTokenUsage = null } = {}) {
   const totals = {
     inputTokens: 0,
     outputTokens: 0,
@@ -195,8 +195,61 @@ function createUsageAccumulator() {
     isByok: null,
     quotaSnapshots: null,
   };
+  // The token booking's view (POST /api/turn-token-usage): the same calls,
+  // per model, the four token kinds apart. A field no call of the model
+  // carried stays null, so "not reported" is not booked as 0.
+  const byModel = new Map();
+  let compactionCalls = 0;
+  // A compaction's call as `session.compaction_complete` reports it, kept
+  // apart until the snapshot: it is booked only if no usage event of the
+  // compaction class came in the turn, before or after it.
+  const compactionTokens = new Map();
+  function addTokens(model, data, into = byModel) {
+    const key = String(model || '').trim();
+    const bucket = into.get(key) || {
+      model: key, inputTokens: null, outputTokens: null, cacheReadTokens: null, cacheWriteTokens: null, reasoningTokens: null,
+    };
+    const count = (value) => {
+      if (value === null || value === undefined || value === '') return null;
+      const n = Number(value);
+      return Number.isFinite(n) && n >= 0 ? n : null;
+    };
+    const cacheRead = count(data.cacheReadTokens);
+    const cacheWrite = count(data.cacheWriteTokens);
+    const prompt = count(data.inputTokens);
+    // Fresh input is the prompt count less the cache reads and writes, per
+    // call, floored at 0. Inferred, not verified: the bundled runtime reads
+    // OpenAI-style `prompt_tokens` with `prompt_tokens_details.cached_tokens`
+    // (and cache creation), where the prompt count includes the cache. A
+    // real-provider check at the merge gate confirms it, reading the raw
+    // counts that OAR_DEBUG_TOKEN_USAGE=1 logs.
+    const fresh = prompt === null ? null : Math.max(0, prompt - (cacheRead || 0) - (cacheWrite || 0));
+    for (const [field, value] of [
+      ['inputTokens', fresh],
+      ['outputTokens', count(data.outputTokens)],
+      ['cacheReadTokens', cacheRead],
+      ['cacheWriteTokens', cacheWrite],
+      ['reasoningTokens', count(data.reasoningTokens)],
+    ]) {
+      if (value !== null) bucket[field] = (bucket[field] ?? 0) + value;
+    }
+    into.set(key, bucket);
+  }
   function add(data, { allowModel = true } = {}) {
     if (!data || typeof data !== 'object') return;
+    if (typeof debugTokenUsage === 'function') {
+      debugTokenUsage({
+        model: data.model ?? null,
+        interactionType: data.interactionType ?? null,
+        inputTokens: data.inputTokens ?? null,
+        cacheReadTokens: data.cacheReadTokens ?? null,
+        cacheWriteTokens: data.cacheWriteTokens ?? null,
+        outputTokens: data.outputTokens ?? null,
+        reasoningTokens: data.reasoningTokens ?? null,
+      });
+    }
+    addTokens(data.model, data);
+    if (String(data.interactionType || '').trim() === 'conversation-compaction') compactionCalls += 1;
     totals.modelCalls += 1;
     if (!allowModel) totals.subagentModelCalls += 1;
     for (const key of ['inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'reasoningTokens', 'cost']) {
@@ -222,13 +275,38 @@ function createUsageAccumulator() {
   }
   return {
     add,
+    /**
+     * A compaction's own model call, from `session.compaction_complete`'s
+     * `compactionTokensUsed`: booked unless the runtime reports it, before
+     * or after, as an `assistant.usage` of the compaction class.
+     */
+    addCompaction(tokensUsed, fallbackModel = '') {
+      if (!tokensUsed || typeof tokensUsed !== 'object') return;
+      addTokens(tokensUsed.model || fallbackModel, tokensUsed, compactionTokens);
+    },
     setQuotaSnapshots(snapshots) {
       if (snapshots && typeof snapshots === 'object' && Object.keys(snapshots).length) {
         totals.quotaSnapshots = snapshots;
       }
     },
     snapshot() {
-      return totals.modelCalls ? { ...totals } : (totals.quotaSnapshots ? { ...totals } : null);
+      // A call without a model id is the turn's main model's.
+      const models = [];
+      const buckets = [...byModel.values(), ...(compactionCalls > 0 ? [] : compactionTokens.values())];
+      for (const bucket of buckets) {
+        const model = bucket.model || totals.model;
+        const same = models.find((entry) => entry.model === model);
+        if (!same) {
+          models.push({ ...bucket, model });
+          continue;
+        }
+        for (const field of ['inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'reasoningTokens']) {
+          if (bucket[field] !== null) same[field] = (same[field] ?? 0) + bucket[field];
+        }
+      }
+      const tokenModels = models.filter((entry) => entry.model);
+      if (!totals.modelCalls && !totals.quotaSnapshots && !tokenModels.length) return null;
+      return { ...totals, models: tokenModels };
     },
   };
 }
@@ -242,6 +320,9 @@ export function createCopilotEventNormalizer({
   // The runner's answer to "is this agent id a background agent?" — shared
   // across turns, unlike this normalizer's own `backgroundRuns`.
   isBackgroundAgent = () => false,
+  // Called with the raw token counts of every model call (no ids), when the
+  // worker runs with OAR_DEBUG_TOKEN_USAGE=1.
+  debugTokenUsage = null,
 } = {}) {
   let sessionModel = '';
   let sessionId = '';
@@ -250,7 +331,7 @@ export function createCopilotEventNormalizer({
   let terminalEmitted = false;
   let contextUsage = null;
   let interactionId = '';
-  const usage = createUsageAccumulator();
+  const usage = createUsageAccumulator({ debugTokenUsage });
 
   // Assistant text is assembled per `messageId`. A tool-using request produces
   // several assistant messages (the first typically empty with `toolRequests`,
@@ -866,6 +947,8 @@ export function createCopilotEventNormalizer({
         return [activityAction('Compacting the conversation context…')];
       }
       case 'session.compaction_complete': {
+        // Its model call costs tokens too (booked with the turn it ran in).
+        usage.addCompaction(data.compactionTokensUsed, data.model || sessionModel);
         if (data.success === false) {
           const reason = String(data.error || '').trim();
           return [activityAction(truncate(reason ? `Context compaction failed: ${reason}` : 'Context compaction failed'))];