claude-mission-control 1.22.0 → 1.24.0

package/README.md

@@ -137,6 +137,27 @@ Model, context use, your 5-hour limit, and this session's cost come from Claude
 { "statusLine": { "type": "command", "command": "claude-dashboard statusline", "padding": 0 } }
 ```
 
+## MCP server: let Claude ask Mission Control
+
+`claude-dashboard mcp` is a read-only MCP server, so a Claude Code session can see what your other sessions are doing and search your past ones. Connect it once for every project:
+
+```bash
+claude mcp add --scope user mission-control -- claude-dashboard mcp
+```
+
+Then ask things like *"what did we decide about the contact form last week?"* or *"which sessions changed functions.php?"*. Four tools, none of which change anything:
+
+- `live_sessions`: what is running now, which sessions wait on you and why, cost, context.
+- `search_sessions`: the dashboard's search (prompts, titles, notes, transcripts) with the same filters.
+- `read_session`: the latest turns of one session.
+- `usage_summary`: 5-hour and weekly limits, when your pace runs out, this week's cost by project.
+
+It answers from the running dashboard on `127.0.0.1`, so start the dashboard first. It needs a global install (npm or Homebrew), not npx.
+
+## Search filters
+
+Search takes filters anywhere in the query: `project:<name>`, `since:7d` or `since:2026-11-01`, `m:<model>` (any model the session used), `b:<branch>` (the branch it started on), and `file:<name>` (a file it changed, from the same file history as the changes panel). A filter on its own, such as `file:functions.php`, lists every session that matches.
+
 ## Install (always-on)
 
 ```bash
@@ -311,7 +332,8 @@ Edit `ignore.json` — an array of absolute path prefixes. A project is hidden i
 | `CLAUDE_DASH_HOST` | `127.0.0.1` | Bind address — see below before changing |
 | `CLAUDE_DASH_DEMO` | unset | `1` = serve believable fake data (screenshots, trying it without Claude history) |
 | `CLAUDE_DASH_OPEN` | unset | `1` = open the browser on startup (what `npx` sets for you) |
-| `CLAUDE_DASH_CONFIG_DIR` | repo dir | Where config.json/names.json/ignore.json live (auto-falls back to `~/.config/claude-dashboard`) |
+| `CLAUDE_DASH_CONFIG_DIR` | repo dir (git checkout) | Where config.json/names.json/ignore.json/chats.json live. Non-git installs (npm, npx) use `~/.config/claude-dashboard`; files from older versions are copied there on first run |
+| `CLAUDE_DASH_ALLOWED_HOSTS` | — | Comma-separated extra hostnames accepted in the Host header, e.g. your MagicDNS name behind `tailscale serve`. Anything else gets 403 (DNS-rebinding protection) |
 
 The server binds to `127.0.0.1` only by default.
 

package/bin/claude-dashboard.js

@@ -6,8 +6,12 @@
 // and never auto-open).
 // `claude-dashboard statusline` prints one line for Claude Code's statusLine
 // setting instead of starting anything.
+// `claude-dashboard mcp` is a read-only MCP server over stdio for Claude Code
+// (`claude mcp add --scope user mission-control -- claude-dashboard mcp`).
 if (process.argv[2] === 'statusline') {
   require('../lib/statusline').runStatusline();
+} else if (process.argv[2] === 'mcp') {
+  require('../lib/mcp').runMcp();
 } else {
   if (!process.argv.includes('--no-open')) process.env.CLAUDE_DASH_OPEN = '1';
   require('../server.js');

package/lib/changes.js

@@ -42,9 +42,12 @@ function mergeChanges(target, src) {
 
 // Real path for a file-history entry: the key/trackingPath can be an odd
 // encoded form, but realParentDir is always the true directory.
+// Keys use forward slashes on every platform, like canonical project paths,
+// so relPath can shorten them against the project root.
 function realPathOf(key, backup) {
   if (!backup || !backup.realParentDir || !key) return null;
-  return path.join(backup.realParentDir, path.basename(String(key)));
+  const dir = String(backup.realParentDir).replace(/\\/g, '/').replace(/\/+$/, '');
+  return `${dir}/${String(key).replace(/\\/g, '/').split('/').pop()}`;
 }
 
 const SESSION_ID = /^[0-9a-f-]{8,64}$/i;

package/lib/chats.js

@@ -95,7 +95,15 @@ function readChats() {
 // Normalize the raw export and persist. Returns the imported count.
 function saveChats(raw) {
   const chats = normalizeChats(raw);
-  fs.writeFileSync(CHATS_FILE, JSON.stringify(chats));
+  // Atomic, like config: a failed write keeps the previous import intact.
+  const tmp = `${CHATS_FILE}.${process.pid}.tmp`;
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(chats));
+    fs.renameSync(tmp, CHATS_FILE);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch { /* already gone */ }
+    throw e;
+  }
   cache = { mtimeMs: 0, chats: [] }; // next read picks up the new file
   return chats.length;
 }

package/lib/collector.js

@@ -7,7 +7,7 @@ const { readQuota } = require('./quota');
 const { fetchOauthUsage } = require('./usage');
 const { readRegistry } = require('./registry');
 const { refreshHistory, activityBuckets, weekHourHeat } = require('./history');
-const { scanAllTranscripts, scanFile, groupByProject, sessionTitle, sessionKind, combinedUsage, combinedDays, dailyCostSeries, subagentSummary, usageBreakdown, dayKey, reasonText, contextSummary, toolSummary } = require('./transcripts');
+const { scanAllTranscripts, scanFile, groupByProject, sessionTitle, sessionKind, combinedUsage, combinedDays, dailyCostSeries, subagentSummary, usageBreakdown, dayKey, reasonText, contextSummary, toolSummary, scannerHealth } = require('./transcripts');
 const { collectGitStatus } = require('./gitstatus');
 const { friendlyName } = require('./names');
 const { isIgnored } = require('./ignore');
@@ -165,6 +165,13 @@ class Collector {
     const sessions = await scanAllTranscripts();
     this.raw.transcriptGroups = groupByProject(sessions);
     this.raw.metaBySession = new Map(sessions.map((m) => [m.sessionId, m]));
+    // Say so once per distinct problem, not every 15s scan.
+    const warnings = scannerHealth(sessions);
+    const key = warnings.join('|');
+    if (key !== this.scanWarningKey) {
+      this.scanWarningKey = key;
+      for (const w of warnings) this.noteError('scan', w);
+    }
     this.raw.history = await refreshHistory();
     this.raw.teams = await readTeams();
     // Task summaries for recent sessions (readTasks caches by dir mtime).

package/lib/config.js

@@ -9,25 +9,48 @@ const { loadPricing } = require('./pricing');
 
 const ROOT = path.join(__dirname, '..');
 
-// Config lives beside the code when that's writable (git checkout — the
-// original layout). Under npx / a global npm install the package dir may be
-// read-only or ephemeral, so fall back to ~/.config/claude-dashboard.
-// CLAUDE_DASH_CONFIG_DIR overrides both.
+// Every user file the dashboard keeps. All live in one directory.
+const USER_FILES = ['config.json', 'names.json', 'ignore.json', 'chats.json'];
+
+// Pure: where user files live. CLAUDE_DASH_CONFIG_DIR wins. A writable git
+// checkout keeps them beside the code (the original layout; they're
+// gitignored). Anything else — a global npm install, the npx cache, brew, an
+// unpacked zip — is a tree a package manager or the self-updater may
+// replace wholesale, so user data goes to ~/.config/claude-dashboard.
+function chooseConfigDir({ env, rootIsGit, rootWritable, root, home }) {
+  if (env) return { dir: env, migrateFrom: null };
+  if (rootIsGit && rootWritable) return { dir: root, migrateFrom: null };
+  return { dir: path.join(home, '.config', 'claude-dashboard'), migrateFrom: root };
+}
+
 function resolveConfigDir() {
-  const os = require('os');
-  const env = process.env.CLAUDE_DASH_CONFIG_DIR;
-  if (env) {
-    fs.mkdirSync(env, { recursive: true });
-    return env;
-  }
+  let rootWritable = true;
   try {
     fs.accessSync(ROOT, fs.constants.W_OK);
-    return ROOT;
   } catch {
-    const dir = path.join(os.homedir(), '.config', 'claude-dashboard');
-    fs.mkdirSync(dir, { recursive: true });
-    return dir;
+    rootWritable = false;
   }
+  const { dir, migrateFrom } = chooseConfigDir({
+    env: process.env.CLAUDE_DASH_CONFIG_DIR,
+    rootIsGit: fs.existsSync(path.join(ROOT, '.git')),
+    rootWritable,
+    root: ROOT,
+    home: require('os').homedir(),
+  });
+  fs.mkdirSync(dir, { recursive: true });
+  // Older versions wrote user files into the package dir even for npm
+  // installs. Copy (never move) any that aren't in the new home yet, so the
+  // first run on this version keeps names, notes, pins and the phone key.
+  if (migrateFrom) {
+    for (const f of USER_FILES) {
+      const from = path.join(migrateFrom, f);
+      const to = path.join(dir, f);
+      try {
+        if (fs.existsSync(from) && !fs.existsSync(to)) fs.copyFileSync(from, to);
+      } catch { /* unreadable old file: start fresh rather than fail to boot */ }
+    }
+  }
+  return dir;
 }
 const CONFIG_DIR = resolveConfigDir();
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
@@ -55,14 +78,46 @@ function readJson(file, fallback) {
   }
 }
 
+// For read-modify-write paths. A missing file is a fresh start; a file that
+// exists but won't parse (hand-edit typo, partial write from an older
+// version) must NOT be treated as empty — writing back would wipe every
+// name, note, pin and the phone key. Refuse, and say which file.
+function readJsonForWrite(file, fallback) {
+  let text;
+  try {
+    text = fs.readFileSync(file, 'utf8');
+  } catch (e) {
+    if (e.code === 'ENOENT') return fallback;
+    throw e;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`${path.basename(file)} is not valid JSON; fix or remove ${file} and try again`);
+  }
+}
+
+// Atomic: write a sibling temp file, then rename over the target. A crash
+// or full disk mid-write leaves the old file intact instead of truncated.
 function writeJson(file, value) {
-  fs.writeFileSync(file, JSON.stringify(value, null, 2) + '\n');
+  const tmp = `${file}.${process.pid}.tmp`;
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(value, null, 2) + '\n');
+    fs.renameSync(tmp, file);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch { /* already gone */ }
+    throw e;
+  }
 }
 
 function readConfig() {
   return { ...DEFAULTS, ...readJson(CONFIG_FILE, {}) };
 }
 
+function readConfigForWrite() {
+  return { ...DEFAULTS, ...readJsonForWrite(CONFIG_FILE, {}) };
+}
+
 // Rate table: Claude Code's managed `modelPricing` first (contracted rates
 // an admin deployed), then the same key in our config.json, then bundled
 // list prices. Both files are small; read fresh every call like readConfig.
@@ -72,7 +127,7 @@ function readPricing() {
 }
 
 function updateConfig(patch) {
-  const next = { ...readConfig() };
+  const next = readConfigForWrite();
   if (typeof patch.terminal === 'string') next.terminal = patch.terminal;
   if (typeof patch.notifications === 'boolean') next.notifications = patch.notifications;
   if (typeof patch.usageApi === 'boolean') next.usageApi = patch.usageApi;
@@ -96,7 +151,7 @@ function updateConfig(patch) {
 
 // Add or remove a project from the notification mute list.
 function setProjectMuted(projectPath, muted) {
-  const next = { ...readConfig() };
+  const next = readConfigForWrite();
   const key = canonicalize(projectPath);
   const list = (next.mutedProjects || []).filter((p) => canonicalize(p).toLowerCase() !== key.toLowerCase());
   if (muted) list.push(key);
@@ -107,7 +162,7 @@ function setProjectMuted(projectPath, muted) {
 
 // Pin or unpin a session for the pinned strip. Returns the new pinned state.
 function togglePin(sessionId) {
-  const next = { ...readConfig() };
+  const next = readConfigForWrite();
   const list = next.pinnedSessions || [];
   const has = list.includes(sessionId);
   next.pinnedSessions = has ? list.filter((id) => id !== sessionId) : [...list, sessionId];
@@ -126,7 +181,7 @@ function applySessionName(sessionNames, sessionId, name) {
 }
 
 function setSessionName(sessionId, name) {
-  const next = { ...readConfig() };
+  const next = readConfigForWrite();
   next.sessionNames = applySessionName(next.sessionNames, sessionId, name);
   writeJson(CONFIG_FILE, next);
   return next.sessionNames[sessionId] || '';
@@ -144,7 +199,7 @@ function applySessionNote(sessionNotes, sessionId, note) {
 }
 
 function setSessionNote(sessionId, note) {
-  const next = { ...readConfig() };
+  const next = readConfigForWrite();
   next.sessionNotes = applySessionNote(next.sessionNotes, sessionId, note);
   writeJson(CONFIG_FILE, next);
   return next.sessionNotes[sessionId] || '';
@@ -155,7 +210,7 @@ function readNames() {
 }
 
 function setName(projectPath, name) {
-  const names = readNames();
+  const names = readJsonForWrite(NAMES_FILE, {});
   const key = canonicalize(projectPath);
   // Stored keys may differ in case from the canonical path — replace any match.
   for (const k of Object.keys(names)) {
@@ -171,7 +226,8 @@ function readIgnores() {
 }
 
 function addIgnore(prefix) {
-  const list = readIgnores();
+  const raw = readJsonForWrite(IGNORE_FILE, []);
+  const list = Array.isArray(raw) ? raw : [];
   const key = canonicalize(prefix);
   if (!list.some((p) => canonicalize(p).toLowerCase() === key.toLowerCase())) {
     list.push(key);
@@ -181,14 +237,16 @@ function addIgnore(prefix) {
 
 function removeIgnore(prefix) {
   const key = canonicalize(prefix).toLowerCase();
-  writeJson(IGNORE_FILE, readIgnores().filter((p) => canonicalize(p).toLowerCase() !== key));
+  const raw = readJsonForWrite(IGNORE_FILE, []);
+  writeJson(IGNORE_FILE, (Array.isArray(raw) ? raw : []).filter((p) => canonicalize(p).toLowerCase() !== key));
 }
 
 // Walk PATH for a binary; `exists` injected so the walk is unit-testable.
+// Linux-only (detectTerminals), so PATH is ':'-separated with posix joins.
 function findOnPath(name, pathEnv = process.env.PATH || '', exists = fs.existsSync) {
-  for (const dir of String(pathEnv).split(path.delimiter)) {
+  for (const dir of String(pathEnv).split(':')) {
     if (!dir) continue;
-    const p = path.join(dir, name);
+    const p = path.posix.join(dir, name);
     if (exists(p)) return p;
   }
   return null;
@@ -257,6 +315,9 @@ module.exports = {
   readConfig,
   readPricing,
   configDir: () => CONFIG_DIR,
+  chooseConfigDir,
+  writeJson,
+  readJsonForWrite,
   findOnPath,
   detectClaudeApp,
   resolvedTerminal,

package/lib/guard.js

@@ -0,0 +1,58 @@
+'use strict';
+// Request guards for the main listener. Pure, so they're unit-testable.
+//
+// DNS rebinding: a page on evil.example can re-point its own name at
+// 127.0.0.1 and then read our GET routes as same-origin. The browser still
+// sends `Host: evil.example`, so an EXACT hostname match on the Host header
+// is the defence. A prefix match is not: `localhost.evil.example` is a name
+// an attacker controls.
+
+const LOOPBACK_NAMES = new Set(['127.0.0.1', 'localhost', '[::1]']);
+
+// Hostname part of a Host header value, lowercased: 'LocalHost:4517' ->
+// 'localhost', '[::1]:4517' -> '[::1]'. Empty string for garbage.
+function hostnameOf(hostHeader) {
+  const h = String(hostHeader || '').trim().toLowerCase();
+  if (!h) return '';
+  if (h.startsWith('[')) {
+    const end = h.indexOf(']');
+    return end === -1 ? '' : h.slice(0, end + 1);
+  }
+  const colon = h.indexOf(':');
+  return colon === -1 ? h : h.slice(0, colon);
+}
+
+// `bindHost` is what the server listens on. Accepted: loopback names, any
+// name the user listed in `extraHosts` (CLAUDE_DASH_ALLOWED_HOSTS — e.g. the
+// MagicDNS name `tailscale serve` forwards), and, when bound off-loopback,
+// the bind address itself. A wildcard bind (0.0.0.0) adds nothing: list names.
+function allowedHost(hostHeader, bindHost, extraHosts = []) {
+  const name = hostnameOf(hostHeader);
+  if (!name) return false;
+  if (LOOPBACK_NAMES.has(name)) return true;
+  if (extraHosts.some((h) => hostnameOf(h) === name)) return true;
+  return bindHost !== '127.0.0.1' && bindHost !== '0.0.0.0' && bindHost !== '::' && !!bindHost && name === bindHost.toLowerCase();
+}
+
+// For state-changing routes. Browsers always send Origin on cross-origin
+// POSTs; a missing Origin means a non-browser client (curl), which the Host
+// check has already vetted. A present Origin must name exactly the host the
+// request was sent to, so a page can never POST across origins, whatever
+// the bind address.
+function sameOrigin(originHeader, hostHeader) {
+  if (originHeader === undefined) return true;
+  let origin;
+  try {
+    origin = new URL(String(originHeader));
+  } catch {
+    return false; // includes the literal 'null' origin from sandboxed frames
+  }
+  if (origin.protocol !== 'http:' && origin.protocol !== 'https:') return false;
+  return origin.host.toLowerCase() === String(hostHeader || '').trim().toLowerCase();
+}
+
+function parseAllowedHosts(env) {
+  return String(env || '').split(',').map((s) => s.trim()).filter(Boolean);
+}
+
+module.exports = { hostnameOf, allowedHost, sameOrigin, parseAllowedHosts };

package/lib/ignore.js

@@ -6,7 +6,7 @@ const fs = require('fs');
 const path = require('path');
 const { canonicalize } = require('./paths');
 
-const IGNORE_FILE = path.join(__dirname, '..', 'ignore.json');
+const IGNORE_FILE = path.join(require('./config').configDir(), 'ignore.json');
 
 let cache = { mtimeMs: 0, prefixes: [] };
 

package/lib/mcp.js

@@ -0,0 +1,282 @@
+'use strict';
+// `claude-dashboard mcp`: a Model Context Protocol server over stdio, so a
+// Claude Code session can ask Mission Control what the other sessions are
+// doing, search past ones, and check limits. Read-only by construction: the
+// four tools below are the whole surface, and each one is a fixed GET to the
+// running dashboard on 127.0.0.1 — no listener, nothing that runs a command.
+// The pure handler takes `get` so tests drive it without a server.
+const http = require('http');
+const readline = require('readline');
+const { version: VERSION } = require('../package.json');
+const { parseSearchQuery } = require('./search');
+
+const PROTOCOLS = ['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05'];
+const SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const READ_ONLY = { readOnlyHint: true, openWorldHint: false };
+
+const MCP_TOOLS = [
+  {
+    name: 'live_sessions',
+    description:
+      'Claude Code sessions running on this machine right now, sessions waiting on the user first: project, title, status, ' +
+      'what a waiting session needs, model, estimated cost so far and burn rate, context use, and its latest action.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    annotations: { title: 'Live sessions', ...READ_ONLY },
+  },
+  {
+    name: 'search_sessions',
+    description:
+      'Search past and present Claude Code sessions on this machine: every prompt the user sent, session titles, the ' +
+      "user's session notes and (deep, the default) full transcripts. Filters go in the query: project:<name>, " +
+      'since:7d or since:YYYY-MM-DD, m:<model>, b:<branch>, file:<changed file>. A filter-only query such as ' +
+      '"file:functions.php" lists the sessions that changed that file. Use read_session on a sessionId to read one.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', minLength: 2, maxLength: 200, description: 'Words to find, plus any filters.' },
+        deep: { type: 'boolean', description: 'Also search full transcripts (slower). Default true.' },
+      },
+      required: ['query'],
+      additionalProperties: false,
+    },
+    annotations: { title: 'Search sessions', ...READ_ONLY },
+  },
+  {
+    name: 'read_session',
+    description:
+      "One session's recent turns: what the user said, Claude's replies, and the tools it called with a short summary " +
+      'of each input. Long messages are clipped.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sessionId: { type: 'string', description: 'A session id from live_sessions or search_sessions.' },
+        last: { type: 'integer', minimum: 1, maximum: 200, description: 'How many of the latest turns to return. Default 40.' },
+      },
+      required: ['sessionId'],
+      additionalProperties: false,
+    },
+    annotations: { title: 'Read session', ...READ_ONLY },
+  },
+  {
+    name: 'usage_summary',
+    description:
+      "The user's Claude usage: 5-hour and weekly limit use with reset times, when the current pace runs out, this " +
+      "week's sessions, prompts and estimated cost by project, all-time totals, and the most expensive sessions. Costs are " +
+      'estimates at list price.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    annotations: { title: 'Usage summary', ...READ_ONLY },
+  },
+];
+
+const iso = (t) => (typeof t === 'number' && Number.isFinite(t) ? new Date(t).toISOString() : null);
+const isoAny = (t) => (typeof t === 'string' ? iso(Date.parse(t)) : iso(t));
+
+function liveSummary(state) {
+  const sessions = (state.liveSessions || []).map((s) => ({
+    sessionId: s.sessionId,
+    project: s.projectName,
+    title: s.title || null,
+    status: s.status,
+    needsYou: s.status === 'waiting',
+    waitingFor: s.waitingFor || null,
+    waitingReason: s.waitingReason || null,
+    model: s.model || null,
+    estCost: s.estCost ?? null,
+    burnRatePerHour: s.burnRate ?? null,
+    contextPct: s.context ? s.context.pct : null,
+    lastAction: s.lastAction ? [s.lastAction.verb, s.lastAction.target].filter(Boolean).join(' ') : null,
+    background: Boolean(s.background),
+    startedAt: iso(s.startedAt),
+  }));
+  sessions.sort((a, b) => Number(b.needsYou) - Number(a.needsYou));
+  return { sessions };
+}
+
+function searchSummary(r) {
+  const out = {
+    prompts: (r.prompts || []).map((p) => ({ project: p.projectName, sessionId: p.sessionId, at: iso(p.timestamp), text: p.snippet })),
+    titles: (r.titles || []).map((t) => ({ project: t.projectName, sessionId: t.sessionId, at: iso(t.lastActivityAt), title: t.title })),
+    notes: (r.notes || []).map((n) => ({ project: n.projectName, sessionId: n.sessionId, at: iso(n.lastActivityAt), note: n.snippet })),
+  };
+  if (r.transcripts) {
+    out.transcripts = {
+      matches: r.transcripts.matches.map((m) => ({ project: m.projectName, sessionId: m.sessionId, role: m.role, at: iso(m.ts), text: m.text })),
+      scanned: r.transcripts.scanned,
+      total: r.transcripts.total,
+      complete: r.transcripts.complete,
+    };
+  }
+  return out;
+}
+
+function sessionSummary(r, last) {
+  const all = r.events || [];
+  const events = all.slice(-last).map((e) =>
+    e.kind === 'tool'
+      ? { kind: 'tool', at: iso(e.ts), tool: e.name, input: e.input }
+      : { kind: e.kind, at: iso(e.ts), text: e.text, ...(e.truncated ? { clipped: true } : {}) }
+  );
+  return {
+    sessionId: r.sessionId,
+    title: r.title || null,
+    project: r.projectName || null,
+    note: r.note || null,
+    filesChanged: r.changeCount || 0,
+    earlierTurnsOmitted: Math.max(0, all.length - events.length) + (r.truncatedTurns || 0),
+    events,
+  };
+}
+
+function usageSummary(state, stats) {
+  const q = state.quota || {};
+  const f = state.forecast || {};
+  return {
+    limits: {
+      fiveHourPct: q.utilization ?? null,
+      fiveHourResetsAt: isoAny(q.resetsAt),
+      fiveHourRunsOutAt: iso(f.session && f.session.hitAt),
+      weeklyPct: q.weeklyUtilization ?? null,
+      weeklyResetsAt: isoAny(q.weeklyResetsAt),
+      weekRunsOutAt: iso(f.week && f.week.hitAt),
+      stale: Boolean(q.stale),
+    },
+    week: stats.week || null,
+    allTime: stats.totals || null,
+    topSessions: (stats.topSessions || []).slice(0, 5).map((s) => ({
+      sessionId: s.sessionId, title: s.title, project: s.projectName, model: s.model, cost: s.cost, at: iso(s.lastActivityAt),
+    })),
+  };
+}
+
+const text = (obj) => ({ content: [{ type: 'text', text: JSON.stringify(obj) }] });
+const toolError = (msg) => ({ content: [{ type: 'text', text: msg }], isError: true });
+
+async function runTool(name, args, get) {
+  if (name === 'live_sessions') return text(liveSummary(await get('/api/state')));
+  if (name === 'search_sessions') {
+    const q = typeof args.query === 'string' ? args.query.trim() : '';
+    if (q.length < 2 || q.length > 200) return toolError('query must be 2 to 200 characters.');
+    const deep = args.deep === false ? '0' : '1';
+    // Echo what the query meant: every result passed these filters, which a
+    // filter-only query's matches can't show on their own.
+    const p = parseSearchQuery(q);
+    const filters = {};
+    for (const k of ['project', 'model', 'branch', 'file']) if (p[k]) filters[k] = p[k];
+    if (p.since) filters.since = iso(p.since);
+    const found = searchSummary(await get(`/api/search?q=${encodeURIComponent(q)}&deep=${deep}`));
+    return text({ matchedText: p.text || null, filters, ...found });
+  }
+  if (name === 'read_session') {
+    const id = typeof args.sessionId === 'string' ? args.sessionId.trim() : '';
+    if (!SESSION_ID.test(id)) return toolError('sessionId must be a session id (a UUID) from live_sessions or search_sessions.');
+    const last = Number.isInteger(args.last) ? Math.min(200, Math.max(1, args.last)) : 40;
+    return text(sessionSummary(await get(`/api/session?id=${id}`), last));
+  }
+  if (name === 'usage_summary') {
+    const [state, stats] = await Promise.all([get('/api/state'), get('/api/stats')]);
+    return text(usageSummary(state, stats));
+  }
+  return null;
+}
+
+// One JSON-RPC message in, one reply out (null for notifications).
+function createMcpHandler({ get, port = 4517 }) {
+  return async function handle(msg) {
+    const isRequest = msg && msg.id !== undefined && msg.id !== null;
+    if (!isRequest) return null;
+    const reply = (result) => ({ jsonrpc: '2.0', id: msg.id, result });
+    const fail = (code, message) => ({ jsonrpc: '2.0', id: msg.id, error: { code, message } });
+    const params = msg.params || {};
+    switch (msg.method) {
+      case 'initialize':
+        return reply({
+          protocolVersion: PROTOCOLS.includes(params.protocolVersion) ? params.protocolVersion : PROTOCOLS[0],
+          capabilities: { tools: {} },
+          serverInfo: { name: 'mission-control', title: 'Claude Mission Control', version: VERSION },
+          instructions:
+            'Read-only view of the Claude Code sessions on this machine, from the Mission Control dashboard. ' +
+            'Use search_sessions to find past work and decisions, read_session to read one, live_sessions for what is ' +
+            'running now, usage_summary for limits and cost.',
+        });
+      case 'ping':
+        return reply({});
+      case 'tools/list':
+        return reply({ tools: MCP_TOOLS });
+      case 'tools/call': {
+        if (!MCP_TOOLS.some((t) => t.name === params.name)) return fail(-32602, `Unknown tool: ${String(params.name).slice(0, 60)}`);
+        try {
+          return reply(await runTool(params.name, params.arguments || {}, get));
+        } catch (e) {
+          if (e && (e.code === 'ECONNREFUSED' || e.code === 'ECONNRESET')) {
+            return reply(toolError(
+              `Mission Control isn't running at http://127.0.0.1:${port}. Start it with \`claude-dashboard\` ` +
+              '(or `brew services start claude-dashboard`), then try again.'
+            ));
+          }
+          return reply(toolError(`Mission Control error: ${String(e && e.message).slice(0, 200)}`));
+        }
+      }
+      default:
+        return fail(-32601, `Method not found: ${String(msg.method).slice(0, 60)}`);
+    }
+  };
+}
+
+// GET a dashboard endpoint on loopback. The path is always one built above.
+function dashGet(port, timeoutMs = 15000) {
+  return (p) =>
+    new Promise((resolve, reject) => {
+      const req = http.get({ host: '127.0.0.1', port, path: p, timeout: timeoutMs }, (res) => {
+        let body = '';
+        res.setEncoding('utf8');
+        res.on('data', (c) => (body += c));
+        res.on('end', () => {
+          if (res.statusCode === 404) return reject(new Error('not found (unknown session?)'));
+          if (res.statusCode !== 200) return reject(new Error(`dashboard answered ${res.statusCode}`));
+          try {
+            resolve(JSON.parse(body));
+          } catch {
+            reject(new Error('dashboard sent something that is not JSON'));
+          }
+        });
+      });
+      req.on('timeout', () => req.destroy(new Error('dashboard took too long to answer')));
+      req.on('error', reject);
+    });
+}
+
+// stdio transport: newline-delimited JSON-RPC. stdout carries only protocol
+// messages; anything else goes to stderr.
+function runMcp() {
+  const port = Number(process.env.CLAUDE_DASH_PORT) || 4517;
+  const handle = createMcpHandler({ get: dashGet(port), port });
+  const send = (m) => process.stdout.write(JSON.stringify(m) + '\n');
+  const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+  // Replies are async; on stdin close, finish the ones in flight, then exit.
+  let pending = 0;
+  let closed = false;
+  const maybeExit = () => closed && pending === 0 && process.exit(0);
+  rl.on('line', (line) => {
+    if (!line.trim()) return;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } });
+      return;
+    }
+    pending++;
+    handle(msg)
+      .then((r) => r && send(r), (e) => process.stderr.write(`mcp: ${e && e.stack}\n`))
+      .finally(() => {
+        pending--;
+        maybeExit();
+      });
+  });
+  rl.on('close', () => {
+    closed = true;
+    maybeExit();
+  });
+}
+
+module.exports = { createMcpHandler, MCP_TOOLS, runMcp, liveSummary, searchSummary, sessionSummary, usageSummary };

package/lib/names.js

@@ -4,7 +4,7 @@ const fs = require('fs');
 const path = require('path');
 const { canonicalize } = require('./paths');
 
-const NAMES_FILE = path.join(__dirname, '..', 'names.json');
+const NAMES_FILE = path.join(require('./config').configDir(), 'names.json');
 
 let cache = { mtimeMs: 0, map: {} };
 
@@ -28,7 +28,7 @@ function loadNames() {
 const GENERIC = new Set(['app', 'public', 'wp-content', 'themes', 'plugins', 'src', 'site']);
 
 function displayBase(p) {
-  const parts = canonicalize(p).split(path.sep).filter(Boolean);
+  const parts = canonicalize(p).split('/').filter(Boolean); // canonical form is '/' everywhere
   for (let i = parts.length - 1; i >= 0; i--) {
     if (!GENERIC.has(parts[i].toLowerCase())) return parts[i];
   }

package/lib/paths.js

@@ -10,11 +10,16 @@ const CLAUDE_DIR = path.join(os.homedir(), '.claude');
 // no trailing slash. Display strings keep whatever the source gave us.
 function canonicalize(p) {
   if (!p) return p;
-  // Don't run path.resolve on a Windows-style path when we're not on Windows
-  // (it would prefix the posix cwd) — those appear in tests and in data
-  // copied between machines.
+  // Don't resolve a path written for the other platform: on posix,
+  // path.resolve would prefix a Windows path with the cwd; on Windows, it
+  // would put the current drive on a posix path. Both appear in tests and in
+  // data copied between machines. (`//server` is a UNC path, so it resolves.)
   const winStyle = /^[A-Za-z]:[\\/]/.test(p);
-  let r = winStyle && process.platform !== 'win32' ? p : path.resolve(p);
+  const posixStyle = /^\/(?!\/)/.test(p);
+  let r;
+  if (winStyle && process.platform !== 'win32') r = p;
+  else if (posixStyle && process.platform === 'win32') r = path.posix.normalize(p);
+  else r = path.resolve(p);
   r = r.replace(/\\/g, '/');
   if (r.length > 1 && r.endsWith('/')) r = r.slice(0, -1);
   return r;

package/lib/search.js

@@ -13,11 +13,20 @@ const MAX_RESULTS = 60;
 // 'project:dashboard since:7d fix the build' -> filters plus remaining text.
 // project: substring-matches the canonical project path; since: takes Nd or
 // YYYY-MM-DD (local). Malformed values are dropped rather than erroring.
+// m:/model:, b:/branch: and file: are session filters: substring matches on
+// any model the session used, the branch it started on, and the paths of the
+// files it changed.
 function parseSearchQuery(q, now = Date.now()) {
   let project = null;
   let since = null;
+  let model = null;
+  let branch = null;
+  let file = null;
   const text = String(q)
     .replace(/(?:^|\s)project:(\S+)/i, (_, v) => { project = v.toLowerCase(); return ' '; })
+    .replace(/(?:^|\s)(?:m|model):(\S+)/i, (_, v) => { model = v.toLowerCase(); return ' '; })
+    .replace(/(?:^|\s)(?:b|branch):(\S+)/i, (_, v) => { branch = v.toLowerCase(); return ' '; })
+    .replace(/(?:^|\s)file:(\S+)/i, (_, v) => { file = v.toLowerCase(); return ' '; })
     .replace(/(?:^|\s)since:(\S+)/i, (_, v) => {
       const rel = /^(\d+)d$/i.exec(v);
       const abs = /^(\d{4})-(\d{2})-(\d{2})$/.exec(v);
@@ -27,16 +36,42 @@ function parseSearchQuery(q, now = Date.now()) {
     })
     .replace(/\s+/g, ' ')
     .trim();
-  return { text, project, since };
+  return { text, project, since, model, branch, file };
 }
 
-function searchHistory(q) {
+const hasSessionFilters = (f) => Boolean(f.model || f.branch || f.file);
+
+// A session's transcript meta against the session filters. A filter the
+// session has no data for (no branch, no changes) fails rather than passes.
+function sessionMatchesFilters(meta, f) {
+  if (f.model) {
+    const models = [meta.model, ...Object.keys(meta.usage || {})].filter(Boolean);
+    if (!models.some((m) => m.toLowerCase().includes(f.model))) return false;
+  }
+  if (f.branch && !(meta.gitBranch || '').toLowerCase().includes(f.branch)) return false;
+  if (f.file && !Object.keys(meta.changes || {}).some((p) => p.toLowerCase().includes(f.file))) return false;
+  return true;
+}
+
+// For sources keyed only by session id (history.jsonl): a predicate over the
+// ids of sessions passing the filters, or null when there are none to apply.
+function sessionFilterFor(q, transcriptGroups) {
+  const f = parseSearchQuery(q);
+  if (!hasSessionFilters(f)) return null;
+  const ok = new Set();
+  for (const g of transcriptGroups.values()) {
+    for (const m of g.sessions) if (sessionMatchesFilters(m, f)) ok.add(m.sessionId);
+  }
+  return (id) => Boolean(id) && ok.has(id);
+}
+
+function searchHistory(q, { allowSession = null, file = HISTORY_FILE } = {}) {
   const { text, project, since } = parseSearchQuery(q);
   const needle = text.toLowerCase();
   return new Promise((resolve) => {
     const matches = [];
     const rl = readline.createInterface({
-      input: fs.createReadStream(HISTORY_FILE, { encoding: 'utf8' }),
+      input: fs.createReadStream(file, { encoding: 'utf8' }),
       crlfDelay: Infinity,
     });
     rl.on('line', (line) => {
@@ -48,6 +83,7 @@ function searchHistory(q) {
         if (isIgnored(root)) return;
         if (project && !root.toLowerCase().includes(project)) return;
         if (since && !(rec.timestamp >= since)) return;
+        if (allowSession && !allowSession(rec.sessionId)) return;
         const i = rec.display.toLowerCase().indexOf(needle);
         const start = Math.max(0, i - 60);
         matches.push({
@@ -71,7 +107,8 @@ function searchHistory(q) {
 
 // Title matches come from the collector's in-memory transcript groups.
 function searchTitles(q, transcriptGroups, sessionTitle) {
-  const { text, project, since } = parseSearchQuery(q);
+  const f = parseSearchQuery(q);
+  const { text, project, since } = f;
   const needle = text.toLowerCase();
   const out = [];
   for (const g of transcriptGroups.values()) {
@@ -79,6 +116,7 @@ function searchTitles(q, transcriptGroups, sessionTitle) {
     if (project && !g.path.toLowerCase().includes(project)) continue;
     for (const m of g.sessions) {
       if (since && !(m.lastActivityAt >= since)) continue;
+      if (!sessionMatchesFilters(m, f)) continue;
       const { title } = sessionTitle(m);
       if (title && title.toLowerCase().includes(needle)) {
         out.push({ title, project: g.path, sessionId: m.sessionId, lastActivityAt: m.lastActivityAt });
@@ -91,7 +129,8 @@ function searchTitles(q, transcriptGroups, sessionTitle) {
 
 // Notes the user attached to sessions (config.json sessionNotes).
 function searchNotes(q, transcriptGroups, sessionNotes, now = Date.now()) {
-  const { text, project, since } = parseSearchQuery(q, now);
+  const f = parseSearchQuery(q, now);
+  const { text, project, since } = f;
   const needle = text.toLowerCase();
   if (!needle) return [];
   const out = [];
@@ -103,6 +142,7 @@ function searchNotes(q, transcriptGroups, sessionNotes, now = Date.now()) {
       const note = typeof raw === 'string' ? raw : raw == null ? '' : String(raw);
       if (!note || !note.toLowerCase().includes(needle)) continue;
       if (since && !(m.lastActivityAt >= since)) continue;
+      if (!sessionMatchesFilters(m, f)) continue;
       const i = note.toLowerCase().indexOf(needle);
       const start = Math.max(0, i - 60);
       out.push({
@@ -157,7 +197,8 @@ const MAX_DEEP_RESULTS = 40;
 const MAX_PER_SESSION = 3;
 
 async function searchTranscripts(q, transcriptGroups) {
-  const { text, project, since } = parseSearchQuery(q);
+  const f = parseSearchQuery(q);
+  const { text, project, since } = f;
   const needle = text.toLowerCase();
   if (!needle) return { matches: [], scanned: 0, total: 0, complete: true };
   const sessions = [];
@@ -166,6 +207,7 @@ async function searchTranscripts(q, transcriptGroups) {
     if (project && !g.path.toLowerCase().includes(project)) continue;
     for (const m of g.sessions) {
       if (since && !(m.lastActivityAt >= since)) continue;
+      if (!sessionMatchesFilters(m, f)) continue;
       sessions.push({ file: m.file, sessionId: m.sessionId, project: g.path, lastActivityAt: m.lastActivityAt });
     }
   }
@@ -196,4 +238,7 @@ async function searchTranscripts(q, transcriptGroups) {
   return { matches, scanned, total: sessions.length, complete: scanned >= sessions.length };
 }
 
-module.exports = { searchHistory, searchTitles, searchNotes, parseSearchQuery, transcriptLineMatch, searchTranscripts };
+module.exports = {
+  searchHistory, searchTitles, searchNotes, parseSearchQuery, transcriptLineMatch, searchTranscripts,
+  sessionMatchesFilters, sessionFilterFor,
+};

package/lib/transcripts.js

@@ -193,6 +193,8 @@ async function scanFile(abs, sessionIdFromName) {
   meta.context = scan.lastContext || null;
   meta.tools = scan.tools || null;
   meta.lastTool = scan.lastTool || null;
+  meta.badLines = scan.badLines || 0;
+  meta.size = st.size;
 
   cache.set(abs, { mtimeMs: st.mtimeMs, size: st.size, meta, scan });
   return meta;
@@ -220,13 +222,20 @@ async function incrementalScan(abs, size, scan) {
   }
 }
 
+// A line we picked out by its "type" marker but couldn't parse. Lines are
+// only scanned once complete, so this is real damage or a format change —
+// counted so the collector can say so instead of silently reading $0.
+function badLine(scan) {
+  scan.badLines = (scan.badLines || 0) + 1;
+}
+
 function scanLine(line, scan) {
   if (line.includes('"type":"ai-title"')) {
     try {
       const rec = JSON.parse(line);
       if (rec.aiTitle) scan.aiTitle = rec.aiTitle;
     } catch {
-      /* ignore */
+      badLine(scan);
     }
   } else if (line.includes('"type":"assistant"') && line.includes('"usage"')) {
     try {
@@ -253,7 +262,7 @@ function scanLine(line, scan) {
         addUsage(day, model, m.usage);
       }
     } catch {
-      /* ignore */
+      badLine(scan);
     }
   } else if (line.includes('"type":"file-history-delta"')) {
     try {
@@ -261,7 +270,7 @@ function scanLine(line, scan) {
       const p = realPathOf(rec.trackingPath, rec.backup);
       if (p) recordChange(scan.changes || (scan.changes = {}), p, rec.backup);
     } catch {
-      /* ignore */
+      badLine(scan);
     }
   } else if (line.includes('"type":"file-history-snapshot"')) {
     try {
@@ -272,14 +281,14 @@ function scanLine(line, scan) {
         if (p) recordChange(scan.changes || (scan.changes = {}), p, backup);
       }
     } catch {
-      /* ignore */
+      badLine(scan);
     }
   } else if (line.includes('"is_error":true') && line.includes('"tool_use_id"')) {
     try {
       const rec = JSON.parse(line);
       if (rec.type === 'user' && rec.message) countToolErrors(scan, rec.message.content);
     } catch {
-      /* ignore */
+      badLine(scan);
     }
   } else if (scan.lastAssistantTs && line.includes('"type":"user"') && !line.includes('"tool_use_id"')) {
     // Your next real prompt after assistant output: bucket the gap.
@@ -296,7 +305,7 @@ function scanLine(line, scan) {
       const waits = scan.waits || (scan.waits = [0, 0, 0, 0]);
       waits[gap < 30000 ? 0 : gap < 120000 ? 1 : gap < 600000 ? 2 : 3]++;
     } catch {
-      /* ignore */
+      badLine(scan);
     }
   }
 }
@@ -700,6 +709,29 @@ function sessionTitle(meta, customNames) {
   return { title: meta.sessionId.slice(0, 8), source: 'session-id' };
 }
 
+// The scanner reads an undocumented format by substring match. When Claude
+// Code changes it, nothing throws: costs just read $0. Pure check over a
+// scan's metas; returns warning strings for the settings diagnostics.
+//  - drift: several recent, sizeable, interactive transcripts with no usage
+//    at all. Real sessions always have assistant turns; a format change is
+//    the likely cause.
+//  - damage: lines that carried a known "type" marker but didn't parse.
+const DRIFT_MIN_BYTES = 64 * 1024;
+const DRIFT_MIN_SESSIONS = 3;
+const BAD_LINE_WARN = 5;
+function scannerHealth(metas, now = Date.now()) {
+  const out = [];
+  const weekAgo = now - 7 * 86400000;
+  const recent = (metas || []).filter((m) => m.lastActivityAt >= weekAgo && (m.size || 0) >= DRIFT_MIN_BYTES && m.entrypoint !== 'sdk-cli');
+  const empty = recent.filter((m) => !Object.keys(m.usage || {}).length);
+  if (recent.length >= DRIFT_MIN_SESSIONS && empty.length === recent.length) {
+    out.push(`no token usage found in ${empty.length} recent transcripts — Claude Code's transcript format may have changed, so costs and limits will read low`);
+  }
+  const bad = (metas || []).reduce((n, m) => n + (m.badLines || 0), 0);
+  if (bad >= BAD_LINE_WARN) out.push(`${bad} transcript lines could not be parsed — some costs or titles may be missing`);
+  return out;
+}
+
 // Group scanned sessions by canonical project root (worktrees fold in).
 function groupByProject(sessions) {
   const byProject = new Map(); // lowercase root -> { path, sessions: [] }
@@ -723,5 +755,5 @@ function groupByProject(sessions) {
 module.exports = {
   scanAllTranscripts, scanFile, groupByProject, sessionTitle, tidyPromptTitle, sessionKind, combinedUsage, mergeUsage,
   scanLine, mergeDays, combinedDays, dailyCostSeries, subagentSummary, usageBreakdown, dayKey, contextSummary, toolSummary,
-  waitingReason, reasonText, shouldReadMeta, TOOL_RING,
+  waitingReason, reasonText, shouldReadMeta, TOOL_RING, scannerHealth,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mission-control",
-  "version": "1.22.0",
+  "version": "1.24.0",
   "description": "Local dashboard for Claude Code: live sessions, transcripts, costs, git status — all your projects in one place.",
   "main": "server.js",
   "bin": {

package/public/index.html

@@ -2730,7 +2730,7 @@ async function runSearch(q, deep) {
           deepRows ? `<ul class="d-sessions">${deepRows}</ul>` : null, 'No matches inside transcripts.')
       : `<div style="margin:14px 0"><button class="copy" data-deep-search="${esc(q)}">search inside full transcripts →</button>
          <span class="s-when" style="margin-left:8px">reads every conversation, not just your prompts</span></div>`;
-    $('#d-path').textContent = `${d.prompts.length + d.titles.length + (t ? t.matches.length : 0) + (d.notes || []).length} results — narrow with project:name or since:7d`;
+    $('#d-path').textContent = `${d.prompts.length + d.titles.length + (t ? t.matches.length : 0) + (d.notes || []).length} results — narrow with project:name, since:7d, m:opus, b:branch or file:name`;
     const titleRows = d.titles.map((t) => `
       <li>
         <span class="s-title" data-session="${esc(t.sessionId)}" title="Click to read the transcript">${esc(t.title)}</span>

package/server.js

@@ -9,7 +9,7 @@ const { Collector } = require('./lib/collector');
 const { openSession, openNewSession, revealTarget, revealFile } = require('./lib/opener');
 const { projectDetail } = require('./lib/detail');
 const { sessionTranscript } = require('./lib/transcript-view');
-const { searchHistory, searchTitles, searchNotes, searchTranscripts, parseSearchQuery } = require('./lib/search');
+const { searchHistory, searchTitles, searchNotes, searchTranscripts, parseSearchQuery, sessionFilterFor } = require('./lib/search');
 const { readChats, saveChats, searchChats } = require('./lib/chats');
 const { sessionTitle } = require('./lib/transcripts');
 const { friendlyName } = require('./lib/names');
@@ -43,15 +43,17 @@ function indexHtml() {
   return indexCache;
 }
 
+const guard = require('./lib/guard');
+// Extra names to accept in the Host header when bound off-loopback (e.g. a
+// Tailscale MagicDNS name). Comma-separated.
+const ALLOWED_HOSTS = guard.parseAllowedHosts(process.env.CLAUDE_DASH_ALLOWED_HOSTS);
+
 function allowedHost(req) {
-  if (HOST !== '127.0.0.1') return true; // explicitly opted into remote access
-  const h = String(req.headers.host || '');
-  return h.startsWith('127.0.0.1') || h.startsWith('localhost');
+  return guard.allowedHost(req.headers.host, HOST, ALLOWED_HOSTS);
 }
 
 function sameOrigin(req) {
-  const origin = req.headers.origin;
-  return !origin || /^http:\/\/(127\.0\.0\.1|localhost)(:\d+)?$/.test(origin) || HOST !== '127.0.0.1';
+  return guard.sameOrigin(req.headers.origin, req.headers.host);
 }
 
 function readBody(req, res, cb) {
@@ -474,8 +476,10 @@ const server = http.createServer((req, res) => {
       return;
     }
     const deep = new URL(req.url, 'http://localhost').searchParams.get('deep') === '1';
+    // m:/b:/file: describe Claude Code sessions; claude.ai chats have none of that.
+    const allowSession = sessionFilterFor(q, collector.raw.transcriptGroups);
     Promise.all([
-      searchHistory(q),
+      searchHistory(q, { allowSession }),
       deep ? searchTranscripts(q, collector.raw.transcriptGroups) : Promise.resolve(null),
     ])
       .then(([prompts, transcripts]) => {
@@ -486,7 +490,7 @@ const server = http.createServer((req, res) => {
         for (const r of notes) r.projectName = friendlyName(r.project);
         if (transcripts) for (const r of transcripts.matches) r.projectName = friendlyName(r.project);
         let chats = null;
-        if (deep) {
+        if (deep && !allowSession) {
           const { text, since } = parseSearchQuery(q);
           const pool = since ? readChats().filter((c) => c.updatedAt >= since) : readChats();
           chats = searchChats(text, pool);
@@ -503,8 +507,7 @@ const server = http.createServer((req, res) => {
 
   if (url === '/api/open' && req.method === 'POST') {
     // Same-origin only: browsers always send Origin on cross-origin POSTs.
-    const origin = req.headers.origin;
-    if (origin && !/^http:\/\/(127\.0\.0\.1|localhost)(:\d+)?$/.test(origin)) {
+    if (!sameOrigin(req)) {
       res.writeHead(403, { 'Content-Type': 'application/json' });
       res.end('{"ok":false,"error":"forbidden"}');
       return;