claude-mission-control 1.23.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

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/config.js

@@ -242,10 +242,11 @@ function removeIgnore(prefix) {
 }
 
 // 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;

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

@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mission-control",
-  "version": "1.23.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');
@@ -476,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]) => {
@@ -488,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);