@deepseek-harness-tui/dsh-tui 0.11.0 → 0.11.2

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

@@ -0,0 +1,133 @@
+/**
+ * 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 @deepseek-harness-tui/dsh-tui/migrate/adapters/omp
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { emptyStats, fromRoleTurns } from '../parse/role-turns.js';
+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, titleExplicit: false, startedAt: startedAt || turns[0].time, turns: fromRoleTurns(turns), stats: emptyStats() };
+}
+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-fs.d.ts

@@ -0,0 +1,60 @@
+import type { Fingerprint, ForeignSessionSummary, LoadSkip, ScanEntry, ScanOptions } from '../types.js';
+/** Largest artifact a full load reads (a larger one is reported, not read). */
+export declare const MAX_ARTIFACT_BYTES: number;
+/** Head windows tried in order: most prompts sit in the first few KB, but a
+ *  large preamble (Codex base instructions, Claude snapshots) can push the
+ *  first prompt further. */
+export declare const HEAD_WINDOWS: readonly number[];
+/** One file the walk matched. */
+export interface WalkedFile {
+    readonly path: string;
+    readonly dir: string;
+    readonly name: string;
+}
+export interface WalkOptions {
+    readonly maxDepth: number;
+    readonly match: (name: string) => boolean;
+    /** Directory names never descended into. */
+    readonly skipDirs?: readonly string[];
+    readonly signal?: AbortSignal;
+}
+/** Walk roots breadth-unbounded, depth-bounded; unreadable directories cost themselves only. */
+export declare function walkFiles(roots: readonly string[], options: WalkOptions): AsyncGenerator<WalkedFile>;
+/** mtime + size of one file, or undefined when it vanished. */
+export declare function fingerprintOf(path: string): Promise<Fingerprint | undefined>;
+/**
+ * The first `bytes` of a file as whole lines: a window that ends mid-line
+ * drops the partial line (the cut happens on bytes, before decoding, so no
+ * character is split either).
+ */
+export declare function readHead(path: string, bytes: number): Promise<string>;
+/** The last `bytes` of a file as whole lines (the partial first line is dropped). */
+export declare function readTail(path: string, bytes: number, size: number): Promise<string>;
+/**
+ * Read growing head windows until `accept` finds what it needs (or the whole
+ * file has been seen).
+ * @returns The first accepted result, or the result for the largest window.
+ */
+export declare function withHead<T>(path: string, size: number, accept: (head: string, whole: boolean) => T | undefined): Promise<T | undefined>;
+/** Whole text of an artifact for a full load, or the reason it cannot be read. */
+export declare function loadText(path: string): Promise<string | LoadSkip>;
+/** One candidate artifact of a scan. */
+export interface ScanCandidate {
+    readonly ref: string;
+    readonly fp: Fingerprint;
+}
+/**
+ * The shared scan loop: fingerprint every artifact the walk finds, reuse the
+ * cached result for an unchanged one, summarize the rest, and report
+ * conversations as they are found.
+ *
+ * Per-artifact work runs in a bounded pool: a stat or a head read is IO-bound,
+ * and doing them one after another made a scan's wall time the sum of
+ * thousands of round trips. Entries therefore arrive unordered.
+ * @param files - The walk.
+ * @param refOf - Locator of the artifact a walked file belongs to (the file
+ *   itself, or its session directory); duplicates are scanned once.
+ * @param fingerprint - mtime + size of an artifact, undefined when it vanished.
+ */
+export declare function runScan(files: AsyncIterable<WalkedFile>, refOf: (file: WalkedFile) => string, fingerprint: (ref: string) => Promise<Fingerprint | undefined>, options: ScanOptions | undefined, summarize: (candidate: ScanCandidate) => Promise<ForeignSessionSummary | null>): Promise<ScanEntry[]>;
+//# sourceMappingURL=scan-fs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scan-fs.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/scan-fs.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAEvG,+EAA+E;AAC/E,eAAO,MAAM,kBAAkB,QAAmB,CAAA;AAElD;;4BAE4B;AAC5B,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAA4B,CAAA;AAOtE,iCAAiC;AACjC,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;IACzC,4CAA4C;IAC5C,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAC9B;AAED,gGAAgG;AAChG,wBAAuB,SAAS,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,OAAO,EAAE,WAAW,GAAG,cAAc,CAAC,UAAU,CAAC,CAwB3G;AAED,+DAA+D;AAC/D,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAOlF;AAED;;;;GAIG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAW3E;AAED,qFAAqF;AACrF,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAWzF;AAED;;;;GAIG;AACH,wBAAsB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,CAAC,GAAG,SAAS,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAO7I;AAED,kFAAkF;AAClF,wBAAsB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,QAAQ,CAAC,CASvE;AAED,wCAAwC;AACxC,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAA;CACzB;AAKD;;;;;;;;;;;;GAYG;AACH,wBAAsB,OAAO,CAC3B,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,EAChC,KAAK,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,MAAM,EACnC,WAAW,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,EAC9D,OAAO,EAAE,WAAW,GAAG,SAAS,EAChC,SAAS,EAAE,CAAC,SAAS,EAAE,aAAa,KAAK,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,GAC7E,OAAO,CAAC,SAAS,EAAE,CAAC,CAgCtB"}

package/lib/types/dsh-adapter/migrate/adapters/scan-fs.js

@@ -0,0 +1,178 @@
+/**
+ * Asynchronous file IO shared by the adapters' summary scans.
+ *
+ * A browse scan runs while the session screen is on screen, so it never
+ * blocks the render loop: directory walks use `fs/promises` and yield to the
+ * event loop every few entries, artifacts are read by bounded head/tail
+ * windows instead of whole, and an unchanged artifact (same mtime and size)
+ * is not read at all when the caller already has its summary.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/adapters/scan-fs
+ */
+import { open, readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+/** Largest artifact a full load reads (a larger one is reported, not read). */
+export const MAX_ARTIFACT_BYTES = 64 * 1024 * 1024;
+/** Head windows tried in order: most prompts sit in the first few KB, but a
+ *  large preamble (Codex base instructions, Claude snapshots) can push the
+ *  first prompt further. */
+export const HEAD_WINDOWS = [32 * 1024, 256 * 1024];
+/** Entries handled between two event-loop yields. */
+const YIELD_EVERY = 32;
+const yieldToLoop = () => new Promise(resolve => setImmediate(resolve));
+/** Walk roots breadth-unbounded, depth-bounded; unreadable directories cost themselves only. */
+export async function* walkFiles(roots, options) {
+    let handled = 0;
+    const walk = async function* (dir, depth) {
+        if (depth > options.maxDepth)
+            return;
+        options.signal?.throwIfAborted();
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (++handled % YIELD_EVERY === 0) {
+                await yieldToLoop();
+                options.signal?.throwIfAborted();
+            }
+            if (entry.isDirectory()) {
+                if (options.skipDirs?.includes(entry.name) !== true)
+                    yield* walk(join(dir, entry.name), depth + 1);
+            }
+            else if (entry.isFile() && options.match(entry.name)) {
+                yield { path: join(dir, entry.name), dir, name: entry.name };
+            }
+        }
+    };
+    for (const root of roots)
+        yield* walk(root, 0);
+}
+/** mtime + size of one file, or undefined when it vanished. */
+export async function fingerprintOf(path) {
+    try {
+        const info = await stat(path);
+        return { mtimeMs: info.mtimeMs, size: info.size };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The first `bytes` of a file as whole lines: a window that ends mid-line
+ * drops the partial line (the cut happens on bytes, before decoding, so no
+ * character is split either).
+ */
+export async function readHead(path, bytes) {
+    const handle = await open(path, 'r');
+    try {
+        const buffer = Buffer.alloc(bytes);
+        const { bytesRead } = await handle.read(buffer, 0, bytes, 0);
+        if (bytesRead < bytes)
+            return buffer.subarray(0, bytesRead).toString('utf8');
+        const lastNewline = buffer.lastIndexOf(0x0a);
+        return buffer.subarray(0, lastNewline === -1 ? 0 : lastNewline + 1).toString('utf8');
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** The last `bytes` of a file as whole lines (the partial first line is dropped). */
+export async function readTail(path, bytes, size) {
+    if (size <= bytes)
+        return readFile(path, 'utf8');
+    const handle = await open(path, 'r');
+    try {
+        const buffer = Buffer.alloc(bytes);
+        const { bytesRead } = await handle.read(buffer, 0, bytes, size - bytes);
+        const firstNewline = buffer.indexOf(0x0a);
+        return firstNewline === -1 ? '' : buffer.subarray(firstNewline + 1, bytesRead).toString('utf8');
+    }
+    finally {
+        await handle.close();
+    }
+}
+/**
+ * Read growing head windows until `accept` finds what it needs (or the whole
+ * file has been seen).
+ * @returns The first accepted result, or the result for the largest window.
+ */
+export async function withHead(path, size, accept) {
+    for (const window of HEAD_WINDOWS) {
+        const whole = size <= window;
+        const result = accept(whole ? await readFile(path, 'utf8') : await readHead(path, window), whole);
+        if (result !== undefined || whole)
+            return result;
+    }
+    return undefined;
+}
+/** Whole text of an artifact for a full load, or the reason it cannot be read. */
+export async function loadText(path) {
+    const fp = await fingerprintOf(path);
+    if (fp === undefined)
+        return { skip: 'missing' };
+    if (fp.size > MAX_ARTIFACT_BYTES)
+        return { skip: 'too-large' };
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return { skip: 'missing' };
+    }
+}
+/** Artifacts stat-ed and summarized at once during a scan. */
+const SCAN_CONCURRENCY = 16;
+/**
+ * The shared scan loop: fingerprint every artifact the walk finds, reuse the
+ * cached result for an unchanged one, summarize the rest, and report
+ * conversations as they are found.
+ *
+ * Per-artifact work runs in a bounded pool: a stat or a head read is IO-bound,
+ * and doing them one after another made a scan's wall time the sum of
+ * thousands of round trips. Entries therefore arrive unordered.
+ * @param files - The walk.
+ * @param refOf - Locator of the artifact a walked file belongs to (the file
+ *   itself, or its session directory); duplicates are scanned once.
+ * @param fingerprint - mtime + size of an artifact, undefined when it vanished.
+ */
+export async function runScan(files, refOf, fingerprint, options, summarize) {
+    const entries = [];
+    const seen = new Set();
+    const running = new Set();
+    const scanOne = async (ref) => {
+        const fp = await fingerprint(ref);
+        if (fp === undefined)
+            return;
+        let summary = options?.cached?.(ref, fp);
+        if (summary === undefined) {
+            try {
+                summary = await summarize({ ref, fp });
+            }
+            catch {
+                // An artifact that vanished or cannot be read mid-scan is skipped
+                // this pass; it is retried on the next one (nothing is cached).
+                return;
+            }
+        }
+        entries.push({ ref, fp, summary });
+        if (summary !== null)
+            options?.onEntry?.(summary);
+    };
+    for await (const file of files) {
+        options?.signal?.throwIfAborted();
+        const ref = refOf(file);
+        if (seen.has(ref))
+            continue;
+        seen.add(ref);
+        const task = scanOne(ref).finally(() => running.delete(task));
+        running.add(task);
+        if (running.size >= SCAN_CONCURRENCY)
+            await Promise.race(running);
+    }
+    await Promise.all(running);
+    options?.signal?.throwIfAborted();
+    return entries;
+}

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

@@ -0,0 +1,8 @@
+/** 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;
+    /** Directory names never descended into. */
+    readonly skipDirs?: readonly string[];
+}): 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;IACP,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;IAC7C,4CAA4C;IAC5C,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACtC,GACA,MAAM,CAmBR"}

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

@@ -0,0 +1,40 @@
+/**
+ * Shared lightweight counting for the migration adapters.
+ *
+ * Bare `dsh-tui migrate` (and the TUI's `/migrate`) only prints a per-agent
+ * count, but discover() parses EVERY file into memory (real-world scale:
+ * ~9600 files / 5.5GB → 49s and ~880MB just to print five numbers —
+ * deep-review M3). countSessions() walks the same trees matching only
+ * directory-entry NAMES: no file is opened, no line is parsed.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/adapters/scan
+ */
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+/** Walk-mode file/directory counter shared by every adapter's fast count. */
+export function countEntries(roots, options) {
+    let count = 0;
+    const walk = (dir, depth) => {
+        if (depth > options.maxDepth)
+            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()) {
+                if (options.skipDirs?.includes(entry.name) !== true)
+                    walk(path, depth + 1);
+            }
+            else if (entry.isFile() && options.fileMatch(entry.name))
+                count += 1;
+        }
+    };
+    for (const root of roots)
+        walk(root, 0);
+    return count;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"zcode.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/zcode.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAmC,gBAAgB,EAA+D,MAAM,aAAa,CAAA;AA8BjJ,eAAO,MAAM,YAAY,EAAE,gBA6C1B,CAAA"}

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

@@ -0,0 +1,93 @@
+/**
+ * zcode adapter: `~/.zcode/v2/sessions/<dir>/<taskId>.json`, one JSON object
+ * per conversation. Discovery lives here; the document is parsed by the pure
+ * zcode.parse.ts. A JSON document has no usable head, so the browse scan
+ * parses each changed file whole (they are small; unchanged ones are reused
+ * by fingerprint).
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/adapters/zcode
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { countEntries } from './scan.js';
+import { fingerprintOf, loadText, runScan, walkFiles } from './scan-fs.js';
+import { parseZcodeSession } from './zcode.parse.js';
+const WALK = { maxDepth: 3, match: name => name.endsWith('.json') };
+async function summarize({ ref, fp }) {
+    const raw = await loadText(ref);
+    const session = typeof raw === 'string' ? parseZcodeSession(raw) : undefined;
+    if (session === undefined)
+        return null;
+    return {
+        agentId: 'zcode',
+        sessionKey: session.sourceId,
+        ref,
+        title: session.title ?? '',
+        cwd: session.cwd,
+        lastMessageAt: fp.mtimeMs,
+        createdAt: session.startedAt || fp.mtimeMs,
+    };
+}
+function readOne(path) {
+    try {
+        return parseZcodeSession(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+export const zcodeAdapter = {
+    id: 'zcode',
+    label: 'zcode',
+    roots: () => [join(homedir(), '.zcode', 'v2', '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('.json')) {
+                    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: WALK.maxDepth, fileMatch: WALK.match });
+    },
+    walk: WALK,
+    async scan(options) {
+        const files = walkFiles(this.roots(), { ...WALK, signal: options?.signal });
+        return runScan(files, file => file.path, fingerprintOf, options, summarize);
+    },
+    async load(ref) {
+        const raw = await loadText(ref);
+        if (typeof raw !== 'string')
+            return raw;
+        return parseZcodeSession(raw) ?? { skip: 'not-a-session' };
+    },
+};

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

@@ -0,0 +1,9 @@
+import type { MigrationSession } from '../types.js';
+/**
+ * Parse one zcode session document.
+ * @returns The session, or undefined when the document is not a
+ *   `{ meta, messages }` object with a task id and workspace, or holds no
+ *   prompt.
+ */
+export declare function parseZcodeSession(raw: string): MigrationSession | undefined;
+//# sourceMappingURL=zcode.parse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zcode.parse.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/zcode.parse.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAc,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAE/D;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAwD3E"}

package/lib/types/dsh-adapter/migrate/adapters/zcode.parse.js

@@ -0,0 +1,89 @@
+/**
+ * zcode session parsing (pure): one `<taskId>.json` → one
+ * {@link MigrationSession}.
+ *
+ * One JSON object per conversation (`{ meta, messages }`) with plain-string
+ * contents and epoch-millisecond timestamps. Only the text roles are mapped:
+ * no sample of this store with tool traffic or reasoning has been available,
+ * so no such field is guessed at.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/adapters/zcode.parse
+ */
+import { isInjectedText, unwrapUserText } from '../parse/injection.js';
+import { isRecord } from '../parse/jsonl.js';
+import { emptyStats } from '../parse/role-turns.js';
+import { normalizeTitle } from '../parse/title.js';
+import { newStep } from '../parse/tools.js';
+/**
+ * Parse one zcode session document.
+ * @returns The session, or undefined when the document is not a
+ *   `{ meta, messages }` object with a task id and workspace, or holds no
+ *   prompt.
+ */
+export function parseZcodeSession(raw) {
+    let doc;
+    try {
+        doc = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(doc) || !isRecord(doc.meta) || !Array.isArray(doc.messages))
+        return undefined;
+    const { taskId, workspacePath, title, createdAt } = doc.meta;
+    if (typeof taskId !== 'string' || taskId === '')
+        return undefined;
+    if (typeof workspacePath !== 'string' || workspacePath === '')
+        return undefined;
+    const stats = emptyStats();
+    let turns = [];
+    let current;
+    let firstTime = 0;
+    for (const message of doc.messages) {
+        if (!isRecord(message))
+            continue;
+        if (message.role !== 'user' && message.role !== 'assistant')
+            continue;
+        if (typeof message.content !== 'string' || message.content === '')
+            continue;
+        if (firstTime === 0 && typeof message.timestamp === 'number')
+            firstTime = message.timestamp;
+        if (message.role === 'user') {
+            // Shared injection rules: harness blocks open no turn, wrappers keep
+            // only the human words.
+            if (isInjectedText(message.content)) {
+                stats.filtered += 1;
+                continue;
+            }
+            const prompt = unwrapUserText(message.content);
+            if (prompt === '')
+                continue;
+            current = { prompt, steps: [] };
+            turns.push(current);
+            continue;
+        }
+        if (current === undefined) {
+            current = { prompt: '', steps: [] };
+            turns.push(current);
+        }
+        const step = newStep();
+        step.blocks.push({ type: 'text', text: message.content });
+        current.steps.push(step);
+    }
+    turns = turns.filter(turn => turn.prompt !== '' || turn.steps.length > 0);
+    if (turns.length === 0)
+        return undefined;
+    // meta.title is the store's own title (written to the log); the first real
+    // prompt is only a fallback.
+    const ownTitle = normalizeTitle(typeof title === 'string' ? title : undefined);
+    const shownTitle = ownTitle !== '' ? ownTitle : normalizeTitle(turns.find(turn => turn.prompt !== '')?.prompt);
+    return {
+        sourceId: taskId,
+        cwd: workspacePath,
+        ...(shownTitle === '' ? {} : { title: shownTitle }),
+        titleExplicit: ownTitle !== '',
+        startedAt: typeof createdAt === 'number' ? createdAt : firstTime,
+        turns,
+        stats,
+    };
+}

package/lib/types/dsh-adapter/migrate/bin-path.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolve `bin/dsh-tui.js` for the package that contains `fromDir`, or
+ * undefined when no ancestor within the probe bound carries it.
+ */
+export declare function resolveOwnBin(fromDir: string): string | undefined;
+//# sourceMappingURL=bin-path.d.ts.map

package/lib/types/dsh-adapter/migrate/bin-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin-path.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/migrate/bin-path.ts"],"names":[],"mappings":"AAoBA;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAMjE"}