@askdkc/dsh-cli 0.11.3

package/lib/types/dsh-adapter/migrate/adapters/claude-code.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationAdapter } from '../types.js';
+export declare const claudeCodeAdapter: MigrationAdapter;
+//# sourceMappingURL=claude-code.d.ts.map

package/lib/types/dsh-adapter/migrate/adapters/claude-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-code.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/claude-code.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,gBAAgB,EAAuD,MAAM,aAAa,CAAA;AAuHxG,eAAO,MAAM,iBAAiB,EAAE,gBAmC/B,CAAA"}

package/lib/types/dsh-adapter/migrate/adapters/claude-code.js

@@ -0,0 +1,191 @@
+/**
+ * Claude Code adapter: `~/.claude/projects/<munged-cwd>/<session>.jsonl`.
+ * Lines are self-describing (`type` field); user/assistant message lines carry
+ * `message.content` as a plain string OR a content-block array — both are
+ * normalized here. Tool results surface as user lines with machine content
+ * and are skipped (their `content` is an array of tool_result blocks).
+ *
+ * @module dsh-cli/migrate/adapters/claude-code
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { countEntries } from './scan.js';
+function textOf(content) {
+    if (typeof content === 'string')
+        return content === '' ? undefined : content;
+    if (!Array.isArray(content))
+        return undefined;
+    const parts = [];
+    for (const block of content) {
+        if (block !== null && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string' && block.text !== '') {
+            parts.push(block.text);
+        }
+    }
+    return parts.length === 0 ? undefined : parts.join('\n\n');
+}
+/** Strip Claude Code's inline <system-reminder> machine blocks from user text.
+ *  Fast path first: plain text without the opening tag skips the regex
+ *  entirely (the lazy [\s\S]*? scan is O(text) per unclosed tag start and a
+ *  hostile single line could burn minutes of CPU — deep-review m1). */
+function stripReminders(text) {
+    if (!text.includes('<system-reminder'))
+        return text.trim();
+    return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gu, '').trim();
+}
+function toMillis(iso) {
+    return typeof iso === 'string' ? Date.parse(iso) || 0 : 0;
+}
+/** Extract the text of a user line, skipping tool_result-only lines. */
+function userText(message) {
+    if (message === undefined || message === null)
+        return undefined;
+    const content = message.content;
+    if (Array.isArray(content)) {
+        const blocks = content;
+        if (blocks.some(block => block?.type === 'tool_result'))
+            return undefined;
+    }
+    const raw = textOf(content);
+    if (raw === undefined)
+        return undefined;
+    const stripped = stripReminders(raw);
+    return stripped === '' ? undefined : stripped;
+}
+function readOne(path, fallbackCwd) {
+    let lines;
+    try {
+        lines = readFileSync(path, 'utf8').split('\n');
+    }
+    catch {
+        return undefined;
+    }
+    // basename(), not split('/'): join() produces `\` separators on Windows, so
+    // splitting on '/' would leave the WHOLE absolute path as the id — and the
+    // id is the dedupe key (moving the source store would re-import everything).
+    const sourceId = basename(path).replace(/\.jsonl$/u, '');
+    let startedAt = 0;
+    let turns = [];
+    let lineCwd;
+    for (const line of lines) {
+        if (line === '')
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        // A legal `null` (or scalar) line is not a record; reading .type on it
+        // would throw and kill the whole scan (codex adversarial review).
+        if (entry === null || typeof entry !== 'object')
+            continue;
+        const type = entry.type;
+        if (type === 'session' && startedAt === 0) {
+            startedAt = toMillis(entry.timestamp);
+            continue;
+        }
+        if (type !== 'user' && type !== 'assistant')
+            continue;
+        if (entry.isSidechain === true || entry.isMeta === true)
+            continue;
+        const message = entry.message;
+        if (!message || typeof message !== 'object')
+            continue; // !x also rejects JSON null (typeof null === 'object')
+        // Claude Code writes the authoritative cwd on every message line; the
+        // dash-munged directory name cannot preserve `_`/`.`/`-` and the
+        // system-reminder marker appears in only a small minority of logs.
+        if (typeof entry.cwd === 'string' && entry.cwd !== '')
+            lineCwd = entry.cwd;
+        const time = toMillis(entry.timestamp);
+        if (type === 'user') {
+            const text = userText(message);
+            if (text === undefined)
+                continue;
+            turns.push({ role: 'user', text, time });
+        }
+        else {
+            const content = message.content;
+            const text = textOf(content) ?? '';
+            // Claude Code thinking blocks carry the trace in a `thinking` field
+            // (not `text`); accept both so a pure-reasoning message never vanishes.
+            const reasoning = Array.isArray(content)
+                ? content.filter(block => block?.type === 'thinking')
+                    .map(block => block.thinking ?? block.text)
+                    .filter((t) => typeof t === 'string').join('\n\n')
+                : '';
+            if (text === '' && reasoning === '')
+                continue;
+            const model = typeof message.model === 'string' && message.model !== '' ? message.model : undefined;
+            turns.push({ role: 'assistant', text, reasoning: reasoning === '' ? undefined : reasoning, model, time });
+        }
+    }
+    if (turns.length === 0)
+        return undefined;
+    // cwd precedence: the per-line `cwd` field (authoritative, present on real
+    // logs) → the first user prompt's system-reminder → the unmunged directory
+    // name (lossy fallback for foreign/moved logs).
+    let cwd = lineCwd ?? fallbackCwd;
+    const reminder = turns.find(turn => turn.role === 'user' && turn.text.includes('Primary working directory:'));
+    if (cwd === fallbackCwd && reminder !== undefined) {
+        const match = /Primary working directory: (\S+)/u.exec(reminder.text);
+        if (match !== null)
+            cwd = match[1];
+    }
+    // A sidechain-heavy log may carry nothing but tool chatter; keep it honest.
+    const userTurns = turns.filter(turn => turn.role === 'user');
+    if (userTurns.length === 0)
+        return undefined;
+    turns = turns.filter(turn => turn.role === 'user' || turn.text !== '' || turn.reasoning !== undefined);
+    return { sourceId, cwd, startedAt: startedAt || turns[0].time, turns };
+}
+export const claudeCodeAdapter = {
+    id: 'claude-code',
+    label: 'Claude Code',
+    roots: () => [join(homedir(), '.claude', 'projects')],
+    discover() {
+        const roots = this.roots();
+        const sessions = [];
+        const walk = (dir, depth, fallbackCwd) => {
+            if (depth > 3)
+                return;
+            let entries;
+            try {
+                entries = readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                const path = join(dir, entry.name);
+                if (entry.isDirectory())
+                    walk(path, depth + 1, unmunge(entry.name) ?? fallbackCwd);
+                else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+                    try {
+                        if (statSync(path).size > 64 * 1024 * 1024)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    const session = readOne(path, fallbackCwd);
+                    if (session !== undefined)
+                        sessions.push(session);
+                }
+            }
+        };
+        for (const root of roots)
+            walk(root, 0, homedir());
+        return { roots, sessions };
+    },
+    count() {
+        return countEntries(this.roots(), { maxDepth: 3, fileMatch: name => name.endsWith('.jsonl') });
+    },
+};
+/** Best-effort inverse of Claude Code's dash-munged directory names. */
+function unmunge(name) {
+    if (!name.startsWith('-'))
+        return undefined;
+    return `/${name.split('-').filter(Boolean).join('/')}`;
+}

package/lib/types/dsh-adapter/migrate/adapters/codex.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationAdapter } from '../types.js';
+export declare const codexAdapter: MigrationAdapter;
+//# sourceMappingURL=codex.d.ts.map

package/lib/types/dsh-adapter/migrate/adapters/codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/codex.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,gBAAgB,EAAuD,MAAM,aAAa,CAAA;AAyExG,eAAO,MAAM,YAAY,EAAE,gBAmC1B,CAAA"}

package/lib/types/dsh-adapter/migrate/adapters/codex.js

@@ -0,0 +1,133 @@
+/**
+ * Codex adapter: `~/.codex/sessions/YYYY/MM/DD/rollout-<id>.jsonl`. The log
+ * interleaves `session_meta`, `response_item` (OpenAI Responses items —
+ * `message` with `input_text`/`output_text` blocks; `reasoning` is encrypted
+ * and stays unreadable) and `event_msg` housekeeping, which we skip.
+ *
+ * @module dsh-cli/migrate/adapters/codex
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { countEntries } from './scan.js';
+function blocksText(content, want) {
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (block?.type === want && typeof block.text === 'string' && block.text !== '')
+            parts.push(block.text);
+    }
+    return parts.join('\n\n');
+}
+function toMillis(iso) {
+    return typeof iso === 'string' ? Date.parse(iso) || 0 : 0;
+}
+function readOne(path) {
+    let lines;
+    try {
+        lines = readFileSync(path, 'utf8').split('\n');
+    }
+    catch {
+        return undefined;
+    }
+    const match = /rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/u.exec(path);
+    // Fallback is the bare file name, never the whole path: the id is the dedupe
+    // key, so an absolute path would make it depend on where the store lives.
+    const sourceId = match?.[1] ?? basename(path);
+    let cwd;
+    let startedAt = 0;
+    let lastModel;
+    const turns = [];
+    for (const line of lines) {
+        if (line === '')
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        // A legal `null` (or scalar) line is not a record; reading .type on it
+        // would throw and kill the whole scan (codex adversarial review).
+        if (entry === null || typeof entry !== 'object')
+            continue;
+        const payload = entry.payload;
+        if (!payload || typeof payload !== 'object')
+            continue; // !x also rejects JSON null (typeof null === 'object')
+        const time = toMillis(entry.timestamp);
+        if (entry.type === 'session_meta') {
+            if (typeof payload.cwd === 'string' && payload.cwd !== '')
+                cwd = payload.cwd;
+            startedAt = startedAt || toMillis(payload.timestamp) || time;
+            continue;
+        }
+        // Codex records the active model per turn in `turn_context`; carry the
+        // latest forward so assistant turns can cite the model that wrote them.
+        if (entry.type === 'turn_context' && typeof payload.model === 'string' && payload.model !== '') {
+            lastModel = payload.model;
+            continue;
+        }
+        if (entry.type !== 'response_item' || payload.type !== 'message')
+            continue;
+        if (payload.role === 'user') {
+            const text = blocksText(payload.content, 'input_text');
+            if (text === '')
+                continue;
+            turns.push({ role: 'user', text, time });
+        }
+        else if (payload.role === 'assistant') {
+            const text = blocksText(payload.content, 'output_text');
+            if (text === '')
+                continue;
+            turns.push({ role: 'assistant', text, model: lastModel, time });
+        }
+    }
+    if (turns.length === 0 || cwd === undefined)
+        return undefined;
+    return { sourceId, cwd, startedAt: startedAt || turns[0].time, turns };
+}
+export const codexAdapter = {
+    id: 'codex',
+    label: 'Codex',
+    roots: () => [join(homedir(), '.codex', 'sessions')],
+    discover() {
+        const roots = this.roots();
+        const sessions = [];
+        const walk = (dir, depth) => {
+            if (depth > 5)
+                return;
+            let entries;
+            try {
+                entries = readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                const path = join(dir, entry.name);
+                if (entry.isDirectory())
+                    walk(path, depth + 1);
+                else if (entry.isFile() && entry.name.startsWith('rollout-') && entry.name.endsWith('.jsonl')) {
+                    try {
+                        if (statSync(path).size > 64 * 1024 * 1024)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    const session = readOne(path);
+                    if (session !== undefined)
+                        sessions.push(session);
+                }
+            }
+        };
+        for (const root of roots)
+            walk(root, 0);
+        return { roots, sessions };
+    },
+    count() {
+        return countEntries(this.roots(), { maxDepth: 5, fileMatch: name => name.startsWith('rollout-') && name.endsWith('.jsonl') });
+    },
+};

package/lib/types/dsh-adapter/migrate/adapters/grok-build.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationAdapter } from '../types.js';
+export declare const grokBuildAdapter: MigrationAdapter;
+//# sourceMappingURL=grok-build.d.ts.map

package/lib/types/dsh-adapter/migrate/adapters/grok-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grok-build.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/grok-build.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,gBAAgB,EAAuD,MAAM,aAAa,CAAA;AAuGxG,eAAO,MAAM,gBAAgB,EAAE,gBAsC9B,CAAA"}

package/lib/types/dsh-adapter/migrate/adapters/grok-build.js

@@ -0,0 +1,175 @@
+/**
+ * grok-build adapter: `~/.grok/sessions/<encoded-cwd>/<uuid>/` — each session
+ * directory holds a `summary.json` (metadata) and a `chat_history.jsonl`
+ * whose rows are tagged `ConversationItem`s: `user` rows carry block-array
+ * content, `assistant` rows plain strings, and a `reasoning` row precedes
+ * the assistant turn it belongs to. Rows carry no per-row timestamp, so
+ * turns inherit the summary's clock. The legacy v0 shape (`{role, content}`)
+ * is accepted alongside v1.
+ *
+ * @module dsh-cli/migrate/adapters/grok-build
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { countEntries } from './scan.js';
+function blocksText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const part of content) {
+        if (part !== null && typeof part === 'object' && part.type === 'text' && typeof part.text === 'string' && part.text !== '') {
+            parts.push(part.text);
+        }
+    }
+    return parts.join('\n\n');
+}
+function reasoningText(row) {
+    const summary = row.summary;
+    if (!Array.isArray(summary))
+        return '';
+    const parts = [];
+    for (const part of summary) {
+        if (part !== null && typeof part === 'object' && typeof part.text === 'string' && part.text !== '')
+            parts.push(part.text);
+    }
+    return parts.join('\n\n');
+}
+function toMillis(iso) {
+    return typeof iso === 'string' ? Date.parse(iso) || 0 : 0;
+}
+function readOne(dir) {
+    let rawSummary;
+    let rawLines;
+    try {
+        rawSummary = readFileSync(join(dir, 'summary.json'), 'utf8');
+        rawLines = readFileSync(join(dir, 'chat_history.jsonl'), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    let summaryDoc;
+    try {
+        summaryDoc = JSON.parse(rawSummary);
+    }
+    catch {
+        return undefined;
+    }
+    // A legal `null` (or scalar) summary is not a session; member access on it
+    // would throw and kill the whole scan.
+    if (!summaryDoc || typeof summaryDoc !== 'object')
+        return undefined;
+    const summary = summaryDoc;
+    // !x also rejects JSON null (typeof null === 'object').
+    if (!summary.info || typeof summary.info !== 'object')
+        return undefined;
+    const info = summary.info;
+    if (typeof info.id !== 'string' || info.id === '')
+        return undefined;
+    if (typeof info.cwd !== 'string' || info.cwd === '')
+        return undefined;
+    const startedAt = toMillis(summary.created_at) || toMillis(summary.updated_at);
+    const generatedTitle = summary.generated_title;
+    const fallbackTitle = summary.session_summary;
+    const title = typeof generatedTitle === 'string' && generatedTitle !== ''
+        ? generatedTitle
+        : typeof fallbackTitle === 'string' && fallbackTitle !== '' ? fallbackTitle : undefined;
+    const turns = [];
+    let pendingReasoning;
+    for (const line of rawLines.split('\n')) {
+        if (line === '')
+            continue;
+        let row;
+        try {
+            row = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!row || typeof row !== 'object')
+            continue;
+        const role = row.type === undefined ? row.role : row.type;
+        if (role === 'user') {
+            // Tagged synthetic injections (system reminders, compaction meta, …)
+            // are not the human's words; the default `human` tag is omitted.
+            const reason = row.synthetic_reason;
+            if (reason !== undefined && reason !== 'human')
+                continue;
+            const text = blocksText(row.content);
+            if (text === '')
+                continue;
+            turns.push({ role: 'user', text, time: startedAt });
+        }
+        else if (role === 'assistant') {
+            const text = blocksText(row.content);
+            if (text === '' && pendingReasoning === undefined)
+                continue;
+            const model = row.model_id;
+            turns.push({
+                role: 'assistant',
+                text,
+                reasoning: pendingReasoning,
+                model: typeof model === 'string' && model !== '' ? model : undefined,
+                time: startedAt,
+            });
+            pendingReasoning = undefined;
+        }
+        else if (role === 'reasoning') {
+            // A reasoning row is the pre-sibling of the assistant turn it explains.
+            const text = reasoningText(row);
+            if (text !== '')
+                pendingReasoning = pendingReasoning === undefined ? text : `${pendingReasoning}\n\n${text}`;
+        }
+    }
+    if (turns.length === 0)
+        return undefined;
+    return { sourceId: info.id, cwd: info.cwd, title, startedAt: startedAt || turns[0].time, turns };
+}
+export const grokBuildAdapter = {
+    id: 'grok-build',
+    label: 'Grok Build',
+    roots() {
+        const grokHome = process.env.GROK_HOME?.trim();
+        return [join(grokHome !== undefined && grokHome !== '' ? grokHome : join(homedir(), '.grok'), 'sessions')];
+    },
+    discover() {
+        const roots = this.roots();
+        const sessions = [];
+        const walk = (dir, depth) => {
+            if (depth > 2)
+                return;
+            let entries;
+            try {
+                entries = readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                const path = join(dir, entry.name);
+                if (entry.isDirectory())
+                    walk(path, depth + 1);
+                else if (entry.isFile() && entry.name === 'chat_history.jsonl') {
+                    try {
+                        if (statSync(path).size > 64 * 1024 * 1024)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    const session = readOne(dir);
+                    if (session !== undefined)
+                        sessions.push(session);
+                }
+            }
+        };
+        for (const root of roots)
+            walk(root, 0);
+        return { roots, sessions };
+    },
+    count() {
+        return countEntries(this.roots(), { maxDepth: 2, fileMatch: name => name === 'chat_history.jsonl' });
+    },
+};

package/lib/types/dsh-adapter/migrate/adapters/omp.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationAdapter } from '../types.js';
+export declare const ompAdapter: MigrationAdapter;
+//# sourceMappingURL=omp.d.ts.map

package/lib/types/dsh-adapter/migrate/adapters/omp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omp.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/omp.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,gBAAgB,EAAuD,MAAM,aAAa,CAAA;AAwExG,eAAO,MAAM,UAAU,EAAE,gBAmCxB,CAAA"}

package/lib/types/dsh-adapter/migrate/adapters/omp.js

@@ -0,0 +1,132 @@
+/**
+ * OMP adapter: `~/.omp/agent/sessions/--<munged-cwd>--/<timestamp>_<id>.jsonl`.
+ * OMP shares the DSH lineage: a `session` header line plus `message` lines
+ * whose `message.content` block shape is identical to ours, so this adapter
+ * is a near-direct mapping.
+ *
+ * @module dsh-cli/migrate/adapters/omp
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { countEntries } from './scan.js';
+function blocksText(content, want) {
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (block !== null && typeof block === 'object' && want.includes(block.type) && typeof block.text === 'string' && block.text !== '') {
+            parts.push(block.text);
+        }
+    }
+    return parts.join('\n\n');
+}
+function toMillis(iso) {
+    return typeof iso === 'string' ? Date.parse(iso) || 0 : 0;
+}
+function readOne(path) {
+    let lines;
+    try {
+        lines = readFileSync(path, 'utf8').split('\n');
+    }
+    catch {
+        return undefined;
+    }
+    // basename(): join() is `\`-separated on Windows, where split('/') returned
+    // the whole path and the fallback id stopped being stable across moves.
+    const file = basename(path);
+    const nameMatch = /^[\dT:.Z-]*_([0-9a-zA-Z-]+)\.jsonl$/u.exec(file);
+    const sourceId = nameMatch?.[1] ?? file;
+    let cwd;
+    let startedAt = 0;
+    let title;
+    const turns = [];
+    for (const line of lines) {
+        if (line === '')
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        // A legal `null` (or scalar) line is not a record; reading .type on it
+        // would throw and kill the whole scan (codex adversarial review).
+        if (entry === null || typeof entry !== 'object')
+            continue;
+        const time = toMillis(entry.timestamp);
+        if (entry.type === 'session' || entry.type === 'title') {
+            if (typeof entry.cwd === 'string' && entry.cwd !== '')
+                cwd = entry.cwd;
+            if (typeof entry.title === 'string' && entry.title !== '')
+                title = entry.title;
+            startedAt = startedAt || toMillis(entry.timestamp);
+            continue;
+        }
+        if (entry.type !== 'message')
+            continue;
+        const message = entry.message;
+        if (!message || typeof message !== 'object')
+            continue; // !x also rejects JSON null (typeof null === 'object')
+        if (message.role === 'user') {
+            const text = blocksText(message.content, ['text']);
+            if (text === '')
+                continue;
+            turns.push({ role: 'user', text, time });
+        }
+        else if (message.role === 'assistant') {
+            const text = blocksText(message.content, ['text']);
+            const reasoning = blocksText(message.content, ['reasoning', 'thinking']);
+            if (text === '' && reasoning === '')
+                continue;
+            turns.push({ role: 'assistant', text, reasoning: reasoning === '' ? undefined : reasoning, time });
+        }
+    }
+    if (turns.length === 0 || cwd === undefined)
+        return undefined;
+    return { sourceId, cwd, title, startedAt: startedAt || turns[0].time, turns };
+}
+export const ompAdapter = {
+    id: 'omp',
+    label: 'OMP',
+    roots: () => [join(homedir(), '.omp', 'agent', 'sessions')],
+    discover() {
+        const roots = this.roots();
+        const sessions = [];
+        const walk = (dir, depth) => {
+            if (depth > 3)
+                return;
+            let entries;
+            try {
+                entries = readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                const path = join(dir, entry.name);
+                if (entry.isDirectory())
+                    walk(path, depth + 1);
+                else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+                    try {
+                        if (statSync(path).size > 64 * 1024 * 1024)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    const session = readOne(path);
+                    if (session !== undefined)
+                        sessions.push(session);
+                }
+            }
+        };
+        for (const root of roots)
+            walk(root, 0);
+        return { roots, sessions };
+    },
+    count() {
+        return countEntries(this.roots(), { maxDepth: 3, fileMatch: name => name.endsWith('.jsonl') });
+    },
+};

package/lib/types/dsh-adapter/migrate/adapters/scan.d.ts

@@ -0,0 +1,6 @@
+/** Walk-mode file/directory counter shared by every adapter's fast count. */
+export declare function countEntries(roots: readonly string[], options: {
+    readonly maxDepth: number;
+    readonly fileMatch: (name: string) => boolean;
+}): number;
+//# sourceMappingURL=scan.d.ts.map

package/lib/types/dsh-adapter/migrate/adapters/scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/scan.ts"],"names":[],"mappings":"AAcA,6EAA6E;AAC7E,wBAAgB,YAAY,CAC1B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,EAAE;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,GACpF,MAAM,CAkBR"}