@evomap/evolver-runtime-adapters 2.0.0-beta.2 → 2.0.0-beta.22

package/dist/adapters.d.ts

@@ -6,5 +6,11 @@ export declare const geminiAdapter: SessionLogAdapter;
 export declare const antigravityAdapter: SessionLogAdapter;
 export declare const genericChatAdapter: SessionLogAdapter;
 export declare const kimiAdapter: SessionLogAdapter;
+export declare const kiroRemovedAdapter: SessionLogAdapter;
+export declare const opencodeRemovedAdapter: SessionLogAdapter;
+/** Explicitly removed transcript adapters — path fail-closed only. Never walk this list for content probes. */
+export declare const REMOVED_ADAPTERS: readonly SessionLogAdapter[];
 export declare const ADAPTERS: readonly SessionLogAdapter[];
-export declare function adapterForPath(path: string): SessionLogAdapter | undefined;
+export declare function adapterForPath(path: string): SessionLogAdapter | undefined;
+/** True when the agent id has an explicit removed transcript sentinel (see REMOVED_ADAPTERS). */
+export declare function isRemovedAdapter(agent: string): boolean;

package/dist/adapters.js

@@ -291,26 +291,71 @@ function anthropicSessionSystemPrompt(chunk) {
     }
     return undefined;
 }
-function anthropicStyleSession(chunk) {
+const NATIVE_SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const CLAUDE_TRANSCRIPT_PATH = /(?:^|[/\\])\.claude[/\\]projects[/\\](?:[^/\\]+[/\\])*([A-Za-z0-9][A-Za-z0-9._-]{0,127})\.jsonl$/;
+const CURSOR_TRANSCRIPT_PATHS = [
+    /(?:^|[/\\])\.cursor[/\\]projects[/\\](?:[^/\\]+[/\\])*agent-transcripts[/\\]([A-Za-z0-9][A-Za-z0-9._-]{0,127})\.jsonl$/,
+    /(?:^|[/\\])\.cursor[/\\]projects[/\\](?:[^/\\]+[/\\])*agent-transcripts[/\\]([A-Za-z0-9][A-Za-z0-9._-]{0,127})[/\\]\1\.jsonl$/,
+];
+function transcriptSessionId(chunk, keys) {
+    const values = new Set();
+    for (const row of parseJsonlLines(chunk)) {
+        for (const key of keys) {
+            if (!hasOwn(row, key))
+                continue;
+            const value = row[key];
+            if (typeof value !== 'string' || !NATIVE_SESSION_ID.test(value))
+                return { invalid: true };
+            values.add(value);
+            if (values.size > 1)
+                return { invalid: true };
+        }
+    }
+    return { value: values.values().next().value, invalid: false };
+}
+function nativeResumeIdentity(harness, path, chunk, pathPattern, recordKeys) {
+    const pathId = pathPattern.exec(path)?.[1];
+    if (!pathId || !NATIVE_SESSION_ID.test(pathId))
+        return undefined;
+    const recordId = transcriptSessionId(chunk, recordKeys);
+    if (recordId.invalid || (recordId.value !== undefined && recordId.value !== pathId))
+        return undefined;
+    return { harness, sessionId: pathId };
+}
+function cursorResumeIdentity(path, chunk) {
+    for (const pattern of CURSOR_TRANSCRIPT_PATHS) {
+        const identity = nativeResumeIdentity('cursor', path, chunk, pattern, ['sessionId', 'session_id', 'conversationId', 'conversation_id']);
+        if (identity)
+            return identity;
+    }
+    return undefined;
+}
+function anthropicStyleSession(chunk, sessionIdKeys = []) {
     const systemPrompt = anthropicSessionSystemPrompt(chunk);
+    const sessionId = transcriptSessionId(chunk, sessionIdKeys);
     return {
         turns: anthropicStyleTranscript(chunk),
         ...(systemPrompt ? { systemPrompt } : {}),
+        ...(!sessionId.invalid && sessionId.value ? { sessionId: sessionId.value } : {}),
     };
 }
 export const claudeCodeAdapter = {
     agent: 'claude-code',
     detect: (p) => /\.claude[/\\]projects[/\\].*\.jsonl$/.test(p) || /claude.*\.jsonl$/i.test(p),
+    resumeIdentityFromSource: (path, chunk) => nativeResumeIdentity('claude-code', path, chunk, CLAUDE_TRANSCRIPT_PATH, ['sessionId', 'session_id']),
     parse: anthropicStyleTranscript,
-    parseSession: anthropicStyleSession,
+    parseSession: (chunk) => anthropicStyleSession(chunk, ['sessionId', 'session_id']),
 };
-// Verified against real cursor agent-transcripts (~/.cursor/projects/<proj>/agent-transcripts/<uuid>.jsonl):
+// Verified against real cursor agent-transcripts
+// (~/.cursor/projects/<proj>/agent-transcripts/<session-id>.jsonl, with newer nested layouts also accepted):
 // same Anthropic content-block shape as claude-code — observed blocks are text + tool_use (no tool_result). Other
 // .jsonl that live under .cursor (eval datasets: task_id/canonical_solution, no role) carry no turn and parse to [].
 export const cursorAdapter = {
     agent: 'cursor',
     detect: (p) => /\.cursor[/\\].*\.jsonl$/.test(p) || /cursor.*\.jsonl$/i.test(p),
+    resumeIdentityFromSource: cursorResumeIdentity,
     parse: anthropicStyleTranscript,
+    parseSession: (chunk) => anthropicStyleSession(chunk, ['sessionId', 'session_id', 'conversationId', 'conversation_id']),
 };
 // Verified against codex-cli 0.137.0 rollout logs (~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl). Each line is
 // {timestamp, type, payload}. Codex writes the SAME conversation twice: a high-level `event_msg` stream
@@ -1217,7 +1262,42 @@ export const kimiAdapter = {
     parseSession: (chunk) => kimiSessions(chunk)[0] ?? { turns: [] },
     parseSessions: kimiSessions,
 };
-// Only verified adapters are registered. opencode/kiro live in git history — re-add with a real-log fixture.
+// ── Removed runtime adapters ─────────────────────────────────────────────────
+// Kiro and OpenCode transcript adapters were removed in V2: no sanitized real-log golden fixture exists for
+// either runtime, so shipping a guessed schema would silently yield 0 turns on real logs while appearing
+// supported. The MCP config installer (setup-hooks --runtime=kiro|opencode) remains functional for injection.
+//
+// Sentinels live in REMOVED_ADAPTERS (NOT in ADAPTERS) so content probes that walk ADAPTERS and call
+// parse() cannot throw "kiro removed" on unrelated JSON (trajectoryExport.adapterForContent).
+// Path-based selection uses adapterForPath, which checks REMOVED_ADAPTERS first; matching paths then fail
+// closed on parse with an actionable error.
+const REMOVED_ADAPTER_MESSAGE = (agent) => `${agent} transcript adapter was removed from evolver v2 — no sanitized real-log golden fixture exists. `
+    + `Re-add with a verified golden test (see adapters.test.ts). `
+    + `MCP injection (setup-hooks --runtime=${agent}) is still supported; only transcript ingest is blocked.`;
+function removedAdapter(agent, detect) {
+    return {
+        agent,
+        detect,
+        parse: () => { throw new Error(REMOVED_ADAPTER_MESSAGE(agent)); },
+        parseSession: () => { throw new Error(REMOVED_ADAPTER_MESSAGE(agent)); },
+        parseSessions: () => { throw new Error(REMOVED_ADAPTER_MESSAGE(agent)); },
+    };
+}
+export const kiroRemovedAdapter = removedAdapter('kiro', (p) => /(^|[/\\])\.kiro([/\\]|$)/i.test(p) || /(^|[/\\])kiro[^/\\]*\.jsonl?$/i.test(p));
+export const opencodeRemovedAdapter = removedAdapter('opencode', (p) => /(^|[/\\])\.opencode([/\\]|$)/i.test(p) || /(^|[/\\])opencode[^/\\]*\.jsonl?$/i.test(p));
+/** Explicitly removed transcript adapters — path fail-closed only. Never walk this list for content probes. */
+export const REMOVED_ADAPTERS = [kiroRemovedAdapter, opencodeRemovedAdapter];
+// Only verified adapters are registered for content/path discovery. Removed runtimes are listed in
+// REMOVED_ADAPTERS and selected only via adapterForPath path match (then parse throws).
 // genericChatAdapter is LAST so any tool-specific path (claude/cursor/codex/gemini/antigravity/kimi) resolves first.
 export const ADAPTERS = [claudeCodeAdapter, codexAdapter, cursorAdapter, geminiAdapter, antigravityAdapter, kimiAdapter, genericChatAdapter];
-export function adapterForPath(path) { return ADAPTERS.find((a) => a.detect(path)); }
+export function adapterForPath(path) {
+    const removed = REMOVED_ADAPTERS.find((a) => a.detect(path));
+    if (removed)
+        return removed;
+    return ADAPTERS.find((a) => a.detect(path));
+}
+/** True when the agent id has an explicit removed transcript sentinel (see REMOVED_ADAPTERS). */
+export function isRemovedAdapter(agent) {
+    return REMOVED_ADAPTERS.some((a) => a.agent === agent);
+}

package/dist/cursorState.d.ts

@@ -1,8 +1,13 @@
 import type { NormalizedSession } from './types.js';
+export type CursorStateVscdbErrorStage = 'open' | 'schema' | 'query';
+export declare class CursorStateVscdbError extends Error {
+    readonly stage: CursorStateVscdbErrorStage;
+    constructor(stage: CursorStateVscdbErrorStage, message: string, cause?: unknown);
+}
 /**
  * Read Cursor chat sessions out of a `state.vscdb` sqlite database (read-only). Returns one NormalizedSession per
- * composer that has at least one real (non-meta) turn. Never throws on a malformed/locked db — returns []. The db
- * is opened read-only, so it is safe to run against a live Cursor profile.
+ * composer that has at least one real (non-meta) turn. A valid database with no sessions returns []; database open,
+ * query, and incompatible-schema failures throw CursorStateVscdbError. The database is always opened read-only.
  */
 export declare function parseCursorStateVscdb(dbPath: string): NormalizedSession[];
 /** True for a path that looks like a Cursor globalStorage state.vscdb. */

package/dist/cursorState.js

@@ -1,6 +1,14 @@
 import { createRequire } from 'node:module';
 import { correlateToolNames, isMetaText } from './types.js';
 const nodeRequire = createRequire(import.meta.url);
+export class CursorStateVscdbError extends Error {
+    stage;
+    constructor(stage, message, cause) {
+        super(`Cursor state database ${stage} error: ${message}`, { cause });
+        this.name = 'CursorStateVscdbError';
+        this.stage = stage;
+    }
+}
 function isBunRuntime() {
     return typeof process.versions === 'object' && typeof process.versions.bun === 'string';
 }
@@ -37,11 +45,9 @@ function openReadOnlySqliteDatabase(path) {
 // bubbleId:<composer>:<bubble> rows; extracting user/assistant text, assistant `thinking` as a reasoning turn,
 // and `toolFormerData` as a tool_use + tool_result pair; per-bubble token counts; session model/createdAt.
 //
-// NOT yet covered / known gaps (the local machine's DB had only EMPTY composers, so these are schema-documented
-// but not golden-verified against real populated bubbles): Cursor's code-edit "diff" capability blocks
-// (codeBlockData / originalFileStates) are NOT reconstructed into before/after diffs; sub-composer / best-of-N
-// branch bubbles are read flat (no tree structure); attachment/context payloads are ignored. Extend with a real
-// populated-DB fixture before trusting those.
+// Composer roots can also carry an inline `conversation` array (including sub-composer roots). Attachment bodies
+// and explicit code-block content are preserved as turns. We intentionally do not synthesize before/after diffs
+// from codeBlockData/originalFileStates because those fields vary by Cursor version.
 function isRecord(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
@@ -90,9 +96,61 @@ function bubbleToolTurns(bubble, toolUseId) {
     }
     return turns;
 }
-function bubbleToTurns(bubble, bubbleId) {
-    if (!isRecord(bubble))
+function explicitBodyText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!isRecord(value))
+        return '';
+    return asString(value['text']) || asString(value['content']);
+}
+function bubbleAttachmentTexts(bubble) {
+    const directValue = bubble['attachments'];
+    if (directValue !== undefined && !Array.isArray(directValue)) {
+        throw new CursorStateVscdbError('schema', 'conversation attachments must be an array');
+    }
+    const direct = Array.isArray(directValue) ? directValue : [];
+    const toolValue = isRecord(bubble['toolFormerData']) ? bubble['toolFormerData']['attachments'] : undefined;
+    if (toolValue !== undefined && !Array.isArray(toolValue)) {
+        throw new CursorStateVscdbError('schema', 'tool attachments must be an array');
+    }
+    const tool = Array.isArray(toolValue) ? toolValue : [];
+    return [...direct, ...tool].map((attachment) => {
+        if (!isRecord(attachment)) {
+            throw new CursorStateVscdbError('schema', 'attachment must be an object');
+        }
+        return explicitBodyText(attachment['body']);
+    }).filter(Boolean);
+}
+function bubbleCodeBlockTexts(bubble) {
+    const codeBlocks = bubble['codeBlocks'];
+    if (codeBlocks === undefined)
         return [];
+    if (!Array.isArray(codeBlocks)) {
+        throw new CursorStateVscdbError('schema', 'conversation codeBlocks must be an array');
+    }
+    return codeBlocks.map(explicitContentText).filter(Boolean);
+}
+function explicitContentText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!isRecord(value))
+        return '';
+    return asString(value['content']) || asString(value['text']) || asString(value['code']) || explicitBodyText(value['body']);
+}
+function contentTurns(role, texts, existingText = '') {
+    const seen = new Set(existingText ? [existingText] : []);
+    return texts.flatMap((text) => {
+        const trimmed = text.trim();
+        if (!trimmed || seen.has(trimmed))
+            return [];
+        seen.add(trimmed);
+        return [{ role, text, isMeta: isMetaText(text) }];
+    });
+}
+function bubbleToTurns(bubble, bubbleId) {
+    if (!isRecord(bubble)) {
+        throw new CursorStateVscdbError('schema', `conversation bubble ${bubbleId} is missing or invalid`);
+    }
     const type = finiteNumber(bubble['type']);
     const inputTokens = isRecord(bubble['tokenCount']) ? finiteNumber(bubble['tokenCount']['inputTokens']) : undefined;
     const outputTokens = isRecord(bubble['tokenCount']) ? finiteNumber(bubble['tokenCount']['outputTokens']) : undefined;
@@ -101,9 +159,14 @@ function bubbleToTurns(bubble, bubbleId) {
     if (type === 1) {
         // user bubble
         turns.push({ role: 'user', text, isMeta: isMetaText(text) });
+        turns.push(...contentTurns('user', bubbleAttachmentTexts(bubble), text));
+        turns.push(...contentTurns('user', bubbleCodeBlockTexts(bubble), text));
         return turns;
     }
-    // assistant (type === 2) or unknown -> treat as assistant content
+    if (type !== 2) {
+        throw new CursorStateVscdbError('schema', `conversation bubble ${bubbleId} has an unsupported type`);
+    }
+    // assistant bubble
     const thinking = bubbleThinkingText(bubble);
     if (thinking) {
         turns.push({ role: 'assistant', text: thinking, reasoning: true, isMeta: false });
@@ -118,31 +181,139 @@ function bubbleToTurns(bubble, bubbleId) {
         });
     }
     turns.push(...bubbleToolTurns(bubble, bubbleId));
+    turns.push(...contentTurns('assistant', bubbleAttachmentTexts(bubble), text));
+    turns.push(...contentTurns('assistant', bubbleCodeBlockTexts(bubble), text));
     return turns;
 }
 function conversationHeaders(composer) {
     const headers = composer['fullConversationHeadersOnly'];
-    if (!Array.isArray(headers))
+    if (headers === undefined)
         return [];
-    return headers
-        .map((header) => (isRecord(header) ? { bubbleId: asString(header['bubbleId']), type: finiteNumber(header['type']) } : { bubbleId: '' }))
-        .filter((header) => header.bubbleId);
+    if (!Array.isArray(headers)) {
+        throw new CursorStateVscdbError('schema', 'fullConversationHeadersOnly must be an array');
+    }
+    return headers.map((header) => {
+        if (!isRecord(header))
+            throw new CursorStateVscdbError('schema', 'conversation header must be an object');
+        const bubbleId = asString(header['bubbleId']);
+        if (!bubbleId)
+            throw new CursorStateVscdbError('schema', 'conversation header bubbleId is missing');
+        return { bubbleId, type: finiteNumber(header['type']) };
+    });
 }
-function composerToSession(composer, composerId, readBubble) {
+function inlineConversation(composer) {
+    const conversation = composer['conversation'];
+    if (conversation === undefined)
+        return [];
+    if (!Array.isArray(conversation)) {
+        throw new CursorStateVscdbError('schema', 'conversation must be an array');
+    }
+    return conversation.map((bubble, index) => ({
+        bubbleId: isRecord(bubble) ? asString(bubble['bubbleId']) || `inline-${index + 1}` : `inline-${index + 1}`,
+        value: bubble,
+    }));
+}
+function codeBlockContentByBubble(composer, readCodeBlockDiff) {
+    const byBubble = new Map();
+    const trailing = [];
+    const codeBlockData = composer['codeBlockData'];
+    if (codeBlockData === undefined)
+        return { byBubble, trailing };
+    if (!isRecord(codeBlockData)) {
+        throw new CursorStateVscdbError('schema', 'codeBlockData must be an object');
+    }
+    const seen = new Set();
+    const add = (text, bubbleId) => {
+        const trimmed = text.trim();
+        const key = `${bubbleId}\0${trimmed}`;
+        if (!trimmed || seen.has(key))
+            return;
+        seen.add(key);
+        if (bubbleId) {
+            const texts = byBubble.get(bubbleId);
+            if (texts)
+                texts.push(text);
+            else
+                byBubble.set(bubbleId, [text]);
+        }
+        else
+            trailing.push(text);
+    };
+    const stack = Object.values(codeBlockData).reverse()
+        .map((value) => ({ value, bubbleId: '' }));
+    let visited = 0;
+    while (stack.length > 0) {
+        if (++visited > 100_000)
+            throw new CursorStateVscdbError('schema', 'codeBlockData is too deeply nested');
+        const current = stack.pop();
+        if (Array.isArray(current.value)) {
+            for (let index = current.value.length - 1; index >= 0; index--) {
+                stack.push({ value: current.value[index], bubbleId: current.bubbleId });
+            }
+            continue;
+        }
+        if (!isRecord(current.value))
+            continue;
+        const bubbleId = asString(current.value['bubbleId']) || current.bubbleId;
+        const directText = asString(current.value['content']) || asString(current.value['text'])
+            || asString(current.value['code']) || asString(current.value['body']);
+        if (directText)
+            add(directText, bubbleId);
+        const diffId = asString(current.value['diffId']);
+        if (diffId) {
+            const diff = readCodeBlockDiff(diffId);
+            if (!isRecord(diff) || !Array.isArray(diff['newModelDiffWrtV0'])) {
+                throw new CursorStateVscdbError('schema', 'code block diff must contain newModelDiffWrtV0');
+            }
+            for (const line of diff['newModelDiffWrtV0']) {
+                if (!isRecord(line)) {
+                    throw new CursorStateVscdbError('schema', 'code block diff line must be an object');
+                }
+                const modified = line['modified'];
+                if (typeof modified === 'string')
+                    add(modified, bubbleId);
+                else if (Array.isArray(modified) && modified.every((value) => typeof value === 'string')) {
+                    add(modified.join('\n'), bubbleId);
+                }
+                else
+                    throw new CursorStateVscdbError('schema', 'code block diff line must contain modified text');
+            }
+        }
+        const children = Object.values(current.value).filter((child) => Array.isArray(child) || isRecord(child));
+        for (let index = children.length - 1; index >= 0; index--) {
+            stack.push({ value: children[index], bubbleId });
+        }
+    }
+    return { byBubble, trailing };
+}
+function composerToSession(composer, composerId, readBubble, readCodeBlockDiff) {
     const headers = conversationHeaders(composer);
-    const conversationMap = isRecord(composer['conversationMap']) ? composer['conversationMap'] : undefined;
-    const orderedBubbleIds = headers.length > 0
-        ? headers.map((header) => header.bubbleId)
-        : (conversationMap ? Object.keys(conversationMap) : []);
+    const inline = inlineConversation(composer);
+    const inlineById = new Map(inline.map((bubble) => [bubble.bubbleId, bubble.value]));
+    const conversationMapValue = composer['conversationMap'];
+    if (conversationMapValue !== undefined && !isRecord(conversationMapValue)) {
+        throw new CursorStateVscdbError('schema', 'conversationMap must be an object');
+    }
+    const conversationMap = isRecord(conversationMapValue) ? conversationMapValue : undefined;
+    const codeBlocks = codeBlockContentByBubble(composer, (diffId) => readCodeBlockDiff(composerId, diffId));
+    const orderedBubbles = headers.length > 0
+        ? headers.map((header) => ({ bubbleId: header.bubbleId, value: (conversationMap && conversationMap[header.bubbleId] !== undefined)
+                ? conversationMap[header.bubbleId]
+                : readBubble(composerId, header.bubbleId) ?? inlineById.get(header.bubbleId) }))
+        : inline.length > 0
+            ? inline
+            : (conversationMap ? Object.entries(conversationMap).map(([bubbleId, value]) => ({ bubbleId, value })) : []);
     const turns = [];
-    for (const bubbleId of orderedBubbleIds) {
-        const bubble = (conversationMap && conversationMap[bubbleId] !== undefined)
-            ? conversationMap[bubbleId]
-            : readBubble(composerId, bubbleId);
-        turns.push(...bubbleToTurns(bubble, bubbleId));
+    for (const bubble of orderedBubbles) {
+        turns.push(...bubbleToTurns(bubble.value, bubble.bubbleId));
+        turns.push(...contentTurns('assistant', codeBlocks.byBubble.get(bubble.bubbleId) ?? []));
     }
+    turns.push(...contentTurns('assistant', codeBlocks.trailing));
     const model = isRecord(composer['modelConfig']) ? asString(composer['modelConfig']['modelName']) : '';
     const createdAt = finiteNumber(composer['createdAt']);
+    if (createdAt !== undefined && Math.abs(createdAt) > 8_640_000_000_000_000) {
+        throw new CursorStateVscdbError('schema', 'composer createdAt is outside the supported date range');
+    }
     return {
         turns: correlateToolNames(turns),
         sessionId: composerId,
@@ -155,51 +326,93 @@ function composerToSession(composer, composerId, readBubble) {
 }
 /**
  * Read Cursor chat sessions out of a `state.vscdb` sqlite database (read-only). Returns one NormalizedSession per
- * composer that has at least one real (non-meta) turn. Never throws on a malformed/locked db — returns []. The db
- * is opened read-only, so it is safe to run against a live Cursor profile.
+ * composer that has at least one real (non-meta) turn. A valid database with no sessions returns []; database open,
+ * query, and incompatible-schema failures throw CursorStateVscdbError. The database is always opened read-only.
  */
 export function parseCursorStateVscdb(dbPath) {
     let db;
     try {
-        db = openReadOnlySqliteDatabase(dbPath);
-        const composerRows = db
-            .prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'")
-            .all();
-        const bubbleStmt = db.prepare('SELECT value FROM cursorDiskKV WHERE key = ?');
-        const readBubble = (composerId, bubbleId) => {
+        try {
+            db = openReadOnlySqliteDatabase(dbPath);
+        }
+        catch (error) {
+            throw new CursorStateVscdbError('open', 'unable to open the file read-only', error);
+        }
+        let columns;
+        try {
+            columns = db.prepare('PRAGMA table_info(cursorDiskKV)').all();
+        }
+        catch (error) {
+            throw new CursorStateVscdbError('query', 'unable to inspect cursorDiskKV', error);
+        }
+        const columnNames = new Set(columns.flatMap((column) => isRecord(column) ? [asString(column['name'])] : []));
+        if (!columnNames.has('key') || !columnNames.has('value')) {
+            throw new CursorStateVscdbError('schema', 'cursorDiskKV with key and value columns is required');
+        }
+        let composerRows;
+        let valueStmt;
+        try {
+            composerRows = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'").all();
+            valueStmt = db.prepare('SELECT value FROM cursorDiskKV WHERE key = ?');
+        }
+        catch (error) {
+            throw new CursorStateVscdbError('query', 'unable to query Cursor conversations', error);
+        }
+        const parseJsonValue = (value, label) => {
+            const text = typeof value === 'string'
+                ? value
+                : value instanceof Uint8Array
+                    ? new TextDecoder().decode(value)
+                    : undefined;
+            if (text === undefined) {
+                throw new CursorStateVscdbError('schema', `${label} value must be JSON text or a UTF-8 blob`);
+            }
             try {
-                const row = bubbleStmt.get(`bubbleId:${composerId}:${bubbleId}`);
-                if (!row || typeof row.value !== 'string')
-                    return undefined;
-                return JSON.parse(row.value);
+                return JSON.parse(text);
             }
-            catch {
-                return undefined;
+            catch (error) {
+                throw new CursorStateVscdbError('schema', `${label} contains invalid JSON`, error);
+            }
+        };
+        const readValue = (key, label) => {
+            let row;
+            try {
+                row = valueStmt.get(key);
+            }
+            catch (error) {
+                throw new CursorStateVscdbError('query', `unable to query a Cursor ${label}`, error);
             }
+            if (!row)
+                return undefined;
+            return parseJsonValue(row.value, label);
         };
+        const readBubble = (composerId, bubbleId) => readValue(`bubbleId:${composerId}:${bubbleId}`, 'conversation bubble');
+        const readCodeBlockDiff = (composerId, diffId) => readValue(`codeBlockDiff:${composerId}:${diffId}`, 'code block diff');
         const sessions = [];
+        let firstComposerError;
         for (const row of composerRows) {
-            if (typeof row.value !== 'string')
-                continue;
-            let composer;
             try {
-                composer = JSON.parse(row.value);
+                const composer = parseJsonValue(row.value, 'composer');
+                if (!isRecord(composer))
+                    throw new CursorStateVscdbError('schema', 'composer must be a JSON object');
+                const composerId = asString(row.key).replace(/^composerData:/, '') || asString(composer['composerId']);
+                if (!composerId)
+                    throw new CursorStateVscdbError('schema', 'composer id is missing');
+                const session = composerToSession(composer, composerId, readBubble, readCodeBlockDiff);
+                if (session.turns.some((turn) => turn.isMeta !== true))
+                    sessions.push(session);
             }
-            catch {
-                continue;
+            catch (error) {
+                if (!(error instanceof CursorStateVscdbError) || error.stage !== 'schema')
+                    throw error;
+                firstComposerError ??= error;
             }
-            if (!isRecord(composer))
-                continue;
-            const composerId = asString(row.key).replace(/^composerData:/, '') || asString(composer['composerId']);
-            const session = composerToSession(composer, composerId, readBubble);
-            if (session.turns.some((turn) => turn.isMeta !== true))
-                sessions.push(session);
         }
+        // Returning only the healthy composers would silently produce an incomplete archive.
+        if (firstComposerError)
+            throw firstComposerError;
         return sessions;
     }
-    catch {
-        return [];
-    }
     finally {
         try {
             db?.close();

package/dist/evidenceSummary.d.ts

@@ -0,0 +1,19 @@
+import type { NormalizedSession } from './types.js';
+export type RuntimeSessionEvidenceCoverage = 'complete' | 'partial' | 'empty';
+export type RuntimeSessionEvidenceGapCode = 'empty_session' | 'missing_tool_result' | 'unmatched_tool_result';
+export interface RuntimeSessionEvidenceCounts {
+    nonMetaTurns: number;
+    toolCalls: number;
+    toolResults: number;
+    matchedToolResults: number;
+    missingToolResults: number;
+    unmatchedToolResults: number;
+    failedToolResults: number;
+}
+export interface RuntimeSessionEvidenceSummary {
+    coverage: RuntimeSessionEvidenceCoverage;
+    counts: RuntimeSessionEvidenceCounts;
+    gapCodes: RuntimeSessionEvidenceGapCode[];
+}
+/** Summarizes transcript structure only; complete coverage does not verify the task outcome. */
+export declare function summarizeSessionEvidence(session: Pick<NormalizedSession, 'turns'>): RuntimeSessionEvidenceSummary;

package/dist/evidenceSummary.js

@@ -0,0 +1,73 @@
+function toolUseId(turn) {
+    const id = turn.toolUseId;
+    return id?.trim() ? id : undefined;
+}
+function isToolCall(turn) {
+    return turn.role === 'assistant'
+        && turn.toolResult === undefined
+        && (turn.toolUseId !== undefined
+            || turn.toolInput !== undefined
+            || turn.toolName !== undefined);
+}
+function isToolResult(turn) {
+    return turn.role === 'tool';
+}
+/** Summarizes transcript structure only; complete coverage does not verify the task outcome. */
+export function summarizeSessionEvidence(session) {
+    const turns = session.turns.filter((turn) => turn.isMeta !== true);
+    const pendingCallsById = new Map();
+    let toolCalls = 0;
+    let toolResults = 0;
+    let matchedToolResults = 0;
+    let unmatchedToolResults = 0;
+    let failedToolResults = 0;
+    for (const turn of turns) {
+        if (isToolCall(turn)) {
+            toolCalls += 1;
+            const id = toolUseId(turn);
+            if (id)
+                pendingCallsById.set(id, (pendingCallsById.get(id) ?? 0) + 1);
+            continue;
+        }
+        if (isToolResult(turn)) {
+            toolResults += 1;
+            if (turn.errorMessage !== undefined)
+                failedToolResults += 1;
+            const id = toolUseId(turn);
+            const pending = id ? pendingCallsById.get(id) ?? 0 : 0;
+            if (id && pending > 0) {
+                matchedToolResults += 1;
+                if (pending === 1)
+                    pendingCallsById.delete(id);
+                else
+                    pendingCallsById.set(id, pending - 1);
+            }
+            else {
+                unmatchedToolResults += 1;
+            }
+        }
+    }
+    const missingToolResults = toolCalls - matchedToolResults;
+    const counts = {
+        nonMetaTurns: turns.length,
+        toolCalls,
+        toolResults,
+        matchedToolResults,
+        missingToolResults,
+        unmatchedToolResults,
+        failedToolResults,
+    };
+    const gapCodes = [];
+    if (turns.length === 0)
+        gapCodes.push('empty_session');
+    else {
+        if (missingToolResults > 0)
+            gapCodes.push('missing_tool_result');
+        if (unmatchedToolResults > 0)
+            gapCodes.push('unmatched_tool_result');
+    }
+    const coverage = turns.length === 0
+        ? 'empty'
+        : gapCodes.length > 0 ? 'partial' : 'complete';
+    return { coverage, counts, gapCodes };
+}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export declare const PACKAGE = "@evomap/evolver-runtime-adapters";
 export * from './types.js';
+export * from './evidenceSummary.js';
 export * from './adapters.js';
 export * from './cursorState.js';

package/dist/index.js

@@ -1,4 +1,5 @@
 export const PACKAGE = '@evomap/evolver-runtime-adapters';
 export * from './types.js';
+export * from './evidenceSummary.js';
 export * from './adapters.js';
 export * from './cursorState.js';

package/dist/types.d.ts

@@ -67,11 +67,17 @@ export interface NormalizedSession {
     sourceRecord?: unknown;
     rawRows?: unknown[];
 }
+export interface NativeResumeIdentity {
+    harness: 'claude-code' | 'cursor';
+    sessionId: string;
+}
 export interface SessionLogAdapter {
     readonly agent: string;
     detect(path: string): boolean;
     /** Derive a stable runtime session id when the transcript itself does not carry one. */
     sessionIdFromPath?(path: string): string | undefined;
+    /** Resolve a harness-bound native session identity from a verified transcript source. */
+    resumeIdentityFromSource?(path: string, rawChunk: string): NativeResumeIdentity | undefined;
     parse(rawChunk: string): NormalizedTurn[];
     parseSession?(rawChunk: string): NormalizedSession;
     parseSessions?(rawChunk: string): NormalizedSession[];

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@evomap/evolver-runtime-adapters",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.22",
   "private": false,
   "type": "module",
+  "engines": {
+    "node": "^22.13.0 || >=23.4.0"
+  },
   "description": "五 runtime 会话日志适配器 (CC/codex/cursor/kiro/opencode)",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -12,6 +15,10 @@
       "default": "./dist/index.js"
     }
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EvoMap/evolver.git"
+  },
   "publishConfig": {
     "access": "public",
     "tag": "v2-beta"