claude-code-session-manager 0.35.2 → 0.35.3

package/src/main/historyAggregator.cjs

@@ -11,6 +11,32 @@ const PARSE_BUDGET_MS = 2_000;
 const MAX_FILE_BYTES = 20 * 1024 * 1024;
 const CACHE_MAX = 500;
 
+// Dollars per million tokens (input / output / cache-read). Cache-read
+// tokens are priced far below input because they're served from
+// Anthropic's prompt cache, not re-processed — this is what makes the
+// cache-savings figure in the dashboard real money, not a vanity stat.
+const MODEL_PRICING = {
+  opus:   { i: 15,  o: 75, c: 1.5 },
+  sonnet: { i: 3,   o: 15, c: 0.3 },
+  haiku:  { i: 0.8, o: 4,  c: 0.08 },
+};
+const DEFAULT_PRICING_KEY = 'sonnet'; // fallback for unrecognized model ids
+
+/**
+ * Resolve a raw model id (e.g. "claude-opus-4-8-20260115") to a pricing
+ * bucket key. Model ids aren't stable enough to match exactly, so this is a
+ * case-insensitive substring check. Unrecognized ids fall back to
+ * DEFAULT_PRICING_KEY and are flagged so callers can annotate them as
+ * estimated rather than exact.
+ */
+function resolvePricingKey(modelId) {
+  const id = String(modelId ?? '').toLowerCase();
+  if (id.includes('opus')) return { key: 'opus', estimated: false };
+  if (id.includes('sonnet')) return { key: 'sonnet', estimated: false };
+  if (id.includes('haiku')) return { key: 'haiku', estimated: false };
+  return { key: DEFAULT_PRICING_KEY, estimated: true };
+}
+
 // ── LRU cache ─────────────────────────────────────────────────────────────────
 // Backed by an insertion-order Map: delete+re-insert on access = O(1) LRU.
 class LRUCache {
@@ -114,6 +140,19 @@ function scanAggrLines(lines, acc, captureFirst) {
       if (typeof outT === 'number') acc.outputTokens += outT;
       if (typeof cacheR === 'number') acc.cacheReadTokens += cacheR;
       if (typeof cacheC === 'number') acc.cacheCreationTokens += cacheC;
+
+      // Only assistant usage lines carry model+usage together in practice;
+      // read defensively rather than assuming every usage line has a model.
+      const modelId = obj.message?.model;
+      if (typeof modelId === 'string' && modelId) {
+        const bucket = acc.byModel[modelId] ?? (acc.byModel[modelId] = {
+          inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0,
+        });
+        if (typeof inT === 'number') bucket.inputTokens += inT;
+        if (typeof outT === 'number') bucket.outputTokens += outT;
+        if (typeof cacheR === 'number') bucket.cacheReadTokens += cacheR;
+        if (typeof cacheC === 'number') bucket.cacheCreationTokens += cacheC;
+      }
     }
 
     const content = obj.message?.content ?? obj.content;
@@ -157,6 +196,7 @@ async function parseJSONL(filePath, stat) {
     cacheCreationTokens: 0,
     toolCallCount: 0,
     toolBreakdown: {},
+    byModel: {},
     errorCount: 0,
     sessionDate: null,
     skipped: false,
@@ -195,6 +235,7 @@ async function parseJSONL(filePath, stat) {
             cacheCreationTokens: prev.cacheCreationTokens + delta.cacheCreationTokens,
             toolCallCount: prev.toolCallCount + delta.toolCallCount,
             toolBreakdown: { ...prev.toolBreakdown },
+            byModel: {},
             errorCount: prev.errorCount + delta.errorCount,
             sessionDate: prev.sessionDate, // firstTs doesn't change on appends
             skipped: false,
@@ -202,6 +243,18 @@ async function parseJSONL(filePath, stat) {
           for (const [k, v] of Object.entries(delta.toolBreakdown)) {
             merged.toolBreakdown[k] = (merged.toolBreakdown[k] ?? 0) + v;
           }
+          for (const [modelId, srcBucket] of Object.entries(prev.byModel ?? {})) {
+            merged.byModel[modelId] = { ...srcBucket };
+          }
+          for (const [modelId, deltaBucket] of Object.entries(delta.byModel)) {
+            const b = merged.byModel[modelId] ?? (merged.byModel[modelId] = {
+              inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0,
+            });
+            b.inputTokens += deltaBucket.inputTokens;
+            b.outputTokens += deltaBucket.outputTokens;
+            b.cacheReadTokens += deltaBucket.cacheReadTokens;
+            b.cacheCreationTokens += deltaBucket.cacheCreationTokens;
+          }
           // readOffset advances to the last complete newline so the next tail
           // always starts at a line boundary. size stays at stat.size so the
           // exact-hit check works correctly on the next call.
@@ -307,6 +360,7 @@ async function aggregate(req) {
           cacheCreationTokens: 0,
           toolCallCount: 0,
           toolBreakdown: {},
+          byModel: {},
           sessionCount: 0,
           errorCount: 0,
         });
@@ -322,6 +376,15 @@ async function aggregate(req) {
       for (const [tool, cnt] of Object.entries(parsed.toolBreakdown)) {
         b.toolBreakdown[tool] = (b.toolBreakdown[tool] ?? 0) + cnt;
       }
+      for (const [modelId, srcBucket] of Object.entries(parsed.byModel ?? {})) {
+        const dst = b.byModel[modelId] ?? (b.byModel[modelId] = {
+          inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0,
+        });
+        dst.inputTokens += srcBucket.inputTokens;
+        dst.outputTokens += srcBucket.outputTokens;
+        dst.cacheReadTokens += srcBucket.cacheReadTokens;
+        dst.cacheCreationTokens += srcBucket.cacheCreationTokens;
+      }
       b.sessionCount++;
       b.errorCount += parsed.errorCount;
 
@@ -337,15 +400,30 @@ async function aggregate(req) {
     }
   }
 
-  const rows = Array.from(buckets.values()).map((b) => ({
-    ...b,
-    estimatedCostUsd: (b.inputTokens * 3 + b.outputTokens * 15) / 1_000_000,
-  }));
+  let cacheSavingsUsd = 0;
+  const rows = Array.from(buckets.values()).map((b) => {
+    const byModel = {};
+    let estimatedCostUsd = 0;
+    for (const [modelId, bucket] of Object.entries(b.byModel)) {
+      const { key, estimated } = resolvePricingKey(modelId);
+      const pricing = MODEL_PRICING[key];
+      const costUsd =
+        (bucket.inputTokens + bucket.cacheCreationTokens) * pricing.i / 1e6 +
+        bucket.outputTokens * pricing.o / 1e6 +
+        bucket.cacheReadTokens * pricing.c / 1e6;
+      byModel[modelId] = { ...bucket, costUsd, ...(estimated ? { estimated: true } : {}) };
+      estimatedCostUsd += costUsd;
+      // What those cache-read tokens would have cost at the full input rate,
+      // minus what they actually cost at the cache rate.
+      cacheSavingsUsd += bucket.cacheReadTokens * (pricing.i - pricing.c) / 1e6;
+    }
+    return { ...b, byModel, estimatedCostUsd };
+  });
 
   rows.sort((a, b) => a.date.localeCompare(b.date) || a.projectCwd.localeCompare(b.projectCwd));
 
   const scannedMs = Date.now() - t0;
-  return { rows, partial: truncated, truncated, scannedMs, skippedLargeFiles };
+  return { rows, partial: truncated, truncated, scannedMs, skippedLargeFiles, cacheSavingsUsd };
 }
 
 // ── IPC registration ──────────────────────────────────────────────────────────
@@ -398,4 +476,12 @@ function registerHistoryAggregatorHandlers() {
 
 const remote = { aggregate };
 
-module.exports = { registerHistoryAggregatorHandlers, remote };
+module.exports = {
+  registerHistoryAggregatorHandlers,
+  remote,
+  MODEL_PRICING,
+  // exported for tests
+  scanAggrLines,
+  parseJSONL,
+  resolvePricingKey,
+};

package/src/main/index.cjs

@@ -1,4 +1,4 @@
-const { app, BrowserWindow, ipcMain, dialog, Menu, session, systemPreferences, globalShortcut, shell, clipboard, powerSaveBlocker, protocol } = require('electron');
+const { app, BrowserWindow, ipcMain, dialog, Menu, session, systemPreferences, globalShortcut, shell, clipboard, nativeImage, powerSaveBlocker, protocol } = require('electron');
 const { spawn, execFile, execFileSync } = require('node:child_process');
 const path = require('node:path');
 const fs = require('node:fs');
@@ -7,6 +7,8 @@ const os = require('node:os');
 const { schemas, validated } = require('./ipcSchemas.cjs');
 const { cleanChildEnv } = require('./lib/cleanEnv.cjs');
 const { manager: ptyManager, registerPtyHandlers } = require('./pty.cjs');
+const browserView = require('./browserView.cjs');
+const browserCapture = require('./browserCapture.cjs');
 const configMgr = require('./config.cjs');
 const transcripts = require('./transcripts.cjs');
 const usageMatrix = require('./usageMatrix.cjs');
@@ -21,6 +23,8 @@ crashDiagnostics.startCrashReporter();
 const voiceHotkey = require('./voiceHotkey.cjs');
 const voiceWizard = require('./voiceWizard.cjs');
 const scheduler = require('./scheduler.cjs');
+const { createAdminServer } = require('./adminServer.cjs');
+const adminServer = createAdminServer(scheduler.remote);
 const supervisor = require('./supervisor.cjs');
 const watchers = require('./watchers.cjs');
 const teams = require('./teams.cjs');
@@ -33,7 +37,6 @@ const { registerHistoryAggregatorHandlers } = require('./historyAggregator.cjs')
 const memoryTool = require('./memoryTool.cjs');
 const { registerMemoryAggregateIpc } = require('./memoryAggregate.cjs');
 const agentMemory = require('./agentMemory.cjs');
-const { registerDocEditorHandlers } = require('./docEditor.cjs');
 const git = require('./git.cjs');
 const superagent = require('./superagent.cjs');
 const filesIpc = require('./files.cjs');
@@ -265,6 +268,8 @@ async function rebootApp() {
     configMgr.attachWindow(mainWindow);
     transcripts.attachWindow(mainWindow);
     usageMatrix.attachWindow(mainWindow);
+    browserView.attachWindow(mainWindow);
+    browserCapture.attachWindow(mainWindow);
     voiceHotkey.init(mainWindow).catch((e) => {
       logs.writeLine({ scope: 'voice-hotkey', level: 'error', message: 'reinit failed', meta: { error: e?.message } });
     });
@@ -445,6 +450,19 @@ ipcMain.handle('clipboard:paste-image', async () => {
   }
 });
 
+// PRD 407 Capture panel — write side of paste-image's read. Writes a
+// screenshot capture to the OS clipboard as an image.
+ipcMain.handle('browser:copy-image', validated(schemas.browserCopyImage, ({ dataUrl }) => {
+  try {
+    const img = nativeImage.createFromDataURL(dataUrl);
+    if (!img || img.isEmpty()) return { ok: false, error: 'empty image' };
+    clipboard.writeImage(img);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e && e.message ? e.message : String(e) };
+  }
+}));
+
 // Hooks tab "Test fire": run a hook command with a fake event payload piped
 // to stdin. shell:true is intentional — Claude Code's hook field is a shell
 // string. Timeout is enforced via SIGKILL on a timer because spawn's built-in
@@ -673,7 +691,6 @@ pluginInstall.registerPluginInstallHandlers();
 memoryTool.registerMemoryHandlers();
 registerMemoryAggregateIpc();
 agentMemory.registerAgentMemoryHandlers();
-registerDocEditorHandlers();
 git.register(ipcMain);
 superagent.registerSuperAgentHandlers();
 filesIpc.registerFilesHandlers();
@@ -774,6 +791,11 @@ app.on('web-contents-created', (_e, wc) => {
   });
 
   wc.on('will-navigate', (event, url) => {
+    // The embedded Browser tab's WebContentsView is a real browser — it must
+    // be able to navigate anywhere. Exempt ONLY webContents registered by
+    // browserView.cjs; the main window's lock below is unchanged.
+    if (browserView.isBrowserViewContents(wc.id)) return;
+
     const allowed = useDevServer
       ? ['http://localhost:5173', 'http://127.0.0.1:5173']
       : [];
@@ -971,6 +993,9 @@ app.whenReady().then(async () => {
   configMgr.attachWindow(mainWindow);
   transcripts.attachWindow(mainWindow);
   usageMatrix.attachWindow(mainWindow);
+  browserView.registerBrowserView({ mainWindow, ipcMain });
+  browserCapture.attachWindow(mainWindow);
+  browserCapture.registerBrowserCapture({ ipcMain, getView: browserView.getView });
   voiceHotkey.init(mainWindow).catch((e) => {
     logs.writeLine({ scope: 'voice-hotkey', level: 'error', message: 'init failed', meta: { error: e?.message } });
   });
@@ -983,6 +1008,9 @@ app.whenReady().then(async () => {
   scheduler.init().catch((e) => {
     logs.writeLine({ scope: 'scheduler', level: 'error', message: 'init failed', meta: { error: e?.message } });
   });
+  adminServer.start().catch((e) => {
+    logs.writeLine({ scope: 'admin-server', level: 'error', message: 'init failed', meta: { error: e?.message } });
+  });
   // First-boot default: install the bundled session-manager-dev plugin (its 10
   // dev skills) from the app's own marketplace. One-shot + idempotent; never
   // throws. SM_SEED_DEV_PLUGIN_DISABLE=1 to opt out.
@@ -1072,6 +1100,7 @@ app.on('before-quit', () => {
   configMgr.closeAllWatchers();
   transcripts.closeAll();
   watchers.manager.killAll();
+  adminServer.stop().catch(() => {});
   // Best-effort flush of any pending OTEL spans. shutdown() has its own 2s
   // ceiling so a wedged exporter can't hold quit.
   otel.shutdown().catch(() => {});

package/src/main/ipcSchemas.cjs

@@ -45,6 +45,100 @@ const ptyResize = z.object({
   rows: z.number().int().min(3).max(1000),
 });
 
+// ──────────────────────────────────────────── Browser (WebContentsView embed)
+// viewId is a renderer-generated identifier; restrict to a safe charset (no
+// '/', no '.') since it keys the in-process Map<viewId, WebContentsView> —
+// not used as a filesystem path, but kept consistent with tabId conventions.
+const BROWSER_VIEW_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+const browserViewId = z.object({
+  viewId: z.string().min(1).max(128).regex(BROWSER_VIEW_ID_RE),
+});
+
+const browserCreate = z.object({
+  viewId: z.string().min(1).max(128).regex(BROWSER_VIEW_ID_RE),
+  // Non-persistent partition string (PRD 400 run-mode isolation). No leading
+  // 'persist:' enforced here — callers choose persistence explicitly.
+  partition: z.string().min(1).max(256),
+});
+
+const BOUNDS_INT = z.number().int().min(0).max(100000);
+const browserSetBounds = z.object({
+  viewId: z.string().min(1).max(128).regex(BROWSER_VIEW_ID_RE),
+  x: BOUNDS_INT,
+  y: BOUNDS_INT,
+  width: BOUNDS_INT,
+  height: BOUNDS_INT,
+});
+
+const browserNavigate = z.object({
+  viewId: z.string().min(1).max(128).regex(BROWSER_VIEW_ID_RE),
+  url: z.string().min(1).max(8192),
+});
+
+// PRD 407: DOM/text capture from the active browser sub-tab.
+const browserCaptureDom = z.object({
+  viewId: z.string().min(1).max(128).regex(BROWSER_VIEW_ID_RE),
+  kind: z.enum(['text', 'html']),
+});
+
+// PRD 404: filter -> prune -> summarize -> chunk capture of a picked
+// selection (browser:capture). selectors comes from the PRD 403 picker.
+const browserCaptureSelection = z.object({
+  viewId: z.string().min(1).max(128).regex(BROWSER_VIEW_ID_RE),
+  selectors: z.array(z.string().min(1).max(2048)).min(1).max(50),
+  mode: z.enum(['agent', 'html', 'a11y', 'selector']),
+});
+
+// PRD 407: clipboard image write (browser:copy-image). dataUrl is a PNG data
+// URL from webContents.capturePage() — capped well above any realistic
+// screenshot so a malformed/huge payload can't wedge the IPC channel.
+const browserCopyImage = z.object({
+  dataUrl: z.string().min(1).max(50_000_000),
+});
+
+// PRD 407: binary-safe atomic write (browser:save-binary) for screenshot
+// captures — config:write-text is utf8-only.
+const browserSaveBinary = z.object({
+  path: z.string().min(1).max(4096),
+  base64: z.string().min(1).max(50_000_000),
+});
+
+// PRD 410: replay a recorded step list against a live view. The renderer
+// owns the step list (main never persists recorded steps), so every call is
+// self-contained. `select` is accepted for forward-compat even though the
+// live recorder engine doesn't emit it yet.
+const browserReplayStep = z.object({
+  n: z.number().int().min(1),
+  verb: z.enum(['navigate', 'click', 'type', 'select', 'wait-for']),
+  target: z.string().max(2000),
+  value: z.string().max(2000).optional(),
+  variable: z.string().max(64).nullable().optional(),
+  kind: z.enum(['nav', 'assert']).optional(),
+  masked: z.boolean().optional(),
+  variableSuggestion: z.string().max(64).optional(),
+});
+
+const browserReplay = z.object({
+  viewId: z.string().min(1).max(128).regex(BROWSER_VIEW_ID_RE),
+  steps: z.array(browserReplayStep).max(500),
+  values: z.record(z.string().max(64), z.string().max(2000)).optional(),
+  continueOnError: z.boolean().optional(),
+});
+
+// PRD 402: address-bar zoom control. factor is clamped again in
+// browserView.cjs's setZoom — this just bounds the wire payload.
+const browserSetZoom = z.object({
+  viewId: z.string().min(1).max(128).regex(BROWSER_VIEW_ID_RE),
+  factor: z.number().min(0.1).max(10),
+});
+
+// PRD 402: Cmd/Ctrl+F find bar.
+const browserFind = z.object({
+  viewId: z.string().min(1).max(128).regex(BROWSER_VIEW_ID_RE),
+  text: z.string().max(2000),
+  forward: z.boolean().optional(),
+});
+
 // ──────────────────────────────────────────── Transcripts
 const SESSION_UUID_RE = /^[a-zA-Z0-9-]{1,64}$/;
 
@@ -90,6 +184,7 @@ const sessionsPayload = z.object({
   tabs: z.array(z.object({
     id: z.string().min(1).max(128),
     claudeSessionId: z.string().min(1).max(128),
+    chatSessionId: z.string().min(1).max(128).optional(),
     cwd: z.string().min(1).max(4096),
     label: z.string().max(256),
     presetId: z.string().max(128).nullable(),
@@ -512,6 +607,17 @@ module.exports = {
     ptyWrite,
     ptyResize,
     sessionSubscribe,
+    browserViewId,
+    browserCreate,
+    browserSetBounds,
+    browserNavigate,
+    browserCaptureDom,
+    browserCaptureSelection,
+    browserCopyImage,
+    browserSaveBinary,
+    browserReplay,
+    browserSetZoom,
+    browserFind,
     transcriptSubscribe,
     transcriptTabId,
     transcriptPath,

package/src/main/lib/schedulerConfig.cjs

@@ -3,8 +3,12 @@ module.exports = {
   // `when-available` policy notices the 5h window crossing the utilization
   // threshold — i.e. when to stop (util ≥ threshold) and start (util < threshold)
   // jobs around the 5-hour limit. Reset-time resume is scheduled exactly (not
-  // poll-bound), so 10 min only bounds how late we react to utilization drift.
-  POLL_INTERVAL_MS: 10 * 60_000,
+  // poll-bound), so 1 min only bounds how late we react to utilization drift
+  // (e.g. freed host memory unblocking a pending job in another project).
+  // Tradeoff accepted: this raises billing.fetchUsage() calls from 6x/hour to
+  // 60x/hour against Anthropic's usage endpoint (src/main/usage.cjs) — not a
+  // job-execution cost, just a lighter-weight polling GET.
+  POLL_INTERVAL_MS: 60_000,
   // Exponential backoff floor for polling retries after transient failures.
   POLL_MIN_INTERVAL_MS: 90_000,
   // Cadence for refreshing the AppStatusBar's 5h-usage chip (billing meter).

package/src/main/runVerify.cjs

@@ -616,6 +616,18 @@ async function verifyRun({ runDir, prdPath, queueEntry, allJobs = [], committedD
       ? { ...(annotations.length ? { annotations } : {}), ...sentinelFields }
       : undefined;
 
+    // No pattern hits is not automatically "clean": a run that neither
+    // committed anything nor ever emitted the finish-protocol sentinel likely
+    // ended before doing real work (e.g. stopped on a clarifying question).
+    // Weaker evidence than a caught transcript error, but still not clean.
+    if (sentinel === null && !committedDuringRun) {
+      issues.push({
+        verdict: 'no_verdict_sentinel',
+        reason: 'run made no commit and emitted no SCHEDULER_VERDICT sentinel — likely ended before the finish protocol (e.g. stopped on a clarifying question)',
+        priority: 1,
+      });
+    }
+
     if (issues.length === 0) {
       const reason = annotations.length
         ? `no blocking issues (${annotations.length} annotation(s): ${annotations.map((a) => a.reason).join('; ')})`
@@ -623,7 +635,8 @@ async function verifyRun({ runDir, prdPath, queueEntry, allJobs = [], committedD
       return conclude('clean', reason, null, extras);
     }
 
-    // Pick highest-priority issue (transcript_errors > verify_unavailable).
+    // Pick highest-priority issue (transcript_errors > verify_unavailable ==
+    // no_verdict_sentinel; ties keep the loop's original order via stable sort).
     issues.sort((a, b) => b.priority - a.priority);
     const top = issues[0];
 

package/src/main/scheduler.cjs

@@ -2479,7 +2479,12 @@ const remote = {
     });
     if (!found) return { ok: false, error: 'not found' };
     await broadcast();
-    return { ok: true };
+    return { ok: true, slug, status: 'pending' };
+  },
+
+  async listJobs() {
+    const state = await readQueue();
+    return state.jobs.map((j) => ({ slug: j.slug, title: j.title, status: j.status, cwd: j.cwd }));
   },
 
   async runNow() {

package/src/main/sessionsStore.cjs

@@ -5,9 +5,9 @@
  * Storage: ~/.config/session-manager/tabs.json
  * Shape: { tabs: PersistedTab[], activeTabId: string | null, savedAt: number }
  *
- * Only serializable, durable fields are persisted: id, claudeSessionId, cwd,
- * label, presetId. Runtime-only fields (pid, status, startupCommand,
- * exitCode) are recomputed on boot.
+ * Only serializable, durable fields are persisted: id, claudeSessionId,
+ * chatSessionId, cwd, label, presetId. Runtime-only fields (pid, status,
+ * startupCommand, exitCode) are recomputed on boot.
  */
 
 const fs = require('node:fs');
@@ -59,6 +59,7 @@ async function markFreshRestart() {
   const freshTabs = tabs.map((t) => ({
     ...t,
     claudeSessionId: crypto.randomUUID(),
+    chatSessionId: crypto.randomUUID(),
   }));
   await save({ tabs: freshTabs, activeTabId, freshStart: true });
 }

package/src/preload/api.d.ts

@@ -15,6 +15,72 @@ export interface WriteErrorEvent {
   reason: string;
 }
 
+export interface BrowserNavState {
+  url: string;
+  title: string;
+  canGoBack: boolean;
+  canGoForward: boolean;
+  loading: boolean;
+  isSecure: boolean;
+}
+
+/** One captured recorder step (PRD 408 engine → PRD 409 panel). */
+export interface RecordStep {
+  n: number;
+  /** `select` is accepted by replay/export (PRD 410) for forward-compat;
+   * the live engine does not emit it yet. */
+  verb: 'navigate' | 'click' | 'type' | 'select' | 'wait-for';
+  target: string;
+  kind?: 'nav' | 'assert';
+  /** True for `type` steps — the actual typed value is never captured. */
+  masked?: boolean;
+  /** Engine-suggested `{{var}}` name for a `type` step (e.g. field name). */
+  variableSuggestion?: string;
+  /** Renderer-owned: set once the user checks "parameterize as {{var}}". */
+  variable?: string | null;
+  /** `select` steps only — the option value to choose on replay/export. */
+  value?: string;
+}
+
+/** Per-step replay outcome (PRD 410), streamed as `browser:replay-step:<viewId>`. */
+export interface ReplayStepResult {
+  n: number;
+  status: 'pass' | 'fail';
+  detail?: string;
+}
+
+/** find-in-page result (PRD 402), streamed as `browser:find-result:<viewId>`. */
+export interface FindResult {
+  requestId: number;
+  matches: number;
+  activeMatchOrdinal: number;
+}
+
+/** Element-picker event (PRD 403), streamed as `browser:picker-event:<viewId>`. */
+export interface PickerEvent {
+  type: 'hover' | 'pick' | 'unpick' | 'exit';
+  selector?: string;
+  label?: string;
+  tag?: string;
+  rect?: { x: number; y: number; width: number; height: number };
+  /** Present on a 'pick' event fired by an unmodified click — the selection was replaced, not accumulated. */
+  replace?: boolean;
+}
+
+/** One entry in `~/.claude/session-manager/browser/history.json` (PRD 402). */
+export interface BrowserHistoryEntry {
+  url: string;
+  title: string;
+  ts: number;
+}
+
+/** One entry in `~/.claude/session-manager/browser/bookmarks.json` (PRD 402). */
+export interface BrowserBookmark {
+  url: string;
+  title: string;
+  ts: number;
+}
+
 export interface ReadJsonResult {
   exists: boolean;
   raw: string;
@@ -82,6 +148,8 @@ export interface SubscribeResult {
 export interface PersistedTab {
   id: string;
   claudeSessionId: string;
+  /** Chat mode's own session id, decoupled from claudeSessionId. Optional for backwards-compat with tabs.json written before this field existed. */
+  chatSessionId?: string;
   cwd: string;
   label: string;
   presetId: string | null;
@@ -435,12 +503,23 @@ export interface DayProjectRow {
   sessionCount: number;
   errorCount: number;
   estimatedCostUsd: number;
+  byModel: Record<string, {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    costUsd: number;
+    /** Set when the model id didn't match opus/sonnet/haiku and was priced at Sonnet rates as a fallback. */
+    estimated?: boolean;
+  }>;
 }
 
 export interface HistoryAggregateResult {
   rows: DayProjectRow[];
   partial: boolean;
   scannedMs: number;
+  /** Total $ saved across all rows from cache-read pricing vs. full input pricing. Global, not per-row. */
+  cacheSavingsUsd: number;
 }
 
 export interface SessionScanEntry {
@@ -932,6 +1011,54 @@ export interface SessionManagerAPI {
     onExit: (tabId: string, handler: (info: PtyExit) => void) => () => void;
     onWriteError: (handler: (ev: WriteErrorEvent) => void) => () => void;
   };
+  browser: {
+    create: (payload: { viewId: string; partition: string }) => Promise<{ ok: boolean }>;
+    setBounds: (payload: { viewId: string; x: number; y: number; width: number; height: number }) => Promise<{ ok: boolean }>;
+    show: (viewId: string) => Promise<{ ok: boolean }>;
+    hide: (viewId: string) => Promise<{ ok: boolean }>;
+    destroy: (viewId: string) => Promise<{ ok: boolean }>;
+    navigate: (payload: { viewId: string; url: string }) => Promise<{ ok: boolean; error?: string }>;
+    back: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    forward: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    reload: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    stop: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    onNavState: (viewId: string, handler: (state: BrowserNavState) => void) => () => void;
+    recordStart: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    recordStop: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    onRecordStep: (viewId: string, handler: (step: RecordStep) => void) => () => void;
+    captureDom: (payload: { viewId: string; kind: 'text' | 'html' }) => Promise<
+      | { ok: true; url: string; title: string; text: string; truncated?: boolean }
+      | { ok: false; error: string }
+    >;
+    captureShot: (viewId: string) => Promise<
+      | { ok: true; url: string; title: string; dataUrl: string }
+      | { ok: false; error: string }
+    >;
+    saveBinary: (path: string, base64: string) => Promise<{ ok: boolean; error?: string }>;
+    replay: (payload: {
+      viewId: string;
+      steps: RecordStep[];
+      values?: Record<string, string>;
+      continueOnError?: boolean;
+    }) => Promise<{ ok: boolean; error?: string; stopped?: boolean; failedAt?: number }>;
+    onReplayStep: (viewId: string, handler: (step: ReplayStepResult) => void) => () => void;
+    setZoom: (payload: { viewId: string; factor: number }) => Promise<{ ok: boolean; error?: string; factor?: number }>;
+    find: (payload: { viewId: string; text: string; forward?: boolean }) => Promise<{ ok: boolean; error?: string }>;
+    stopFind: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    onFindResult: (viewId: string, handler: (result: FindResult) => void) => () => void;
+    pickerStart: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    pickerStop: (viewId: string) => Promise<{ ok: boolean; error?: string; wasPicking?: boolean }>;
+    onPickerEvent: (viewId: string, handler: (ev: PickerEvent) => void) => () => void;
+    /** Selection-scoped capture pipeline (PRD 404): filter -> prune -> summarize -> chunk for 'agent', outerHTML for 'html', CDP AX-tree for 'a11y', fallback-chain for 'selector'. */
+    capture: (payload: {
+      viewId: string;
+      selectors: string[];
+      mode: 'agent' | 'html' | 'a11y' | 'selector';
+    }) => Promise<
+      | { ok: true; mode: string; text: string; meta: { chunks?: number; tokens?: number } }
+      | { ok: false; error: string }
+    >;
+  };
   transcripts: {
     subscribe: (payload: { tabId: string; cwd: string; sessionUuid: string }) => Promise<SubscribeResult>;
     /** Release the sub back to the LRU cache (view-switch). Does not destroy the watcher. */
@@ -1099,6 +1226,8 @@ export interface SessionManagerAPI {
       | { ok: true; path: string; bytes: number }
       | { ok: false; empty?: true; error?: string }
     >;
+    /** Write side — copies a Capture-panel screenshot data URL to the OS clipboard. */
+    copyImage: (dataUrl: string) => Promise<{ ok: boolean; error?: string }>;
   };
   memory: {
     /** List markdown memory entries for the given workspace (defaults to 'default'). */
@@ -1129,11 +1258,6 @@ export interface SessionManagerAPI {
     /** Delete one entry. Removes the file outright when last entry is removed. */
     delete: (agentId: string, entryId: string) => Promise<AgentMemoryMutationResult>;
   };
-  docEditor: {
-    pickFile: (payload?: { lastDir?: string }) => Promise<{ path: string | null; error?: string }>;
-    readFile: (path: string) => Promise<{ ok: boolean; text?: string; mtimeMs?: number; error?: string }>;
-    writeFile: (path: string, text: string) => Promise<{ ok: boolean; mtimeMs?: number; error?: string }>;
-  };
   git: {
     /** Full git status for `cwd`. Returns null when not a git repo, git is
      *  missing, or the call times out (5s ceiling). Cached per-cwd for 5s. */