@specship/specship-darwin-arm64 0.28.0 → 0.30.0

package/lib/dist/server/ingest/ingestor.js

@@ -1,13 +1,18 @@
 /**
- * JSONL → SQLite ingestor for Claude Code transcripts.
+ * Transcript → SQLite ingestor, one adapter per agent (REQ-AGENTSWITCH-004).
  *
- * Each Claude Code session lives in `~/.claude/projects/<slug>/<sessionId>.jsonl`,
- * where `<slug>` is the slash-escaped absolute path of the user's project.
- * Files are append-only (Claude Code writes one JSON line per assistant/user
- * turn), so we resume from the last byte offset on every pass — no re-parse
- * of the whole file.
+ * `ingestAll` walks every adapter in `./transcripts/` and ingests each of its
+ * files. Adapters normalise tool names to the shared set, so every row's
+ * `tool_name` is comparable across agents; `raw_tool_name` keeps the agent's
+ * own name and `host` names the agent. A document the adapter cannot parse
+ * is skipped and counted (`filesUnreadable`), never guessed at.
  *
- * Pipeline per file:
+ * JSON-lines adapters (Claude Code) are append-only, so we resume from the
+ * last byte offset on every pass — no re-parse of the whole file. Document
+ * adapters (Gemini CLI) rewrite the whole file, so a changed file replaces
+ * that session's rows.
+ *
+ * JSON-lines pipeline per file:
  *   1. Read state from `claude_ingest_state` (offset, last_size). If file
  *      grew, open it and seek to offset; otherwise skip.
  *   2. Parse each line with parseLine(). Group entries by promptId.
@@ -26,15 +31,10 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { computeCost, resolvePricing } from './pricing.js';
-import { parseLine, toEpochMs, extractUserPrompt, summarizeToolInput, toolResultLength, } from './parser.js';
+import { toEpochMs } from './transcripts/shared.js';
 import { classifyToolCall } from './specship-classify.js';
-/**
- * Convert Claude's slash-escaped project dir name back into a real path.
- * `~/.claude/projects/-Users-alice-projects-foo` → `/Users/alice/projects/foo`
- */
-export function decodeProjectSlug(slug) {
-    return slug.startsWith('-') ? '/' + slug.slice(1).replace(/-/g, '/') : slug;
-}
+import { transcriptAdapters, decodeProjectSlug, listClaudeTranscriptFiles } from './transcripts/index.js';
+export { decodeProjectSlug };
 /**
  * Build a predicate that tells whether a stored `project_path` belongs to the
  * primary project, given the primary's REAL filesystem path.
@@ -54,38 +54,28 @@ export function primaryProjectMatcher(primaryRealPath) {
     return (storedPath) => storedPath === primaryRealPath || storedPath === mangled;
 }
 /**
- * List every JSONL file inside `<claudeRoot>/<slug>/<sessionId>.jsonl`.
- * Returns the absolute file path + the decoded project path.
+ * List every Claude Code JSONL file inside `<claudeRoot>/<slug>/<sessionId>.jsonl`.
+ * Kept for existing callers; the Claude transcript adapter owns the walk.
  */
 export function listTranscriptFiles(claudeRoot) {
+    return listClaudeTranscriptFiles(claudeRoot);
+}
+/**
+ * The adapters an ingest pass runs, each with its root. Named roots win and
+ * restrict the pass to those adapters (see `IngestOptions.roots`).
+ */
+export function resolveIngestRoots(options = {}) {
+    const named = { ...(options.roots ?? {}) };
+    if (options.claudeRoot)
+        named['claude'] = options.claudeRoot;
+    const anyNamed = Object.values(named).some((r) => typeof r === 'string' && r.length > 0);
     const out = [];
-    let projects;
-    try {
-        projects = fs.readdirSync(claudeRoot, { withFileTypes: true });
-    }
-    catch {
-        return out;
-    }
-    for (const p of projects) {
-        if (!p.isDirectory())
-            continue;
-        const dir = path.join(claudeRoot, p.name);
-        let files;
-        try {
-            files = fs.readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const f of files) {
-            if (f.isFile() && f.name.toLowerCase().endsWith('.jsonl')) {
-                out.push({
-                    filePath: path.join(dir, f.name),
-                    projectPath: decodeProjectSlug(p.name),
-                    projectSlug: p.name,
-                });
-            }
-        }
+    for (const adapter of options.adapters ?? transcriptAdapters()) {
+        const root = named[adapter.id];
+        if (root)
+            out.push({ adapter, root });
+        else if (!anyNamed)
+            out.push({ adapter, root: adapter.defaultRoot(os.homedir()) });
     }
     return out;
 }
@@ -146,16 +136,16 @@ function readTail(filePath, fromOffset) {
     }
 }
 /**
- * Walk every transcript file under claudeRoot, ingest any new bytes, and
- * return aggregate stats. Synchronous: the caller controls cadence.
+ * Walk every adapter's transcript files, ingest anything new, and return
+ * aggregate stats. Synchronous: the caller controls cadence.
  */
 export function ingestAll(db, options = {}) {
     const start = Date.now();
-    const claudeRoot = options.claudeRoot ?? path.join(os.homedir(), '.claude', 'projects');
     const verbose = options.verbose ?? false;
     const stats = {
         filesScanned: 0,
         filesSkipped: 0,
+        filesUnreadable: 0,
         bytesIngested: 0,
         linesParsed: 0,
         linesSkipped: 0,
@@ -165,12 +155,24 @@ export function ingestAll(db, options = {}) {
         durationMs: 0,
     };
     const pricing = loadPricing(db);
-    const files = listTranscriptFiles(claudeRoot);
-    for (const f of files) {
+    const files = [];
+    for (const { adapter, root } of resolveIngestRoots(options)) {
+        for (const file of adapter.listFiles(root, { projectPaths: options.projectPaths }))
+            files.push({ adapter, file });
+    }
+    for (const { adapter, file: f } of files) {
         stats.filesScanned++;
         try {
-            const wasIngested = ingestFile(db, f.filePath, f.projectPath, pricing, options);
-            if (!wasIngested.modified) {
+            const wasIngested = ingestFile(db, adapter, f, pricing, options);
+            if (wasIngested === 'unreadable') {
+                // Skipped and counted, never guessed at (REQ-AGENTSWITCH-004.A3).
+                stats.filesUnreadable++;
+                if (verbose) {
+                    // eslint-disable-next-line no-console
+                    console.error('[ingest] unreadable transcript skipped:', f.filePath);
+                }
+            }
+            else if (!wasIngested.modified) {
                 stats.filesSkipped++;
             }
             else {
@@ -202,7 +204,28 @@ let lastIngestStats = null;
 export function getLastIngestStats() {
     return lastIngestStats;
 }
-function ingestFile(db, filePath, projectPath, pricing, options) {
+/**
+ * Ingest one transcript through its adapter. Returns `'unreadable'` when a
+ * document adapter cannot parse the file — nothing is written for it.
+ */
+export function ingestFile(db, adapter, file, pricing, options) {
+    return adapter.format === 'document'
+        ? ingestDocumentFile(db, adapter, file, pricing, options)
+        : ingestJsonlFile(db, adapter, file, pricing, options);
+}
+/** Resolve the graph once per file; best-effort, never aborts ingest. */
+function resolveGraphFor(options, projectPath) {
+    if (!options.resolveGraph)
+        return null;
+    try {
+        return options.resolveGraph(projectPath);
+    }
+    catch {
+        return null;
+    }
+}
+function ingestJsonlFile(db, adapter, file, pricing, options) {
+    const { filePath, projectPath } = file;
     // Load state.
     const stateRow = db
         .prepare('SELECT last_offset, file_size, session_id FROM claude_ingest_state WHERE file_path = ?')
@@ -257,18 +280,10 @@ function ingestFile(db, filePath, projectPath, pricing, options) {
     // on every tool call. Returns null when no resolver is configured. The
     // resolver can throw on a locked/corrupt index; that estimate is best-effort
     // decoration and must NEVER abort transcript ingest, so degrade to null.
-    let graph = null;
-    if (options.resolveGraph) {
-        try {
-            graph = options.resolveGraph(projectPath);
-        }
-        catch {
-            graph = null;
-        }
-    }
+    const graph = resolveGraphFor(options, projectPath);
     // Per-file ingest in a transaction.
     const txn = db.transaction(() => {
-        return processLines(db, filePath, projectPath, completeLines, pricing, graph);
+        return processLines(db, adapter, filePath, projectPath, completeLines, pricing, graph);
     });
     const result = txn();
     // Persist new offset.
@@ -294,16 +309,121 @@ function ingestFile(db, filePath, projectPath, pricing, options) {
         toolCalls: result.toolCalls,
     };
 }
+const INSERT_TOOL_CALL_SQL = `
+  INSERT INTO claude_tool_calls (prompt_id, session_id, assistant_uuid, tool_use_id, tool_name, input_summary, input_json, result_length, ts, is_specship, displaced_files, resolution, host, raw_tool_name)
+  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`;
+/**
+ * Ingest one whole-document transcript (Gemini CLI). The file is rewritten
+ * whole on every update, so a changed file replaces that session's prompt
+ * and tool-call rows in one transaction; an unchanged one (same size, not
+ * modified since the last pass) is skipped. An unparseable document writes
+ * nothing and records no state, so it is retried — and counted — every pass.
+ */
+function ingestDocumentFile(db, adapter, file, pricing, options) {
+    const { filePath, projectPath } = file;
+    const stat = fs.statSync(filePath);
+    const stateRow = db
+        .prepare('SELECT last_ingested_at, file_size FROM claude_ingest_state WHERE file_path = ?')
+        .get(filePath);
+    // mtimeMs carries sub-millisecond precision; last_ingested_at is whole ms.
+    if (stateRow && stateRow.file_size === stat.size && stateRow.last_ingested_at >= Math.floor(stat.mtimeMs)) {
+        return { modified: false, bytes: 0, lines: 0, linesSkipped: 0, prompts: 0, toolCalls: 0 };
+    }
+    const text = fs.readFileSync(filePath, 'utf-8');
+    const session = adapter.parseFile(text);
+    if (!session)
+        return 'unreadable';
+    const now = Date.now();
+    db.prepare(`
+    INSERT INTO claude_projects (path, name, first_seen, last_seen)
+    VALUES (?, ?, ?, ?)
+    ON CONFLICT(path) DO UPDATE SET last_seen = excluded.last_seen
+  `).run(projectPath, projectPath, now, now);
+    const graph = resolveGraphFor(options, projectPath);
+    const txn = db.transaction(() => {
+        const sid = session.sessionId;
+        const before = {
+            prompts: db.prepare('SELECT COUNT(*) AS n FROM claude_prompts WHERE session_id = ?').get(sid).n,
+            toolCalls: db.prepare('SELECT COUNT(*) AS n FROM claude_tool_calls WHERE session_id = ?').get(sid).n,
+        };
+        db.prepare('DELETE FROM claude_tool_calls WHERE session_id = ?').run(sid);
+        db.prepare('DELETE FROM claude_prompts WHERE session_id = ?').run(sid);
+        let ti = 0, to = 0, tcw = 0, tcr = 0, cost = 0, toolCalls = 0;
+        const promptCosts = session.prompts.map((p) => computeCost({
+            input_tokens: p.inputTokens,
+            output_tokens: p.outputTokens,
+            cache_creation_input_tokens: p.cacheCreationTokens,
+            cache_read_input_tokens: p.cacheReadTokens,
+        }, resolvePricing(p.model ?? session.model ?? undefined, pricing)));
+        session.prompts.forEach((p, i) => {
+            ti += p.inputTokens;
+            to += p.outputTokens;
+            tcw += p.cacheCreationTokens;
+            tcr += p.cacheReadTokens;
+            cost += promptCosts[i];
+        });
+        db.prepare(`
+      INSERT INTO claude_sessions (id, project_path, source_file, started_at, ended_at, prompt_count,
+        total_input_tokens, total_output_tokens, total_cache_creation_tokens, total_cache_read_tokens,
+        total_cost_usd, last_model, host)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        ended_at = excluded.ended_at,
+        prompt_count = excluded.prompt_count,
+        total_input_tokens = excluded.total_input_tokens,
+        total_output_tokens = excluded.total_output_tokens,
+        total_cache_creation_tokens = excluded.total_cache_creation_tokens,
+        total_cache_read_tokens = excluded.total_cache_read_tokens,
+        total_cost_usd = excluded.total_cost_usd,
+        last_model = COALESCE(excluded.last_model, claude_sessions.last_model),
+        host = excluded.host
+    `).run(sid, projectPath, filePath, session.startedAt, session.endedAt, session.prompts.length, ti, to, tcw, tcr, cost, session.model, adapter.id);
+        const insPrompt = db.prepare(`
+      INSERT INTO claude_prompts (id, session_id, text, ts, leaf_uuid, model, input_tokens, output_tokens,
+        cache_creation_tokens, cache_read_tokens, cost_usd, is_sidechain, assistant_text, thinking_text)
+      VALUES (?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, 0, ?, ?)
+    `);
+        const insToolCall = db.prepare(INSERT_TOOL_CALL_SQL);
+        session.prompts.forEach((p, i) => {
+            insPrompt.run(p.id, sid, p.text, p.ts, p.model, p.inputTokens, p.outputTokens, p.cacheCreationTokens, p.cacheReadTokens, promptCosts[i], p.assistantText, p.thinkingText);
+            for (const tc of p.toolCalls) {
+                const cls = classifyToolCall({ toolName: tc.name, inputJson: tc.inputJson, resultLength: tc.resultLength }, graph);
+                insToolCall.run(p.id, sid, p.id, tc.id, tc.name, tc.summary, tc.inputJson, tc.resultLength, tc.ts, cls.isSpecship, cls.displacedFiles, cls.resolution, adapter.id, tc.rawName);
+                toolCalls++;
+            }
+        });
+        return {
+            prompts: Math.max(0, session.prompts.length - before.prompts),
+            toolCalls: Math.max(0, toolCalls - before.toolCalls),
+        };
+    });
+    const result = txn();
+    db.prepare(`
+    INSERT INTO claude_ingest_state (file_path, last_offset, last_ingested_at, file_size, session_id)
+    VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(file_path) DO UPDATE SET
+      last_offset = excluded.last_offset,
+      last_ingested_at = excluded.last_ingested_at,
+      file_size = excluded.file_size,
+      session_id = excluded.session_id
+  `).run(filePath, stat.size, now, stat.size, session.sessionId);
+    if (options.verbose) {
+        // eslint-disable-next-line no-console
+        console.error(`[ingest] ${path.basename(filePath)} (${adapter.id}): ${session.prompts.length} prompts`);
+    }
+    return { modified: true, bytes: stat.size, lines: 0, linesSkipped: 0, prompts: result.prompts, toolCalls: result.toolCalls };
+}
 /**
  * Single-pass over the entries in this file batch. We need to relate
  * tool_use blocks (in assistant entries) to their tool_result blocks (in
  * the next user entry) so result_length is captured. Maintain a map of
  * pending tool_use_id → { promptId, name, summary, ts } as we walk.
  */
-function processLines(db, filePath, projectPath, completeLines, pricing, graph) {
+function processLines(db, adapter, filePath, projectPath, completeLines, pricing, graph) {
     const insSession = db.prepare(`
-    INSERT INTO claude_sessions (id, project_path, source_file, started_at, ended_at, prompt_count, last_model)
-    VALUES (?, ?, ?, ?, ?, 0, ?)
+    INSERT INTO claude_sessions (id, project_path, source_file, started_at, ended_at, prompt_count, last_model, host)
+    VALUES (?, ?, ?, ?, ?, 0, ?, '${adapter.id}')
     ON CONFLICT(id) DO UPDATE SET
       ended_at = excluded.ended_at,
       last_model = COALESCE(excluded.last_model, claude_sessions.last_model)
@@ -330,10 +450,7 @@ function processLines(db, filePath, projectPath, completeLines, pricing, graph)
       cache_read_tokens = excluded.cache_read_tokens,
       cost_usd = excluded.cost_usd
   `);
-    const insToolCall = db.prepare(`
-    INSERT INTO claude_tool_calls (prompt_id, session_id, assistant_uuid, tool_use_id, tool_name, input_summary, input_json, result_length, ts, is_specship, displaced_files, resolution)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
+    const insToolCall = db.prepare(INSERT_TOOL_CALL_SQL);
     /**
      * Append the assistant's text + thinking blocks from one assistant turn
      * onto the prompt row. A single user prompt can span multiple assistant
@@ -388,7 +505,7 @@ function processLines(db, filePath, projectPath, completeLines, pricing, graph)
     };
     const pendingTools = new Map();
     for (const raw of completeLines) {
-        const entry = parseLine(raw);
+        const entry = adapter.parseLine(raw);
         if (!entry) {
             // Blank lines aren't events; a non-empty line the parser couldn't
             // classify is a coverage gap and must be counted (REQ-DASHINT-008).
@@ -404,7 +521,7 @@ function processLines(db, filePath, projectPath, completeLines, pricing, graph)
         if (entry.type === 'user') {
             // Bookkeep session row first.
             insSession.run(sessionId, projectPath, filePath, ts, ts, null);
-            const text = extractUserPrompt(entry);
+            const text = adapter.extractUserPrompt(entry);
             const promptId = entry.promptId ?? entry.uuid ?? null;
             const isSidechain = entry.isSidechain ? 1 : 0;
             if (promptId) {
@@ -435,11 +552,11 @@ function processLines(db, filePath, projectPath, completeLines, pricing, graph)
             if (Array.isArray(content)) {
                 for (const block of content) {
                     if (block && block.type === 'tool_result' && block.tool_use_id) {
-                        const len = toolResultLength(block);
+                        const len = adapter.toolResultLength(block);
                         const pending = pendingTools.get(block.tool_use_id);
                         if (pending) {
                             const cls = classifyToolCall({ toolName: pending.toolName, inputJson: pending.inputJson, resultLength: len }, graph);
-                            insToolCall.run(pending.promptId, pending.sessionId, pending.assistantUuid, block.tool_use_id, pending.toolName, pending.summary, pending.inputJson, len, pending.ts, cls.isSpecship, cls.displacedFiles, cls.resolution);
+                            insToolCall.run(pending.promptId, pending.sessionId, pending.assistantUuid, block.tool_use_id, pending.toolName, pending.summary, pending.inputJson, len, pending.ts, cls.isSpecship, cls.displacedFiles, cls.resolution, adapter.id, pending.rawToolName);
                             toolCallsInserted++;
                             pendingTools.delete(block.tool_use_id);
                         }
@@ -506,12 +623,14 @@ function processLines(db, filePath, projectPath, completeLines, pricing, graph)
                         catch {
                             inputJson = null;
                         }
+                        const toolName = adapter.normalizeToolName(block.name);
                         pendingTools.set(block.id, {
                             promptId,
                             sessionId,
                             assistantUuid,
-                            toolName: block.name,
-                            summary: summarizeToolInput(block.name, block.input),
+                            toolName,
+                            rawToolName: block.name,
+                            summary: adapter.summarizeToolInput(toolName, block.input),
                             inputJson,
                             ts,
                         });
@@ -546,7 +665,7 @@ function processLines(db, filePath, projectPath, completeLines, pricing, graph)
     for (const [toolUseId, pending] of pendingTools) {
         // result_length=0 for pending/unmatched tools → classifyToolCall returns 'n/a' for specship.
         const cls = classifyToolCall({ toolName: pending.toolName, inputJson: pending.inputJson, resultLength: 0 }, graph);
-        insToolCall.run(pending.promptId, pending.sessionId, pending.assistantUuid, toolUseId, pending.toolName, pending.summary, pending.inputJson, 0, pending.ts, cls.isSpecship, cls.displacedFiles, cls.resolution);
+        insToolCall.run(pending.promptId, pending.sessionId, pending.assistantUuid, toolUseId, pending.toolName, pending.summary, pending.inputJson, 0, pending.ts, cls.isSpecship, cls.displacedFiles, cls.resolution, adapter.id, pending.rawToolName);
         toolCallsInserted++;
     }
     return {

package/lib/dist/server/ingest/project-paths.js

@@ -14,6 +14,8 @@
  *      one of its ancestors) whose encoding equals the slug is the real path.
  *   3. The legacy lossy decode, preserving behavior for hyphen-free paths.
  */
+import { CLAUDE_PROFILE } from '../host-profiles.js';
+import { recordedProjects } from './recorded-projects.js';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
@@ -128,13 +130,17 @@ function sniffCwd(claudeRoot, slug) {
  * mtime change (REQ-SLUGRES-001).
  */
 export function createSlugResolver(opts = {}) {
-    const claudeJsonPath = opts.claudeJsonPath ?? path.join(os.homedir(), '.claude.json');
-    const claudeRoot = opts.claudeRoot ?? path.join(os.homedir(), '.claude', 'projects');
+    const claudeJsonPath = opts.claudeJsonPath ?? path.join(os.homedir(), CLAUDE_PROFILE.userConfigFile);
+    const claudeRoot = opts.claudeRoot ?? path.join(os.homedir(), CLAUDE_PROFILE.configDir, 'projects');
     const sniffed = new Map();
     return (slug) => {
         const fromIndex = claudeJsonIndex(claudeJsonPath).get(slug);
         if (fromIndex)
             return fromIndex;
+        // A project SpecShip is installed in, by any agent (REQ-AGENTSWITCH-011).
+        const recorded = recordedProjects(opts.recordPath).find((p) => encodeProjectSlug(p.path) === slug);
+        if (recorded)
+            return recorded.path;
         const cached = sniffed.get(slug);
         if (cached)
             return cached;

package/lib/dist/server/ingest/recorded-projects.js

@@ -0,0 +1,43 @@
+/**
+ * Projects SpecShip is installed in, from the installed-agents record
+ * (REQ-AGENTSWITCH-006) — the agent-neutral source of project paths
+ * (REQ-AGENTSWITCH-011). An agent whose session folders cannot be mapped back
+ * to a path (Gemini CLI names them by a one-way hash of it) still has its
+ * projects found here. SpecShip's own file, read directly: the server never
+ * imports the CLI package.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+/** `$SPECSHIP_INSTALL_DIR` or `~/.specship` — the same rule the CLI uses. */
+export function installedAgentsRecordPath(env = process.env, home = os.homedir()) {
+    return path.join(env.SPECSHIP_INSTALL_DIR || path.join(home, '.specship'), 'installed-agents.json');
+}
+/** Every project-scoped entry in the record, one row per project. Never throws. */
+export function recordedProjects(recordPath = installedAgentsRecordPath()) {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(recordPath, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+    const entries = parsed?.entries;
+    if (!Array.isArray(entries))
+        return [];
+    const byPath = new Map();
+    for (const e of entries) {
+        if (!e || typeof e !== 'object')
+            continue;
+        const { scope, projectRoot, agent, recordedAt } = e;
+        if (scope !== 'local' || typeof projectRoot !== 'string' || !projectRoot)
+            continue;
+        const at = typeof recordedAt === 'string' ? Date.parse(recordedAt) || 0 : 0;
+        const row = byPath.get(projectRoot) ?? { path: projectRoot, agents: [], recordedAtMs: 0 };
+        if (typeof agent === 'string' && !row.agents.includes(agent))
+            row.agents.push(agent);
+        row.recordedAtMs = Math.max(row.recordedAtMs, at);
+        byPath.set(projectRoot, row);
+    }
+    return [...byPath.values()];
+}

package/lib/dist/server/ingest/specship-classify.js

@@ -10,11 +10,16 @@
  * pure (no I/O, no deps), so duplication is cheap; `__tests__/specship-impact-parity.test.ts`
  * asserts the two copies stay behaviourally identical.
  */
+import { specshipToolPrefix } from '../canonical-tools.js';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
-/** Prefix shared by every MCP tool routed through the specship server. */
-const MCP_SPECSHIP_PREFIX = 'mcp__specship__';
+/**
+ * Prefix shared by every (normalised) MCP tool routed through the specship
+ * server. Tool names reaching this module are already in the shared set —
+ * each transcript adapter normalises its agent's names first (REQ-AGENTSWITCH-004).
+ */
+const MCP_SPECSHIP_PREFIX = specshipToolPrefix;
 /**
  * Strip-prefix base names of SpecShip tools that return code-graph source.
  * These are the tools a SpecShip call can displace a native Read/Grep with.

package/lib/dist/server/ingest/transcripts/claude-jsonl.js

@@ -0,0 +1,54 @@
+/**
+ * Claude transcript line format (REQ-AGENTSWITCH-017): converts one line of a
+ * Claude Code JSONL transcript into a
+ * structured ClaudeRawEntry, or null for unparseable / unrecognised lines.
+ *
+ * Tolerant: a malformed line never throws; the worker logs and skips it.
+ */
+export function parseLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const obj = JSON.parse(trimmed);
+        if (!obj || typeof obj !== 'object' || typeof obj.type !== 'string') {
+            return null;
+        }
+        return obj;
+    }
+    catch {
+        return null;
+    }
+}
+/** Extract the user-visible prompt text from a user-entry message. */
+export function extractUserPrompt(entry) {
+    // Some user entries store text at the top level; most use message.content.
+    if (typeof entry.text === 'string' && entry.text.length > 0)
+        return entry.text;
+    const content = entry.message?.content;
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((b) => b && typeof b === 'object')
+            .map((b) => (b.type === 'text' && typeof b.text === 'string' ? b.text : ''))
+            .filter((t) => t.length > 0)
+            .join('\n')
+            .trim();
+    }
+    return '';
+}
+/** Sum the character length of a tool_result content block. */
+export function toolResultLength(block) {
+    if (!block)
+        return 0;
+    const c = block.content;
+    if (typeof c === 'string')
+        return c.length;
+    if (Array.isArray(c)) {
+        return c.reduce((sum, item) => sum + (typeof item?.text === 'string' ? item.text.length : 0), 0);
+    }
+    return 0;
+}
+// The agent-neutral helpers live in ./shared; re-exported for this adapter's callers.
+export { toEpochMs, summarizeToolInput } from './shared.js';

package/lib/dist/server/ingest/transcripts/claude.js

@@ -0,0 +1,64 @@
+/**
+ * Claude Code transcript adapter (REQ-AGENTSWITCH-004).
+ *
+ * Sessions live in `~/.claude/projects/<slug>/<sessionId>.jsonl`, where
+ * `<slug>` is the slash-escaped absolute project path. Files are append-only
+ * JSON lines, so the ingestor resumes from the last byte offset.
+ *
+ * Claude Code's tool names ARE the shared set (`Read`, `Bash`,
+ * `mcp__<server>__<tool>` …), so normalisation is the identity — which is
+ * what keeps existing rows and counts unchanged (REQ-AGENTSWITCH-004.A2).
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { CLAUDE_PROFILE } from '../../host-profiles.js';
+import { extractUserPrompt, parseLine, toolResultLength } from './claude-jsonl.js';
+import { summarizeToolInput } from './shared.js';
+/**
+ * Convert Claude's slash-escaped project dir name back into a real path.
+ * `-Users-alice-projects-foo` → `/Users/alice/projects/foo`
+ */
+export function decodeProjectSlug(slug) {
+    return slug.startsWith('-') ? '/' + slug.slice(1).replace(/-/g, '/') : slug;
+}
+/** Every `<root>/<slug>/<sessionId>.jsonl`, with the decoded project path. */
+export function listClaudeTranscriptFiles(root) {
+    const out = [];
+    let projects;
+    try {
+        projects = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const p of projects) {
+        if (!p.isDirectory())
+            continue;
+        const dir = path.join(root, p.name);
+        let files;
+        try {
+            files = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const f of files) {
+            if (f.isFile() && f.name.toLowerCase().endsWith('.jsonl')) {
+                out.push({ filePath: path.join(dir, f.name), projectPath: decodeProjectSlug(p.name), projectSlug: p.name });
+            }
+        }
+    }
+    return out;
+}
+export const claudeTranscriptAdapter = {
+    id: CLAUDE_PROFILE.id,
+    format: 'jsonl',
+    defaultRoot: (home) => path.join(home, CLAUDE_PROFILE.configDir, 'projects'),
+    listFiles: (root) => listClaudeTranscriptFiles(root),
+    watches: (fileName) => fileName.toLowerCase().endsWith('.jsonl'),
+    normalizeToolName: (raw) => raw,
+    parseLine,
+    summarizeToolInput,
+    extractUserPrompt,
+    toolResultLength,
+};