@specship/specship-darwin-arm64 0.28.0 → 0.30.0

package/lib/dist/server/routes/claude.js

@@ -19,6 +19,22 @@
  */
 import { writeSseHead } from './sse.js';
 import { decodeProjectSlug, getLastIngestStats } from '../ingest/index.js';
+import { CLAUDE_PROFILE, HOST_PROFILES } from '../host-profiles.js';
+import { CANONICAL_TOOLS } from '../canonical-tools.js';
+// Tool names in claude_tool_calls are the SHARED names every transcript
+// adapter normalises to (REQ-AGENTSWITCH-004), so these queries cover every
+// agent's sessions. Values come from our own canonical-tools.json, never from
+// input, so quoting them into the SQL is safe.
+const sqlString = (v) => `'${v.replace(/'/g, "''")}'`;
+const FILE_TOUCH_TOOLS = [CANONICAL_TOOLS.read, CANONICAL_TOOLS.edit, CANONICAL_TOOLS.write, CANONICAL_TOOLS.notebookEdit];
+const FILE_TOUCH_TOOLS_SQL = FILE_TOUCH_TOOLS.map(sqlString).join(',');
+const FILE_TOUCH_TOOLS_SQL_WITH_MULTI = [...FILE_TOUCH_TOOLS, CANONICAL_TOOLS.multiEdit].map(sqlString).join(',');
+const READ_TOOL_SQL = sqlString(CANONICAL_TOOLS.read);
+/** `<configDir>/settings.json` of the agent a session came from (Claude Code when unknown). */
+function settingsFileFor(host) {
+    const profile = HOST_PROFILES.find((p) => p.id === host) ?? CLAUDE_PROFILE;
+    return `${profile.configDir}/settings.json`;
+}
 /**
  * Normalize a `?project=` filter value to the form stored in
  * claude_sessions.project_path. The Sessions page (and any other UI
@@ -361,7 +377,7 @@ export async function registerClaudeRoutes(app) {
                 ORDER BY inner_tc.ts DESC LIMIT 1) as lastOp
       FROM claude_tool_calls AS tc
       WHERE tc.session_id = ?
-        AND tc.tool_name IN ('Read','Edit','Write','NotebookEdit','MultiEdit')
+        AND tc.tool_name IN (${FILE_TOUCH_TOOLS_SQL_WITH_MULTI})
         AND tc.input_summary != ''
       GROUP BY tc.input_summary
       ORDER BY ops DESC
@@ -437,7 +453,7 @@ export async function registerClaudeRoutes(app) {
         const files = db.prepare(`
       SELECT input_summary as path, COUNT(*) as calls, SUM(result_length) as resultBytes
       FROM claude_tool_calls
-      WHERE ts >= ? AND tool_name IN ('Read','Edit','Write','NotebookEdit') AND input_summary != ''${inProject()}
+      WHERE ts >= ? AND tool_name IN (${FILE_TOUCH_TOOLS_SQL}) AND input_summary != ''${inProject()}
       GROUP BY input_summary
       ORDER BY calls DESC
       LIMIT 100
@@ -450,7 +466,7 @@ export async function registerClaudeRoutes(app) {
         const trendRows = db.prepare(`
       SELECT input_summary as path, CAST((ts - ?) / ? AS INTEGER) as bucket, COUNT(*) as calls
       FROM claude_tool_calls
-      WHERE ts >= ? AND tool_name IN ('Read','Edit','Write','NotebookEdit') AND input_summary != ''${inProject()}
+      WHERE ts >= ? AND tool_name IN (${FILE_TOUCH_TOOLS_SQL}) AND input_summary != ''${inProject()}
       GROUP BY input_summary, bucket
     `).all(...withProject(trend7Start, dayMs, trend7Start));
         const trendByPath = new Map();
@@ -518,7 +534,7 @@ export async function registerClaudeRoutes(app) {
              MAX(t.ts) as lastTs, MIN(t.ts) as firstTs
       FROM claude_tool_calls t
       LEFT JOIN claude_sessions s ON s.id = t.session_id
-      WHERE t.input_summary = ? AND t.ts >= ? AND t.tool_name IN ('Read','Edit','Write','NotebookEdit')
+      WHERE t.input_summary = ? AND t.ts >= ? AND t.tool_name IN (${FILE_TOUCH_TOOLS_SQL})
       GROUP BY t.session_id
       ORDER BY calls DESC
       LIMIT 50
@@ -526,7 +542,7 @@ export async function registerClaudeRoutes(app) {
         const byTool = db.prepare(`
       SELECT tool_name as name, COUNT(*) as calls, COALESCE(SUM(result_length), 0) as bytes
       FROM claude_tool_calls
-      WHERE input_summary = ? AND ts >= ? AND tool_name IN ('Read','Edit','Write','NotebookEdit')
+      WHERE input_summary = ? AND ts >= ? AND tool_name IN (${FILE_TOUCH_TOOLS_SQL})
       GROUP BY tool_name
       ORDER BY calls DESC
     `).all(path, since);
@@ -930,7 +946,7 @@ export async function registerClaudeRoutes(app) {
         const wastefulReads = db.prepare(`
       SELECT session_id, input_summary as file, COUNT(*) as n
       FROM claude_tool_calls
-      WHERE tool_name = 'Read' AND input_summary != '' AND ${inProject}
+      WHERE tool_name = ${READ_TOOL_SQL} AND input_summary != '' AND ${inProject}
       GROUP BY session_id, input_summary
       HAVING n >= 10
       ORDER BY n DESC
@@ -970,13 +986,13 @@ export async function registerClaudeRoutes(app) {
                 title: `${r.tool_name} returned ${Math.round(r.result_length / 1000)}k chars (~${Math.round(estTokens / 1000)}k tokens est.) — try a structural query`,
                 why: 'Tools that dump raw content into context are the dominant cost driver. A structural query returns just what the agent needs.',
                 evidence: { session: r.session_id, detail: `${r.tool_name}(${r.input_summary.slice(0, 100)}) → ${r.result_length} chars (~${estTokens} tokens est.)` },
-                fix: r.tool_name === 'Bash' ? 'specship_search "<symbol>" instead of Bash(grep)' : 'specship_explore "<symbol or question>"',
+                fix: r.tool_name === CANONICAL_TOOLS.bash ? 'specship_search "<symbol>" instead of Bash(grep)' : 'specship_explore "<symbol or question>"',
                 saving: `~$${((estTokens / 1_000_000) * 15).toFixed(2)} est. on this call`,
             });
         }
         // Rule 3: "cache miss rate" — sessions with > 10 prompts and cache_read_rate < 0.3.
         const lowCache = db.prepare(`
-      SELECT s.id, s.total_cache_read_tokens as cr, s.total_input_tokens as ti, s.total_cache_creation_tokens as cw, s.prompt_count, s.last_model
+      SELECT s.id, s.total_cache_read_tokens as cr, s.total_input_tokens as ti, s.total_cache_creation_tokens as cw, s.prompt_count, s.last_model, s.host
       FROM claude_sessions s
       WHERE s.prompt_count >= 10
         AND (s.total_input_tokens + s.total_cache_creation_tokens + s.total_cache_read_tokens) > 0
@@ -996,7 +1012,8 @@ export async function registerClaudeRoutes(app) {
                 title: `Cache read rate is ${Math.round(rate * 100)}% on a ${r.prompt_count}-prompt session`,
                 why: 'When the prompt prefix changes every turn, the 1h cache gets invalidated. Pinning a stable system-prompt prefix lets the cache absorb most of your input.',
                 evidence: { session: r.id, detail: `cache_read=${(r.cr / 1_000_000).toFixed(2)}M / total=${(total / 1_000_000).toFixed(2)}M` },
-                fix: 'Pin a stable system-prompt prefix in .claude/settings.json',
+                // The session's own agent's settings file (REQ-AGENTSWITCH-004).
+                fix: `Pin a stable system-prompt prefix in ${settingsFileFor(r.host)}`,
                 // Not measurable per session without a model price table — state it
                 // qualitatively rather than render a placeholder (REQ-AUDFIX-006.A1).
                 saving: 'cached input bills at a fraction of fresh input',
@@ -1008,7 +1025,7 @@ export async function registerClaudeRoutes(app) {
         // mixed-model workflow (fresh context per step + external verification).
         const flounder = db.prepare(`
       SELECT s.id, s.last_model,
-             (SELECT COUNT(*) FROM claude_tool_calls t WHERE t.session_id = s.id AND t.tool_name = 'Read') AS reads
+             (SELECT COUNT(*) FROM claude_tool_calls t WHERE t.session_id = s.id AND t.tool_name = ${READ_TOOL_SQL}) AS reads
       FROM claude_sessions s
       WHERE s.project_path IN (?, ?)
         AND (LOWER(COALESCE(s.last_model,'')) LIKE '%haiku%' OR LOWER(COALESCE(s.last_model,'')) LIKE '%sonnet%')

package/lib/dist/server/routes/graph.js

@@ -10,6 +10,30 @@
  * The MCP layer's `specship_*` tools are markdown-formatted for agents;
  * here we return raw JSON so the UI can render visually.
  */
+/**
+ * Longest source the split view returns for one symbol. `getCode` already
+ * slices the symbol's own startLine..endLine; this caps a huge class body so a
+ * single match can't turn into a whole-file dump. File nodes get no code at all.
+ */
+export const MAX_CODE_LINES = 400;
+/** One symbol's verbatim source, capped to its own body (null when unavailable). */
+async function symbolCode(cg, node) {
+    if (node.kind === 'file')
+        return { code: null, codeTruncated: false };
+    let code = null;
+    try {
+        code = await cg.getCode(node.id);
+    }
+    catch {
+        code = null;
+    }
+    if (code == null)
+        return { code: null, codeTruncated: false };
+    const lines = code.split('\n');
+    if (lines.length <= MAX_CODE_LINES)
+        return { code, codeTruncated: false };
+    return { code: lines.slice(0, MAX_CODE_LINES).join('\n'), codeTruncated: true };
+}
 /** Returns the active SpecShip or sends a 409. */
 async function resolveCg(app, req, reply) {
     const cg = await app.activeCg(req);
@@ -89,14 +113,51 @@ export async function registerGraphRoutes(app) {
         }
         if (matches.length === 0)
             return reply.code(404).send({ error: 'not found' });
-        const enriched = matches.map((n) => {
+        const withCode = req.query.includeCode === '1' || req.query.includeCode === 'true';
+        const enriched = await Promise.all(matches.map(async (n) => {
             const callers = cg.getCallers(n.id).map((e) => e.node);
             const callees = cg.getCallees(n.id).map((e) => e.node);
             const links = cg.getSpecQueries().getLinksByNode(n.id);
-            return { ...n, callers, callees, linkedSpecs: links };
-        });
+            const base = { ...n, callers, callees, linkedSpecs: links };
+            return withCode ? { ...base, ...(await symbolCode(cg, n)) } : base;
+        }));
         return { matches: enriched };
     });
+    /**
+     * GET /api/graph/split-search?q= — the Graph split view's one search box
+     * (REQ-DASHSIMPLE-005): spec matches (an exact requirement id first, then
+     * the spec full-text index) and code-symbol matches, as two groups.
+     */
+    app.get('/api/graph/split-search', async (req, reply) => {
+        const cg = await resolveCg(app, req, reply);
+        if (!cg)
+            return;
+        const q = (req.query.q ?? '').trim();
+        const limit = Math.min(Math.max(parseInt(req.query.limit ?? '8', 10) || 8, 1), 50);
+        if (!q)
+            return { specs: [], symbols: [] };
+        const sq = cg.getSpecQueries();
+        const specs = [];
+        const seen = new Set();
+        const exact = sq.getSpecById(q) ?? sq.getSpecById(q.toUpperCase());
+        if (exact) {
+            seen.add(exact.id);
+            specs.push({ id: exact.id, title: exact.title, kind: exact.kind, snippet: '' });
+        }
+        for (const hit of sq.searchSpecs(q, limit)) {
+            if (seen.has(hit.spec.id))
+                continue;
+            seen.add(hit.spec.id);
+            specs.push({ id: hit.spec.id, title: hit.spec.title, kind: hit.spec.kind, snippet: hit.snippet });
+        }
+        // Spec nodes live in the code graph too; the specs group already covers them.
+        const symbols = cg.searchNodes(q, { limit: limit * 2 })
+            .map((r) => r.node)
+            .filter((n) => n.kind !== 'spec')
+            .slice(0, limit)
+            .map((n) => ({ id: n.id, name: n.name, kind: n.kind, filePath: n.filePath, startLine: n.startLine }));
+        return { specs: specs.slice(0, limit), symbols };
+    });
     app.post('/api/graph/explore', async (req, reply) => {
         const cg = await resolveCg(app, req, reply);
         if (!cg)

package/lib/dist/server/routes/mcp.js

@@ -1,8 +1,10 @@
 /**
  * MCP servers routes — inventory, live status, and control (REQ-DESKTOP-026).
  *
- * Three real sources, merged (this fork is Claude Code only, so Claude
- * Code's config surfaces ARE the inventory — no other clients are read):
+ * Three real sources, merged (each supported agent's config surfaces are
+ * the inventory; per-agent file names come from `host-profiles.ts`,
+ * REQ-AGENTSWITCH-001 — Gemini CLI's user and project `settings.json`
+ * entries are listed read-only under `gemini:<name>` keys):
  *   1. Claude Code's own config — `~/.claude.json` (global `mcpServers` +
  *      `projects[<root>].mcpServers`) and `<projectRoot>/.mcp.json`, the
  *      same files `specship install` writes. Disabled servers come from
@@ -30,12 +32,15 @@ import { spawn } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
+import { CLAUDE_PROFILE, GEMINI_PROFILE } from '../host-profiles.js';
 function getDb(cg) {
     const anyCg = cg;
     if (anyCg.db?.getDb)
         return anyCg.db.getDb();
     return anyCg.queries?.db;
 }
+/** Inventory key prefix for a Gemini CLI entry, so it never collides with a Claude Code one of the same name. */
+export const GEMINI_KEY_PREFIX = GEMINI_PROFILE.id + ':';
 /** Config-write failures the routes translate to HTTP statuses. */
 export class McpConfigError extends Error {
     statusCode;
@@ -61,7 +66,7 @@ function readJson(p) {
 export function configuredServers(paths) {
     const out = new Map();
     const claudeJson = readJson(paths.claudeJsonPath);
-    const add = (name, cfg) => out.set(name, { name, ...cfg });
+    const add = (name, cfg) => out.set(name, { name, host: CLAUDE_PROFILE.id, ...cfg });
     for (const [name, entry] of Object.entries((claudeJson?.['mcpServers'] ?? {}))) {
         add(name, { scope: 'user', entry, configFile: paths.claudeJsonPath, disabled: false, container: 'user' });
     }
@@ -77,12 +82,26 @@ export function configuredServers(paths) {
             add(name, { scope: 'project', entry, configFile: paths.claudeJsonPath, disabled: true, container: 'project-local' });
         }
         const disabledMcpjson = new Set((proj?.['disabledMcpjsonServers'] ?? []));
-        const mcpJsonPath = path.join(paths.projectRoot, '.mcp.json');
+        const mcpJsonPath = path.join(paths.projectRoot, CLAUDE_PROFILE.projectMcpFile);
         const mcpJson = readJson(mcpJsonPath);
         for (const [name, entry] of Object.entries((mcpJson?.['mcpServers'] ?? {}))) {
             add(name, { scope: 'project', entry, configFile: mcpJsonPath, disabled: disabledMcpjson.has(name), container: 'mcpjson' });
         }
     }
+    if (paths.geminiSettingsPath) {
+        // Gemini CLI: user settings, then the project's settings (project wins).
+        const files = [[paths.geminiSettingsPath, 'user']];
+        if (paths.projectRoot)
+            files.push([path.join(paths.projectRoot, GEMINI_PROFILE.projectMcpFile), 'project']);
+        for (const [file, scope] of files) {
+            const settings = readJson(file);
+            for (const [name, entry] of Object.entries((settings?.['mcpServers'] ?? {}))) {
+                out.set(GEMINI_KEY_PREFIX + name, {
+                    name, scope, entry, configFile: file, disabled: false, container: 'gemini', host: GEMINI_PROFILE.id,
+                });
+            }
+        }
+    }
     return out;
 }
 /**
@@ -281,6 +300,9 @@ export function setServerEnabled(paths, name, enabled) {
         throw new McpConfigError(`unknown MCP server "${name}"`, 404);
     if (cfg.disabled === !enabled)
         return cfg;
+    if (cfg.container === 'gemini') {
+        throw new McpConfigError(`${GEMINI_PROFILE.displayName} servers are edited in ${cfg.configFile}`, 400);
+    }
     if (cfg.container === 'mcpjson') {
         editJsonFile(paths.claudeJsonPath, (data) => {
             const projects = (data['projects'] = data['projects'] ?? {});
@@ -335,16 +357,16 @@ export function addServer(paths, input) {
     if (input.scope === 'project') {
         if (!paths.projectRoot)
             throw new McpConfigError('no project open — cannot write .mcp.json', 400);
-        const mcpJsonPath = path.join(paths.projectRoot, '.mcp.json');
+        const mcpJsonPath = path.join(paths.projectRoot, CLAUDE_PROFILE.projectMcpFile);
         editJsonFile(mcpJsonPath, (data) => {
             data['mcpServers'] = { ...(data['mcpServers'] ?? {}), [name]: entry };
         });
-        return { name, scope: 'project', entry, configFile: mcpJsonPath, disabled: false, container: 'mcpjson' };
+        return { name, scope: 'project', entry, configFile: mcpJsonPath, disabled: false, container: 'mcpjson', host: CLAUDE_PROFILE.id };
     }
     editJsonFile(paths.claudeJsonPath, (data) => {
         data['mcpServers'] = { ...(data['mcpServers'] ?? {}), [name]: entry };
     });
-    return { name, scope: 'user', entry, configFile: paths.claudeJsonPath, disabled: false, container: 'user' };
+    return { name, scope: 'user', entry, configFile: paths.claudeJsonPath, disabled: false, container: 'user', host: CLAUDE_PROFILE.id };
 }
 /** Aggregate claude_tool_calls into per-server usage + the latest example call. */
 function collectUsage(cg) {
@@ -354,16 +376,16 @@ function collectUsage(cg) {
     try {
         const db = getDb(cg);
         usage = db.prepare(`
-      SELECT tool_name, COUNT(*) as calls,
+      SELECT host, tool_name, COUNT(*) as calls,
              COALESCE(SUM(result_length), 0) as bytes,
              MAX(ts) as last
       FROM claude_tool_calls
       WHERE tool_name LIKE 'mcp__%'
-      GROUP BY tool_name
+      GROUP BY host, tool_name
     `).all();
         // Latest verbatim inputs (schema v7) — first row per server wins below.
         examples = db.prepare(`
-      SELECT tool_name, input_json
+      SELECT host, tool_name, input_json
       FROM claude_tool_calls
       WHERE tool_name LIKE 'mcp__%' AND input_json IS NOT NULL
       ORDER BY ts DESC
@@ -372,11 +394,17 @@ function collectUsage(cg) {
     }
     catch { /* analytics tables absent — config-only response */ }
     const parse = (t) => t.match(/^mcp__(.+?)__(.+)$/);
+    // Transcript adapters store every agent's MCP calls under the shared
+    // `mcp__<server>__<tool>` name (REQ-AGENTSWITCH-004), so the bare server
+    // name is the match key; a Gemini CLI call is credited to the Gemini entry
+    // (`gemini:<server>`) that inventory lists for it.
+    const keyFor = mcpUsageKey;
     for (const u of usage) {
         const m = parse(u.tool_name);
         if (!m)
             continue;
-        const [, server, tool] = m;
+        const [, bare, tool] = m;
+        const server = keyFor(u.host, bare);
         if (!byServer.has(server))
             byServer.set(server, { calls: 0, bytes: 0, last: 0, tools: new Map(), example: null });
         const s = byServer.get(server);
@@ -395,7 +423,8 @@ function collectUsage(cg) {
         const m = parse(row.tool_name);
         if (!m)
             continue;
-        const [, server, tool] = m;
+        const [, bare, tool] = m;
+        const server = keyFor(row.host, bare);
         const s = byServer.get(server);
         if (!s || s.example)
             continue;
@@ -417,8 +446,9 @@ function collectUsage(cg) {
 }
 export async function registerMcpRoutes(app) {
     const paths = () => ({
-        claudeJsonPath: path.join(os.homedir(), '.claude.json'),
+        claudeJsonPath: path.join(os.homedir(), CLAUDE_PROFILE.userConfigFile),
         projectRoot: app.primaryCg?.getProjectRoot?.() ?? null,
+        geminiSettingsPath: path.join(os.homedir(), GEMINI_PROFILE.userConfigFile),
     });
     function requirePrimary(reply) {
         if (!app.primaryCg) {
@@ -447,7 +477,8 @@ export async function registerMcpRoutes(app) {
             const command = entry.url ?? [entry.command, ...(entry.args ?? [])].filter(Boolean).join(' ');
             const state = deriveState(cfg, use?.last ? { lastMs: use.last } : null, probes.get(name) ?? null);
             return {
-                id: name, name,
+                id: name, name: cfg?.name ?? name,
+                host: cfg?.host ?? null,
                 scope: cfg?.scope ?? 'unknown',
                 state, transport, command,
                 configFile: cfg?.configFile ?? null,
@@ -498,10 +529,21 @@ export async function registerMcpRoutes(app) {
         }
     });
 }
-/** True when transcripts contain any mcp__<name>__* call. */
+/**
+ * The inventory key a recorded MCP call is credited to: a Gemini CLI call to
+ * server `x` belongs to the `gemini:x` entry, any other agent's to `x`
+ * (REQ-AGENTSWITCH-004 — calls carry the shared name plus their host).
+ */
+export function mcpUsageKey(host, server) {
+    return host === GEMINI_PROFILE.id ? GEMINI_KEY_PREFIX + server : server;
+}
+/** True when transcripts contain any mcp__<name>__* call (a `gemini:` key matches Gemini CLI calls by bare server name). */
 function hasUsage(cg, name) {
     try {
         const db = getDb(cg);
+        if (name.startsWith(GEMINI_KEY_PREFIX)) {
+            return db.prepare(`SELECT 1 FROM claude_tool_calls WHERE host = ? AND tool_name LIKE 'mcp__' || ? || '__%' LIMIT 1`).all(GEMINI_PROFILE.id, name.slice(GEMINI_KEY_PREFIX.length)).length > 0;
+        }
         const rows = db.prepare(`SELECT 1 FROM claude_tool_calls WHERE tool_name LIKE 'mcp__' || ? || '__%' LIMIT 1`).all(name);
         return rows.length > 0;
     }

package/lib/dist/server/routes/memory.js

@@ -1,7 +1,9 @@
 /**
- * GET /api/memory — CLAUDE.md hierarchy + ~/.claude/memory notes.
+ * GET /api/memory — every installed agent's memory-file hierarchy + notes.
  *
- * Walks the standard Claude Code memory locations and returns a flattened
+ * Walks each agent's standard memory locations (from `host-profiles.ts`,
+ * REQ-AGENTSWITCH-001 — Claude Code's CLAUDE.md tree, Gemini CLI's GEMINI.md
+ * tree; each file is tagged with its `host`) and returns a flattened
  * list of MemoryFile records the desktop UI can render directly. Resolves
  * `@path` imports from each instruction file.
  *
@@ -17,11 +19,7 @@ import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { decodeProjectSlug } from '../ingest/ingestor.js';
-const ENTERPRISE_PATHS = [
-    '/Library/Application Support/ClaudeCode/CLAUDE.md',
-    '/etc/ClaudeCode/CLAUDE.md',
-    process.env['ProgramData'] ? path.join(process.env['ProgramData'], 'ClaudeCode', 'CLAUDE.md') : '',
-].filter(Boolean);
+import { HOST_PROFILES } from '../host-profiles.js';
 function estimateTokens(body) {
     // Rough heuristic: ~4 chars per token. Cheap; the UI tolerates approximation.
     return Math.max(1, Math.round(body.length / 4));
@@ -86,48 +84,56 @@ function makeFile(opts) {
         body: opts.body,
         readOnly: opts.readOnly,
         imports: opts.imports?.length ? opts.imports : undefined,
+        host: opts.host,
     };
 }
-async function collectEnterprise() {
+/** Id suffix for a non-default host, so both agents' files stay distinct. */
+function idSuffix(profile) {
+    return profile === HOST_PROFILES[0] ? '' : '-' + profile.id;
+}
+async function collectEnterprise(profile) {
     const out = [];
-    for (const p of ENTERPRISE_PATHS) {
+    for (const p of profile.enterpriseMemoryPaths()) {
         const file = await tryRead(p);
         if (file) {
             out.push(makeFile({
-                id: 'm-ent',
+                id: 'm-ent' + idSuffix(profile),
                 level: 'enterprise',
                 type: 'instruction',
-                name: 'CLAUDE.md',
+                name: profile.memoryFile,
                 scope: 'managed',
                 absolutePath: p,
                 body: file.body,
                 modifiedMs: file.modified,
                 readOnly: true,
+                host: profile.id,
             }));
             break;
         }
     }
     return out;
 }
-async function collectUser() {
-    const p = path.join(os.homedir(), '.claude', 'CLAUDE.md');
+async function collectUser(profile) {
+    const p = path.join(os.homedir(), profile.configDir, profile.memoryFile);
     const file = await tryRead(p);
     if (!file)
         return [];
     return [makeFile({
-            id: 'm-user',
+            id: 'm-user' + idSuffix(profile),
             level: 'user',
             type: 'instruction',
-            name: 'CLAUDE.md',
-            scope: '~/.claude',
+            name: profile.memoryFile,
+            scope: '~/' + profile.configDir,
             absolutePath: p,
             body: file.body,
             modifiedMs: file.modified,
+            host: profile.id,
         })];
 }
-async function collectProject(projectRoot) {
+async function collectProject(projectRoot, profile) {
     const out = [];
-    const proj = path.join(projectRoot, 'CLAUDE.md');
+    const suffix = idSuffix(profile);
+    const proj = path.join(projectRoot, profile.memoryFile);
     const projFile = await tryRead(proj);
     const importMap = new Map();
     if (projFile) {
@@ -137,7 +143,7 @@ async function collectProject(projectRoot) {
             const abs = path.isAbsolute(imp) ? imp : path.join(projectRoot, imp);
             const sub = await tryRead(abs);
             if (sub) {
-                const id = 'm-imp-' + Buffer.from(imp).toString('base64').replace(/=/g, '').slice(0, 10);
+                const id = 'm-imp-' + Buffer.from(imp).toString('base64').replace(/=/g, '').slice(0, 10) + suffix;
                 importMap.set(imp, makeFile({
                     id,
                     level: 'import',
@@ -147,25 +153,27 @@ async function collectProject(projectRoot) {
                     absolutePath: abs,
                     body: sub.body,
                     modifiedMs: sub.modified,
+                    host: profile.id,
                 }));
                 resolvedIds.push(id);
             }
         }
         out.push(makeFile({
-            id: 'm-proj',
+            id: 'm-proj' + suffix,
             level: 'project',
             type: 'instruction',
-            name: 'CLAUDE.md',
+            name: profile.memoryFile,
             scope: 'project root',
             absolutePath: proj,
             body: projFile.body,
             modifiedMs: projFile.modified,
             imports: resolvedIds,
+            host: profile.id,
         }));
         for (const im of importMap.values())
             out.push(im);
     }
-    // Scan one level of subdirectories for nested CLAUDE.md files. Keeps the
+    // Scan one level of subdirectories for nested memory files. Keeps the
     // walk cheap — going deeper would need ignoring node_modules etc.
     try {
         const entries = await fs.readdir(projectRoot, { withFileTypes: true });
@@ -174,18 +182,19 @@ async function collectProject(projectRoot) {
                 continue;
             if (ent.name.startsWith('.') || ent.name === 'node_modules' || ent.name === 'dist')
                 continue;
-            const subPath = path.join(projectRoot, ent.name, 'CLAUDE.md');
+            const subPath = path.join(projectRoot, ent.name, profile.memoryFile);
             const sub = await tryRead(subPath);
             if (sub) {
                 out.push(makeFile({
-                    id: 'm-sub-' + ent.name,
+                    id: 'm-sub-' + ent.name + suffix,
                     level: 'subdir',
                     type: 'instruction',
-                    name: 'CLAUDE.md',
+                    name: profile.memoryFile,
                     scope: ent.name,
                     absolutePath: subPath,
                     body: sub.body,
                     modifiedMs: sub.modified,
+                    host: profile.id,
                 }));
             }
         }
@@ -195,9 +204,11 @@ async function collectProject(projectRoot) {
     }
     return out;
 }
-async function collectNotes() {
-    const dir = path.join(os.homedir(), '.claude', 'memory');
+async function collectNotes(profile) {
     const out = [];
+    if (!profile.notesDir)
+        return out;
+    const dir = path.join(os.homedir(), profile.notesDir);
     let entries;
     try {
         entries = await fs.readdir(dir, { withFileTypes: true });
@@ -217,7 +228,7 @@ async function collectNotes() {
             .filter((t) => typeof t === 'string')
             .slice(0, 6);
         out.push(makeFile({
-            id: 'n-' + ent.name.replace(/\.md$/, ''),
+            id: 'n-' + ent.name.replace(/\.md$/, '') + idSuffix(profile),
             level: 'note',
             type: 'note',
             name: ent.name,
@@ -225,6 +236,7 @@ async function collectNotes() {
             absolutePath: abs,
             body: file.body,
             modifiedMs: file.modified,
+            host: profile.id,
         }));
         if (tags.length) {
             const last = out[out.length - 1];
@@ -234,6 +246,19 @@ async function collectNotes() {
     }
     return out;
 }
+/**
+ * Every agent's memory files, grouped tier by tier: enterprise, user, project,
+ * notes — each tier lists Claude Code's files, then Gemini CLI's.
+ */
+export async function collectMemoryFiles(projectRoot) {
+    const tiers = await Promise.all([
+        Promise.all(HOST_PROFILES.map((p) => collectEnterprise(p))),
+        Promise.all(HOST_PROFILES.map((p) => collectUser(p))),
+        projectRoot ? Promise.all(HOST_PROFILES.map((p) => collectProject(projectRoot, p))) : Promise.resolve([]),
+        Promise.all(HOST_PROFILES.map((p) => collectNotes(p))),
+    ]);
+    return tiers.flat(2);
+}
 export async function registerMemoryRoutes(app) {
     app.get('/api/memory', async (req) => {
         // Memory has three global tiers (enterprise / user / notes) and one
@@ -251,13 +276,7 @@ export async function registerMemoryRoutes(app) {
             projectRoot = req.query.projectPath;
         else if (app.primaryCg?.getProjectRoot)
             projectRoot = app.primaryCg.getProjectRoot();
-        const [enterprise, user, project, notes] = await Promise.all([
-            collectEnterprise(),
-            collectUser(),
-            projectRoot ? collectProject(projectRoot) : Promise.resolve([]),
-            collectNotes(),
-        ]);
-        const files = [...enterprise, ...user, ...project, ...notes];
+        const files = await collectMemoryFiles(projectRoot);
         const resp = {
             totalTokens: files.reduce((a, b) => a + b.tokens, 0),
             instructionCount: files.filter((f) => f.type === 'instruction').length,