dsh-reference-anything 0.3.1 → 0.3.3

package/lib/sources/local-agent/adapters/opencode.js

@@ -0,0 +1,236 @@
+/**
+ * Reads opencode's SQLite history, and mimocode's fork of it.
+ *
+ * opencode keeps every session it has ever run in one database under
+ * `~/.local/share/opencode/`, rather than one file per conversation. That single
+ * fact is why this is a {@link QueryAdapter} instead of a
+ * {@link TranscriptAdapter}: there is no byte offset that means "the start of
+ * this conversation", so a reference has to name the session as well as the
+ * file, and a listing is a query rather than a directory walk.
+ *
+ * mimocode is a fork of it, and older opencode builds differ from newer ones,
+ * so the columns that vary — `time_updated` here, `parent_id` in zcode — are
+ * probed rather than branched on a version number nobody writes down. What
+ * mimocode does not share is its background traffic: MiMo runs
+ * memory-consolidation and distillation sessions through the same tables as the
+ * user's own work, and those are filtered out of discovery.
+ *
+ * @module dsh-reference-anything/local-agent/adapters/opencode
+ */
+import { joinLocalPath } from "../path.js";
+import { COMPACTION_MARKER, createSharedState, flushAssistant, normalizeTitle, parseTimestamp } from "./shared.js";
+import { nestedText, parseBlob, readSessionMessages, stepSessionMessage } from "./sqlite-shared.js";
+/**
+ * Sessions MiMo runs for itself rather than for the user.
+ *
+ * Measured against a real `mimocode.db`: 822 `checkpoint-writer` sessions
+ * against a handful of real ones. Listing them would bury the user's own work
+ * under machinery they never started.
+ */
+const BACKGROUND_TITLE = /^(checkpoint[-_ ]?writer|auto[-_ ]?(dream|distill))\b/iu;
+/**
+ * How far discovery will over-fetch chasing enough non-background sessions.
+ *
+ * The filter is applied in this process rather than in SQL because the exact
+ * predicate is a regular expression and the SQL equivalent — a pile of `LIKE`
+ * patterns — would either miss forms or swallow a real session that happened to
+ * be titled about checkpoints. Over-fetching is the cost of getting that right,
+ * and it is bounded here rather than left to widen without limit.
+ */
+const OVERFETCH_STEPS = [1, 4, 16];
+/** Reads opencode's session database. */
+export const opencodeAdapter = variantAdapter({
+    kind: 'opencode',
+    displayName: 'opencode',
+    dataDir: 'opencode',
+    dbName: 'opencode.db',
+    background: false,
+});
+/** Reads mimocode's session database, minus its own background traffic. */
+export const mimocodeAdapter = variantAdapter({
+    kind: 'mimocode',
+    displayName: 'mimocode',
+    dataDir: 'mimocode',
+    dbName: 'mimocode.db',
+    background: true,
+});
+/**
+ * Whether a session is MiMo's own background work rather than the user's.
+ *
+ * Exported for the tests, which is the only way to pin a filter whose whole job
+ * is to be invisible when it works.
+ * @param title - the session's recorded title.
+ * @returns whether discovery should hide it.
+ */
+export function isBackgroundSession(title) {
+    return BACKGROUND_TITLE.test(title.trim());
+}
+function variantAdapter(variant) {
+    return {
+        kind: variant.kind,
+        displayName: variant.displayName,
+        query: true,
+        defaultRoots(home) {
+            // The root is the directory, not the database: discovery walks
+            // directories, and pointing it at a file would make the one format that
+            // needs no walking the only one that needs a special case.
+            return [joinLocalPath(home, '.local', 'share', variant.dataDir)];
+        },
+        matches(relativePath) {
+            // Exact, so SQLite's `-wal` and `-shm` sidecars are not mistaken for
+            // databases and a backup copy is not listed as a second corpus.
+            return relativePath.split(/[\\/]/u).at(-1) === variant.dbName;
+        },
+        sessions(db, limit) {
+            const query = sessionQuery(db);
+            if (query === undefined)
+                return [];
+            const wanted = Math.max(1, Math.trunc(limit));
+            let kept = [];
+            for (const step of OVERFETCH_STEPS) {
+                const ask = wanted * step;
+                const rows = db.all(`SELECT ${query.fields} FROM session ORDER BY ${query.recency} DESC, id DESC LIMIT ?`, ask);
+                kept = [];
+                for (const row of rows) {
+                    const session = toSession(row, query.recency);
+                    if (session === undefined)
+                        continue;
+                    if (variant.background && isBackgroundSession(session.title))
+                        continue;
+                    kept.push(session);
+                    if (kept.length >= wanted)
+                        break;
+                }
+                // Enough survived the filter, or the database has nothing more to give.
+                if (kept.length >= wanted || rows.length < ask)
+                    break;
+            }
+            return kept;
+        },
+        session(db, sessionId) {
+            const query = sessionQuery(db);
+            if (query === undefined)
+                return undefined;
+            const [row] = db.all(`SELECT ${query.fields} FROM session WHERE id = ? LIMIT 1`, sessionId);
+            return row === undefined ? undefined : toSession(row, query.recency);
+        },
+        turns(db, sessionId, options, maxRecords) {
+            const { messages, truncated } = readSessionMessages(db, sessionId, maxRecords);
+            const { kept, summary, compacted } = applyCompaction(messages);
+            const state = createSharedState();
+            const items = [];
+            // The summary stands where the discarded turns were: first, so the reader
+            // meets it before the tail it explains.
+            if (summary !== undefined)
+                items.push({ role: 'assistant', text: `${COMPACTION_MARKER}\n\n${summary}` });
+            for (const message of kept)
+                items.push(...stepSessionMessage(state, message, options));
+            items.push(...flushAssistant(state));
+            return { items, truncated, compacted };
+        },
+    };
+}
+/**
+ * Which columns this build has, resolved once per query.
+ *
+ * `time_updated` is the one that actually varies between the two forks and
+ * across opencode's own history, so it is probed rather than assumed; a build
+ * without it orders and dates sessions by when they started.
+ * @param db - a read-only reader over the database.
+ * @returns the select list and recency column, or undefined when there is no `session` table.
+ */
+function sessionQuery(db) {
+    const columns = db.columns('session');
+    if (columns.size === 0)
+        return undefined;
+    const recency = columns.has('time_updated') ? 'time_updated' : 'time_created';
+    const fields = ['id', 'title', 'directory', 'time_created'];
+    if (recency === 'time_updated')
+        fields.push('time_updated');
+    return { fields: fields.join(', '), recency };
+}
+/**
+ * Project one `session` row.
+ * @param row - the row as read.
+ * @param recency - which column carries last activity.
+ * @returns the session, or undefined when the row has no usable id.
+ */
+function toSession(row, recency) {
+    const id = typeof row['id'] === 'string' ? row['id'] : String(row['id'] ?? '');
+    if (id === '')
+        return undefined;
+    const createdAt = parseTimestamp(row['time_created']) ?? 0;
+    return {
+        id,
+        title: normalizeTitle(row['title']),
+        cwd: typeof row['directory'] === 'string' ? row['directory'] : '',
+        createdAt,
+        updatedAt: parseTimestamp(row[recency]) ?? createdAt,
+    };
+}
+/**
+ * Honour the compaction opencode recorded, rather than unwinding it.
+ *
+ * A `compaction` part names the message the surviving tail starts at, and the
+ * summary message beside it stands in for everything before. Replaying the
+ * discarded messages would contradict what the agent itself decided to forget;
+ * what is kept is the tail plus the summary, and the caller marks the read
+ * partial so the loss is visible.
+ * @param messages - the session's messages, oldest first.
+ * @returns the messages to fold, the summary text, and whether a boundary was crossed.
+ */
+function applyCompaction(messages) {
+    let tailStart;
+    let summary;
+    for (const message of messages) {
+        for (const part of message.parts) {
+            if (part['type'] === 'compaction' && typeof part['tail_start_id'] === 'string') {
+                tailStart = part['tail_start_id'];
+            }
+        }
+        if (!isSummaryMessage(message))
+            continue;
+        const text = message.parts
+            .filter(part => part['type'] === 'text' && typeof part['text'] === 'string')
+            .map(part => String(part['text']).trim())
+            .filter(text => text !== '')
+            .join('\n')
+            .trim();
+        if (text !== '')
+            summary = text;
+    }
+    if (tailStart === undefined)
+        return { kept: messages, summary: undefined, compacted: false };
+    const at = messages.findIndex(message => message.id === tailStart);
+    // A `tail_start_id` pointing at a message the record cap already dropped is
+    // not a reason to discard the tail we do have.
+    if (at < 0)
+        return { kept: messages, summary, compacted: true };
+    return { kept: messages.slice(at).filter(message => !isSummaryMessage(message)), summary, compacted: true };
+}
+/** Whether a message is a compaction summary rather than part of the conversation. */
+function isSummaryMessage(message) {
+    return message.data['mode'] === 'compaction' || message.data['summary'] === true;
+}
+/**
+ * The working directory a session ran in, when the session row did not record one.
+ *
+ * Older opencode databases leave `session.directory` empty and put the path on
+ * each message instead, so this is the fallback discovery uses before deciding
+ * a session belongs to no workspace.
+ * @param db - a read-only reader over the database.
+ * @param sessionId - the conversation to inspect.
+ * @returns the recorded cwd, or undefined when no message carries one.
+ */
+export function sessionCwd(db, sessionId) {
+    const rows = db.all('SELECT data FROM message WHERE session_id = ? ORDER BY time_created, id LIMIT 8', sessionId);
+    for (const row of rows) {
+        const data = parseBlob(row['data']);
+        if (data === undefined)
+            continue;
+        const cwd = nestedText(data, 'path', 'cwd');
+        if (cwd !== undefined)
+            return cwd;
+    }
+    return undefined;
+}

package/lib/sources/local-agent/adapters/pi.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Pi Coding Agent sessions:
+ * `~/.pi/agent/sessions/--<cwd>--/<stamp>_<uuid>.jsonl`.
+ *
+ * Line-delimited, but not linear. Every entry after the `session` header
+ * carries an `id` and a `parentId`, and the file accumulates *all* branches a
+ * session explored — so reading it front to back would interleave abandoned
+ * attempts with the one that was kept. The conversation is the path from the
+ * last entry back to the root, which is only knowable once the file has ended;
+ * hence {@link TranscriptAdapter.document}. Older v1 files have no ids at all
+ * and are treated as a chain in write order.
+ *
+ * Compaction is respected rather than unwound: from the newest `compaction` on
+ * the active path, the conversation is its summary, then whatever it retained,
+ * then everything after it. The entries it replaced are not in the file to
+ * read, so the summary is the only surviving account of them.
+ *
+ * Pi also names its blocks differently from the Messages API — a tool call's
+ * argument bag is `arguments`, not `input` — which the shared block renderer
+ * already accepts.
+ *
+ * @module dsh-reference-anything/local-agent/adapters/pi
+ */
+import type { TranscriptAdapter } from '../types.ts';
+/** Reads Pi Coding Agent sessions. */
+export declare const piAdapter: TranscriptAdapter;

package/lib/sources/local-agent/adapters/pi.js

@@ -0,0 +1,242 @@
+/**
+ * Pi Coding Agent sessions:
+ * `~/.pi/agent/sessions/--<cwd>--/<stamp>_<uuid>.jsonl`.
+ *
+ * Line-delimited, but not linear. Every entry after the `session` header
+ * carries an `id` and a `parentId`, and the file accumulates *all* branches a
+ * session explored — so reading it front to back would interleave abandoned
+ * attempts with the one that was kept. The conversation is the path from the
+ * last entry back to the root, which is only knowable once the file has ended;
+ * hence {@link TranscriptAdapter.document}. Older v1 files have no ids at all
+ * and are treated as a chain in write order.
+ *
+ * Compaction is respected rather than unwound: from the newest `compaction` on
+ * the active path, the conversation is its summary, then whatever it retained,
+ * then everything after it. The entries it replaced are not in the file to
+ * read, so the summary is the only surviving account of them.
+ *
+ * Pi also names its blocks differently from the Messages API — a tool call's
+ * argument bag is `arguments`, not `input` — which the shared block renderer
+ * already accepts.
+ *
+ * @module dsh-reference-anything/local-agent/adapters/pi
+ */
+import { joinLocalPath } from "../path.js";
+import { COMPACTION_MARKER, arrayField, blankToUndefined, createSharedState, emitUser, flushAssistant, holdLine, normalizeTitle, objectField, parseRecord, parseTimestamp, pushAssistant, pushContentBlocks, renderToolResult, stringField, takeHeld, } from "./shared.js";
+/** Precedes the text summarizing a branch the session came back from. */
+const BRANCH_MARKER = '[summary of an earlier branch]';
+/** Reads Pi Coding Agent sessions. */
+export const piAdapter = {
+    kind: 'pi',
+    displayName: 'Pi',
+    document: true,
+    defaultRoots(home) {
+        return [joinLocalPath(home, '.pi', 'agent', 'sessions')];
+    },
+    matches(relativePath) {
+        return relativePath.toLowerCase().endsWith('.jsonl');
+    },
+    createState() {
+        return createSharedState();
+    },
+    step(line, state, _options) {
+        return holdLine(state, line);
+    },
+    flush(state, options) {
+        const document = takeHeld(state);
+        if (document === undefined)
+            return flushAssistant(state);
+        const entries = [];
+        for (const line of document.split('\n')) {
+            const record = parseRecord(line);
+            if (record === undefined || record['type'] === 'session')
+                continue;
+            const id = stringField(record, 'id') ?? `e${entries.length}`;
+            // v1 wrote no ids, so an entry with no parent continues the previous
+            // one. That makes the "tree" a chain, which is what v1 sessions are.
+            const parentId = typeof record['parentId'] === 'string'
+                ? record['parentId']
+                : entries[entries.length - 1]?.id;
+            entries.push({ id, parentId, record });
+        }
+        const turns = [];
+        for (const item of compacted(activeBranch(entries), state)) {
+            turns.push(...foldEntry(item, state, options));
+        }
+        turns.push(...flushAssistant(state));
+        return turns;
+    },
+    head(headLines, tailLines) {
+        let cwd;
+        let createdAt;
+        let named;
+        let firstPrompt;
+        // Pi's header is the first line, so a probe of the start always reaches
+        // it — the branch tree only matters once turns are being read.
+        for (const line of [...headLines, ...tailLines]) {
+            const record = parseRecord(line);
+            if (record === undefined)
+                continue;
+            if (record['type'] === 'session') {
+                cwd ??= stringField(record, 'cwd');
+                createdAt ??= parseTimestamp(record['timestamp']);
+                continue;
+            }
+            // A rename writes another `session_info`, so the newest one wins.
+            if (record['type'] === 'session_info')
+                named = stringField(record, 'name') ?? named;
+        }
+        for (const line of headLines) {
+            const record = parseRecord(line);
+            if (record?.['type'] !== 'message')
+                continue;
+            const message = objectField(record, 'message');
+            if (message?.['role'] !== 'user')
+                continue;
+            firstPrompt = blankToUndefined(userText(message['content']));
+            if (firstPrompt !== undefined)
+                break;
+        }
+        const title = normalizeTitle(named ?? firstPrompt ?? '');
+        return {
+            ...title === '' ? {} : { title },
+            ...cwd === undefined ? {} : { cwd },
+            ...firstPrompt === undefined ? {} : { firstPrompt },
+            ...createdAt === undefined ? {} : { createdAt },
+        };
+    },
+};
+/**
+ * The path from the newest entry back to the root, in write order.
+ *
+ * The last entry is the leaf of whichever branch the session ended on, so
+ * walking its parents recovers exactly the conversation a person would say
+ * happened and discards the attempts they backed out of.
+ * @param entries - every entry in the file, in write order.
+ * @returns the active path, oldest first.
+ */
+function activeBranch(entries) {
+    const byId = new Map(entries.map(entry => [entry.id, entry]));
+    const path = [];
+    const seen = new Set();
+    let cursor = entries[entries.length - 1];
+    while (cursor !== undefined && !seen.has(cursor.id)) {
+        seen.add(cursor.id);
+        path.push(cursor);
+        cursor = cursor.parentId === undefined ? undefined : byId.get(cursor.parentId);
+    }
+    return path.reverse();
+}
+/**
+ * Trim the path to what survived the newest compaction on it.
+ *
+ * A `compaction` entry states that everything before it is gone and carries
+ * both a summary and, on modern files, the tail it kept verbatim. Older files
+ * name the first surviving entry instead.
+ * @param path - the active branch, oldest first.
+ * @param state - fold state; marked compacted when a boundary is crossed.
+ * @returns the entries to fold, oldest first.
+ */
+function compacted(path, state) {
+    let at = -1;
+    for (let index = path.length - 1; index >= 0; index -= 1) {
+        if (path[index]?.record['type'] === 'compaction') {
+            at = index;
+            break;
+        }
+    }
+    const boundary = at < 0 ? undefined : path[at];
+    if (boundary === undefined)
+        return path;
+    state.compacted = true;
+    const kept = [boundary];
+    const retained = arrayField(boundary.record, 'retainedTail');
+    if (retained !== undefined) {
+        for (const message of retained) {
+            kept.push({ id: '', parentId: undefined, record: { type: 'message', message } });
+        }
+    }
+    else {
+        const from = stringField(boundary.record, 'firstKeptEntryId');
+        const start = from === undefined ? -1 : path.findIndex(entry => entry.id === from);
+        if (start >= 0)
+            kept.push(...path.slice(start, at));
+    }
+    kept.push(...path.slice(at + 1));
+    return kept;
+}
+/** Fold one entry on the active path. */
+function foldEntry(entry, state, options) {
+    const record = entry.record;
+    switch (record['type']) {
+        case 'message':
+            return foldMessage(objectField(record, 'message'), state, options);
+        case 'compaction':
+            pushAssistant(state, marked(COMPACTION_MARKER, stringField(record, 'summary')));
+            return [];
+        case 'branch_summary':
+            pushAssistant(state, marked(BRANCH_MARKER, stringField(record, 'summary')));
+            return [];
+        default:
+            // `model_change`, `thinking_level_change`, `label`, `session_info`, and
+            // the extension-injected `custom` entries are session state.
+            return [];
+    }
+}
+/** Fold one embedded `AgentMessage`, whose role vocabulary is Pi's own. */
+function foldMessage(message, state, options) {
+    if (message === undefined)
+        return [];
+    switch (message['role']) {
+        case 'user': {
+            const text = blankToUndefined(userText(message['content']));
+            return text === undefined ? [] : emitUser(state, text);
+        }
+        case 'assistant':
+            pushContentBlocks(state, arrayField(message, 'content'), options);
+            return [];
+        case 'toolResult':
+        case 'bashExecution':
+            pushAssistant(state, renderToolResult(message['content'], options.toolResults, options.toolSummaryChars));
+            return [];
+        case 'compactionSummary':
+            pushAssistant(state, marked(COMPACTION_MARKER, stringField(message, 'summary')));
+            return [];
+        case 'branchSummary':
+            pushAssistant(state, marked(BRANCH_MARKER, stringField(message, 'summary')));
+            return [];
+        default:
+            // `custom` is an extension's injected context.
+            return [];
+    }
+}
+/**
+ * Flatten a Pi content value to the words a person typed.
+ * @param content - the message's `content`, a string or a block array.
+ * @returns the flattened text; empty when nothing readable was found.
+ */
+function userText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (typeof block !== 'object' || block === null)
+            continue;
+        const entry = block;
+        if (entry['type'] === 'text' && typeof entry['text'] === 'string' && entry['text'].trim() !== '') {
+            parts.push(entry['text'].trim());
+        }
+        else if (entry['type'] === 'image') {
+            const mime = typeof entry['mimeType'] === 'string' ? entry['mimeType'] : 'image';
+            parts.push(`[image: ${mime}]`);
+        }
+    }
+    return parts.join('\n');
+}
+/** Label a summary so it does not read as something the assistant just said. */
+function marked(marker, summary) {
+    const text = summary?.trim() ?? '';
+    return text === '' ? undefined : `${marker}\n\n${text}`;
+}

package/lib/sources/local-agent/adapters/qoder.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Qoder CLI sessions: `~/.qoder/projects/<encoded-project>/<sessionId>.jsonl`.
+ *
+ * Qoder adopted Claude Code's record layout nearly verbatim — the same `user`
+ * and `assistant` envelopes around a Messages-API `message`, the same
+ * `ai-title` and `last-prompt` state records, the same `cwd` on every entry —
+ * so the fold is the same one, and this adapter exists mainly to own the
+ * different roots and the subagent rule.
+ *
+ * That rule is the one thing worth stating: Qoder writes a spawned subagent's
+ * transcript to `<sessionId>/subagents/*.jsonl` while stamping it with the
+ * *parent's* `sessionId`. Listing those as sessions of their own would give
+ * two entries the same identity, so they are rejected by path.
+ *
+ * @module dsh-reference-anything/local-agent/adapters/qoder
+ */
+import type { TranscriptAdapter } from '../types.ts';
+/** Reads Qoder CLI session transcripts. */
+export declare const qoderAdapter: TranscriptAdapter;

package/lib/sources/local-agent/adapters/qoder.js

@@ -0,0 +1,93 @@
+/**
+ * Qoder CLI sessions: `~/.qoder/projects/<encoded-project>/<sessionId>.jsonl`.
+ *
+ * Qoder adopted Claude Code's record layout nearly verbatim — the same `user`
+ * and `assistant` envelopes around a Messages-API `message`, the same
+ * `ai-title` and `last-prompt` state records, the same `cwd` on every entry —
+ * so the fold is the same one, and this adapter exists mainly to own the
+ * different roots and the subagent rule.
+ *
+ * That rule is the one thing worth stating: Qoder writes a spawned subagent's
+ * transcript to `<sessionId>/subagents/*.jsonl` while stamping it with the
+ * *parent's* `sessionId`. Listing those as sessions of their own would give
+ * two entries the same identity, so they are rejected by path.
+ *
+ * @module dsh-reference-anything/local-agent/adapters/qoder
+ */
+import { joinLocalPath } from "../path.js";
+import { arrayField, contentBlockUserText, createSharedState, emitUser, flushAssistant, normalizeTitle, objectField, parseRecord, parseTimestamp, pushAssistant, pushContentBlocks, pushToolResults, stringField, } from "./shared.js";
+/** Reads Qoder CLI session transcripts. */
+export const qoderAdapter = {
+    kind: 'qoder',
+    displayName: 'Qoder',
+    defaultRoots(home) {
+        return [joinLocalPath(home, '.qoder', 'projects')];
+    },
+    matches(relativePath) {
+        const path = relativePath.toLowerCase();
+        return path.endsWith('.jsonl') && !path.includes('/subagents/');
+    },
+    createState() {
+        return createSharedState();
+    },
+    step(line, state, options) {
+        const record = parseRecord(line);
+        if (record === undefined)
+            return [];
+        const message = objectField(record, 'message');
+        if (record['type'] === 'user') {
+            pushToolResults(state, message?.['content'], options);
+            const text = contentBlockUserText(message?.['content']);
+            return text === undefined ? [] : emitUser(state, text);
+        }
+        if (record['type'] === 'assistant') {
+            const content = message?.['content'];
+            if (typeof content === 'string')
+                pushAssistant(state, content);
+            else
+                pushContentBlocks(state, arrayField(message, 'content'), options);
+            return [];
+        }
+        // `ai-title`, `last-prompt`, `mode`, and the subagent metadata records are
+        // CLI state; head() reads the two that name the session.
+        return [];
+    },
+    flush(state, _options) {
+        return flushAssistant(state);
+    },
+    head(headLines, tailLines) {
+        let aiTitle;
+        let lastPrompt;
+        let cwd;
+        let createdAt;
+        let firstPrompt;
+        // Later wins for the two title records: Qoder rewrites `ai-title` as the
+        // session is renamed, so the newest one in the tail is the current name.
+        for (const line of [...headLines, ...tailLines]) {
+            const record = parseRecord(line);
+            if (record === undefined)
+                continue;
+            if (record['type'] === 'ai-title')
+                aiTitle = stringField(record, 'aiTitle') ?? aiTitle;
+            else if (record['type'] === 'last-prompt')
+                lastPrompt = stringField(record, 'lastPrompt') ?? lastPrompt;
+            cwd ??= stringField(record, 'cwd');
+            createdAt ??= parseTimestamp(record['timestamp']);
+        }
+        for (const line of headLines) {
+            const record = parseRecord(line);
+            if (record?.['type'] !== 'user')
+                continue;
+            firstPrompt = contentBlockUserText(objectField(record, 'message')?.['content']);
+            if (firstPrompt !== undefined)
+                break;
+        }
+        const title = normalizeTitle(aiTitle ?? lastPrompt ?? firstPrompt ?? '');
+        return {
+            ...title === '' ? {} : { title },
+            ...cwd === undefined ? {} : { cwd },
+            ...firstPrompt === undefined ? {} : { firstPrompt },
+            ...createdAt === undefined ? {} : { createdAt },
+        };
+    },
+};

package/lib/sources/local-agent/adapters/reasonix.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Reasonix sessions: `~/.reasonix/sessions/<stem>.jsonl`.
+ *
+ * Records are OpenAI chat messages written straight to disk with no envelope
+ * — `{role, content}` and nothing wrapping it — which makes this the one
+ * supported format whose lines would be valid request payloads as they stand.
+ *
+ * Two versions are in the wild and both are accepted: v1 nests a tool call
+ * under `function: {name, arguments}`, v2 flattens it to `{name, arguments}`.
+ * `arguments` is a JSON *string* in both, which the shared renderer handles.
+ *
+ * Sibling files share the directory — `<stem>.meta.json` holds the workspace
+ * and summary, `<stem>.events.jsonl` is a write-ahead log replayed over the
+ * checkpoint — and neither is a transcript, so both are rejected by path. The
+ * WAL means a session's newest turns can be missing from the file this reads;
+ * that is a staleness bound, not a correctness one, and it resolves itself the
+ * next time Reasonix checkpoints.
+ *
+ * @module dsh-reference-anything/local-agent/adapters/reasonix
+ */
+import type { TranscriptAdapter } from '../types.ts';
+/** Reads Reasonix session transcripts. */
+export declare const reasonixAdapter: TranscriptAdapter;