claude-code-session-manager 0.35.2 → 0.35.4

package/src/main/chatRunner.cjs

@@ -26,6 +26,7 @@
  *   chat:run:complete   { tabId, sessionId, finalMessage }
  *   chat:run:needs-input { tabId, sessionId, questions, raw }
  *   chat:run:error      { tabId, sessionId, message }
+ *   chat:run:notice     { tabId, sessionId, message }        — informational, not terminal
  */
 
 const { spawn } = require('node:child_process');
@@ -71,6 +72,32 @@ function parseStopSignal(finalText) {
   }
 }
 
+// ─── MCP consent-denial detection ──────────────────────────────────────────
+// Best-effort substring heuristic over known CLI phrasing — NOT a documented
+// stream-json schema field. Confirmed by extracting strings from the compiled
+// `claude` CLI binary (2.1.207): a non-interactive/`-p` run that hits an
+// MCP server requiring first-party consent (e.g. `claude_design`) throws a
+// tool error whose message is exactly:
+//   "<tool label> The user hasn't granted this — run /design consent to
+//   grant it (it can't be approved automatically in this permission mode)."
+// which surfaces to stdout as a `tool_result` block (is_error: true) inside a
+// `type: "user"` stream-json event. Since consent flows exist for MCP servers
+// beyond `claude_design`, match on the generic phrasing rather than the
+// design-specific slash command.
+const MCP_CONSENT_DENIAL_MARKERS = [
+  "hasn't granted this",
+  'run /design consent',
+  'connect to claude design',
+  'requires consent',
+  'needs a claude.ai credential',
+];
+
+function hasMcpConsentDenial(text) {
+  if (typeof text !== 'string' || !text) return false;
+  const lower = text.toLowerCase();
+  return MCP_CONSENT_DENIAL_MARKERS.some((marker) => lower.includes(marker));
+}
+
 // Instruction prepended to every prompt. Tells the agent how to signal that
 // it needs clarification vs. having completed the task.
 const STOP_SIGNAL_INSTRUCTION =
@@ -188,6 +215,24 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume }) {
       broadcast(channel, payload);
     };
 
+    // Separate one-shot guard for the MCP-consent notice (orthogonal to
+    // terminalSent — a run can hit this mid-stream and still legitimately
+    // finish with a normal complete/error afterward).
+    let noticeSent = false;
+    const emitNoticeOnce = () => {
+      if (noticeSent) return;
+      noticeSent = true;
+      broadcast('chat:run:notice', {
+        tabId,
+        sessionId,
+        message:
+          'This run needs interactive consent for an MCP server (e.g. Claude Design), which ' +
+          "can't be granted in chat mode because stdin is closed for headless runs. Open a " +
+          'raw terminal session for this tab ("Back to chat" toggle) and grant consent there, ' +
+          'then retry.',
+      });
+    };
+
     const claudeBin = resolveClaudeBin();
     const childEnv = cleanChildEnv({ PATH: pathWithUserBins() });
 
@@ -285,6 +330,21 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume }) {
             broadcast('chat:run:tool-use', { tabId, id: block.id, ...classified });
           }
         }
+      } else if (event.type === 'user') {
+        // Tool results come back as content blocks on a synthetic "user" event.
+        // An MCP consent-denial surfaces here as an is_error tool_result whose
+        // text carries one of MCP_CONSENT_DENIAL_MARKERS.
+        const content = Array.isArray(event.message?.content) ? event.message.content : [];
+        for (const block of content) {
+          if (block.type !== 'tool_result') continue;
+          const inner = block.content;
+          const text = typeof inner === 'string'
+            ? inner
+            : Array.isArray(inner)
+              ? inner.filter((c) => c?.type === 'text' && typeof c.text === 'string').map((c) => c.text).join('\n')
+              : '';
+          if (hasMcpConsentDenial(text)) emitNoticeOnce();
+        }
       } else if (event.type === 'result') {
         // Use the authoritative `result` field when available; fall back to
         // accumulated assistant text (same content, different source).

package/src/main/config.cjs

@@ -103,7 +103,10 @@ function validateWrite(realAbs) {
     (p) => realAbs === p || realAbs.startsWith(p + path.sep)
   );
   if (inWritePrefix) return;
-  // Also allowed inside a registered project root's .claude/ subtree.
+  // Also allowed inside a registered project root's .claude/ subtree, OR its
+  // tests/fixtures/browser-capture/ subtree (PRD 407 "PRD fixture" capture
+  // destination — narrowly scoped to that one path segment, not a general
+  // project-root write grant).
   for (const root of allowedRoots) {
     if (root === os.homedir()) continue;
     let realRoot;
@@ -113,6 +116,17 @@ function validateWrite(realAbs) {
       if (realAbs === claudeSub || realAbs.startsWith(claudeSub + path.sep)) {
         return;
       }
+      const fixturesSub = path.join(realRoot, 'tests', 'fixtures', 'browser-capture');
+      if (realAbs === fixturesSub || realAbs.startsWith(fixturesSub + path.sep)) {
+        return;
+      }
+      // PRD 410 Recorder → Playwright-spec export: narrowly scoped to
+      // tests/e2e/ (matches the repo's existing e2e spec location), not a
+      // general project-root write grant.
+      const e2eSub = path.join(realRoot, 'tests', 'e2e');
+      if (realAbs === e2eSub || realAbs.startsWith(e2eSub + path.sep)) {
+        return;
+      }
     }
   }
   throw new Error(`Write outside allowed write boundaries: ${realAbs}`);
@@ -182,6 +196,27 @@ async function writeTextAtomic(abs, text, opts = {}) {
   return { ok: true, mtimeMs: stat.mtimeMs };
 }
 
+/**
+ * Binary-safe sibling of writeTextAtomic — same validate + tmp+rename flow,
+ * for callers (screenshot capture) whose payload is a Buffer, not utf8 text.
+ */
+async function writeBinaryAtomic(abs, buffer) {
+  const real = validatePath(expandHome(abs));
+  validateWrite(real);
+  const dir = path.dirname(real);
+  await fsp.mkdir(dir, { recursive: true });
+  const tmp = `${real}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    await fsp.writeFile(tmp, buffer);
+    await fsp.rename(tmp, real);
+  } catch (e) {
+    try { await fsp.unlink(tmp); } catch { /* tmp never created or already gone */ }
+    throw e;
+  }
+  const stat = await fsp.stat(real);
+  return { ok: true, mtimeMs: stat.mtimeMs };
+}
+
 async function writeJson(abs, data) {
   const pretty = JSON.stringify(data, null, 2) + '\n';
   return writeTextAtomic(abs, pretty);
@@ -374,6 +409,7 @@ module.exports = {
   writeJson,
   writeJsonSync,
   writeTextAtomic,
+  writeBinaryAtomic,
   listDir,
   exists,
   addAllowedRoot,

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,11 +7,14 @@ 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');
 const sessionsStore = require('./sessionsStore.cjs');
 const billing = require('./usage.cjs');
+const { probeMcpStatus } = require('./mcpStatus.cjs');
 const logs = require('./logs.cjs');
 const crashDiagnostics = require('./crashDiagnostics.cjs');
 // Start the local minidump collector before app-ready (required by Electron).
@@ -21,6 +24,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 +38,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 +269,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 } });
     });
@@ -403,6 +409,10 @@ ipcMain.handle('app:launch-mode', () => ({
   cwd: process.cwd(),
 }));
 
+// MCP Servers tab (PRD 456 consumes this): probes live connection status via
+// `claude mcp list`. Read-only, single in-flight call — no polling.
+ipcMain.handle('mcp:status', () => probeMcpStatus());
+
 ipcMain.handle('app:engage-rules-path', () => process.env.SESSION_MANAGER_ENGAGE_RULES || null);
 
 // Boot diagnostics — renderer polls these to surface toasts when `claude` isn't
@@ -445,6 +455,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 +696,6 @@ pluginInstall.registerPluginInstallHandlers();
 memoryTool.registerMemoryHandlers();
 registerMemoryAggregateIpc();
 agentMemory.registerAgentMemoryHandlers();
-registerDocEditorHandlers();
 git.register(ipcMain);
 superagent.registerSuperAgentHandlers();
 filesIpc.registerFilesHandlers();
@@ -774,6 +796,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 +998,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 +1013,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 +1105,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/mcpStatus.cjs

@@ -0,0 +1,93 @@
+'use strict';
+
+/**
+ * mcpStatus.cjs — probes live MCP server connection status by shelling out to
+ * `claude mcp list` (a plain subcommand, no LLM call — no --model pin needed).
+ *
+ * Read-only, non-polling: only runs on explicit renderer request (mcp:status
+ * IPC). Coalesces concurrent callers onto a single in-flight probe so bursts
+ * don't fan out into parallel `claude` processes.
+ */
+
+const { spawn } = require('node:child_process');
+const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
+
+const PROBE_TIMEOUT_MS = 30_000;
+
+// One server line: "<name>: <target> - <glyph> <status text>"
+const LINE_RE = /^(.+?):\s(.+?)\s-\s(\S+)\s*(.*)$/;
+
+/**
+ * Pure parser — no I/O. Extracts { name, target, transport, status } per
+ * server line. Ignores the "Checking MCP server health…" header and blank
+ * lines. Never throws: unparseable input yields [].
+ */
+function parseMcpList(stdout) {
+  if (!stdout || typeof stdout !== 'string') return [];
+  const servers = [];
+  for (const rawLine of stdout.split('\n')) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (line.toLowerCase().startsWith('checking mcp server health')) continue;
+    const m = LINE_RE.exec(line);
+    if (!m) continue;
+    const [, name, target, glyph, statusText] = m;
+    const transport = /\(HTTP\)$/.test(target) || /^https?:\/\//i.test(target) ? 'http' : 'stdio';
+    let status;
+    if (glyph === '✔') status = 'connected';
+    else if (glyph === '✘') status = 'failed';
+    else if (glyph === '!') status = 'needs-auth';
+    else if (glyph === '⏸') status = 'pending';
+    else status = 'unknown';
+    servers.push({ name: name.trim(), target: target.trim(), transport, status, statusText: statusText.trim() });
+  }
+  return servers;
+}
+
+let inFlight = null;
+
+/** Spawns `claude mcp list`, parses it. Resolves — never rejects. */
+function runProbe() {
+  return new Promise((resolve) => {
+    let bin;
+    try { bin = resolveClaudeBin(); } catch (e) {
+      resolve({ ok: false, servers: [], error: `claude not found: ${e?.message}`, checkedAt: Date.now() });
+      return;
+    }
+    let child;
+    try {
+      child = spawn(bin, ['mcp', 'list'], { env: process.env, stdio: ['ignore', 'pipe', 'pipe'] });
+    } catch (e) {
+      resolve({ ok: false, servers: [], error: e?.message || 'spawn error', checkedAt: Date.now() });
+      return;
+    }
+    let out = '';
+    let err = '';
+    const MAX_OUT_BYTES = 1 * 1024 * 1024;
+    let settled = false;
+    const finish = (result) => { if (!settled) { settled = true; clearTimeout(timer); resolve(result); } };
+    const timer = setTimeout(() => {
+      try { child.kill('SIGKILL'); } catch { /* */ }
+      finish({ ok: false, servers: [], error: 'timeout', checkedAt: Date.now() });
+    }, PROBE_TIMEOUT_MS);
+    child.stdout.on('data', (d) => { if (out.length < MAX_OUT_BYTES) out += d; });
+    child.stderr.on('data', (d) => { if (err.length < MAX_OUT_BYTES) err += d; });
+    child.on('error', (e) => { finish({ ok: false, servers: [], error: e?.message || 'spawn error', checkedAt: Date.now() }); });
+    child.on('close', (code) => {
+      if (code !== 0 && !out) {
+        finish({ ok: false, servers: [], error: err.slice(0, 500) || `exit ${code}`, checkedAt: Date.now() });
+        return;
+      }
+      finish({ ok: true, servers: parseMcpList(out), checkedAt: Date.now() });
+    });
+  });
+}
+
+/** Public entry point. Coalesces concurrent callers onto one in-flight probe. */
+function probeMcpStatus() {
+  if (inFlight) return inFlight;
+  inFlight = runProbe().finally(() => { inFlight = null; });
+  return inFlight;
+}
+
+module.exports = { probeMcpStatus, parseMcpList };