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

package/lib/types/dsh-adapter/migrate/index.js

@@ -0,0 +1,107 @@
+/**
+ * Cross-agent conversation migration: orchestration over the official
+ * persistence backend.
+ *
+ * Discovery is read-only against foreign stores (adapters never write their
+ * source). Import goes EXCLUSIVELY through `JsonlSessionPersistence` — the
+ * same plugin the retired-store migration (scripts/migrate-sessions-to-jsonl.mts)
+ * writes through — so physical encoding, `projectKey`/directory layout, zstd
+ * frames, atomic writes and Windows path handling are upstream's, not ours.
+ * Re-importing the same source conversation deterministically lands on the
+ * same session id and is skipped when already present: repeats neither stack
+ * duplicates nor rewrite existing logs.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate
+ */
+import { Context } from '@deepseek-ai/cordis';
+import JsonlSessionPersistence from '@deepseek-ai/dsh-session-persistence-jsonl';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { claudeCodeAdapter } from './adapters/claude-code.js';
+import { codexAdapter } from './adapters/codex.js';
+import { ompAdapter } from './adapters/omp.js';
+import { grokBuildAdapter } from './adapters/grok-build.js';
+import { zcodeAdapter } from './adapters/zcode.js';
+import { foreignSessionId, writeImportedSession } from './import-one.js';
+export const MIGRATION_ADAPTERS = [
+    claudeCodeAdapter,
+    codexAdapter,
+    ompAdapter,
+    zcodeAdapter,
+    grokBuildAdapter,
+];
+/**
+ * The default import target: the shared DSH session store, resolved exactly
+ * like the persistence backend's root (cordis.patch.yml): an explicit
+ * `DSH_TUI_SESSION_ROOT` first, then `$DSH_HOME/sessions`, then
+ * `~/.dsh/sessions`. Resolving it any other way would let the CLI import into
+ * a store the TUI (and the source tabs) never read.
+ */
+export function defaultSessionRoot() {
+    const override = process.env.DSH_TUI_SESSION_ROOT?.trim();
+    if (override)
+        return override;
+    const dshHome = process.env.DSH_HOME?.trim();
+    return join(dshHome ? dshHome : join(homedir(), '.dsh'), 'sessions');
+}
+/** Deterministic session id for one foreign conversation. */
+export function migrationSessionId(adapter, session) {
+    return foreignSessionId(adapter.id, session.sourceId);
+}
+/** Wait until the plugin's service is published on the context. */
+async function awaitPersistence(ctx) {
+    for (let i = 0; i < 200; i++) {
+        const service = ctx.get('sessionPersistence');
+        if (service !== undefined)
+            return service;
+        await new Promise(resolve => setTimeout(resolve, 25));
+    }
+    throw new Error('session persistence service did not become ready');
+}
+/**
+ * Import every discovered conversation of one adapter into the DSH store.
+ *
+ * The persistence backend is mounted ONCE per run (one Context, one plugin
+ * lifecycle) and disposed after the loop; sessions already present (same
+ * deterministic id) are skipped, and a failed conversation never aborts the
+ * batch — both properties the retired-store migration established first.
+ *
+ * @param adapter - the foreign agent to import from.
+ * @param root - the DSH session root to write into.
+ * @param sessions - the conversations to import (usually adapter.discover()).
+ * @returns the per-run counters.
+ */
+export async function importSessions(adapter, root, sessions) {
+    const ctx = new Context();
+    const fiber = ctx.plugin(JsonlSessionPersistence, { root });
+    let imported = 0;
+    let existing = 0;
+    let failed = 0;
+    const failures = [];
+    try {
+        const persistence = await awaitPersistence(ctx);
+        const present = new Set((await persistence.list()).map(entry => entry.header.id));
+        for (const session of sessions) {
+            const id = migrationSessionId(adapter, session);
+            if (present.has(id)) {
+                existing += 1;
+                continue;
+            }
+            try {
+                await writeImportedSession(persistence, id, adapter.id, session);
+                present.add(id);
+                imported += 1;
+            }
+            catch (error) {
+                failed += 1;
+                failures.push(`${session.sourceId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    finally {
+        // The mounted plugin fiber owns the backend's file handles; dispose it
+        // so a CLI process with nothing left to do can exit promptly.
+        await Promise.resolve(fiber.dispose()).catch(() => { });
+    }
+    return { imported, existing, failed, failures };
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Harness-injection recognition and user-text unwrapping.
+ *
+ * Every foreign agent writes machine text into its user role: environment
+ * blocks, instruction files, reminders, slash-command echoes. None of it is
+ * the human's words, so it must never open a turn or become a title. The
+ * other half is wrappers the harness puts AROUND real words (`<user_query>`,
+ * pasted-content envelopes, interrupt notices): those keep the words and
+ * drop the frame.
+ *
+ * Every scan here is linear: tag bodies are located with indexOf, never a
+ * lazy `[\s\S]*?` regex, whose per-unclosed-tag rescans a hostile single
+ * line can turn quadratic (deep-review m1 on the first claude adapter).
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/injection
+ */
+/**
+ * Line-start markers of injected blocks, matched case-insensitively after
+ * trimming. A user text that STARTS with one of these is harness output.
+ */
+export declare const INJECTED_PREFIXES: readonly string[];
+/** Whether a user text is harness injection rather than the human's words. */
+export declare function isInjectedText(text: string): boolean;
+/** Strip inline `<system-reminder>` blocks (Claude Code puts them anywhere). */
+export declare function stripSystemReminders(text: string): string;
+/** Whether a user text is an interrupt notice (the previous turn was cut short). */
+export declare function isInterruptNotice(text: string): boolean;
+/**
+ * Reduce a user text to the human's own words.
+ *
+ * - `<user_query>` wrappers keep only their bodies — this also covers the
+ *   interrupt / "sent a message while you were working" notices, whose
+ *   human part is always inside a `<user_query>`;
+ * - a notice without a `<user_query>` keeps what follows the notice line;
+ * - pasted-content envelopes lose their tags but keep the pasted text.
+ *
+ * @returns The unwrapped, trimmed text ('' when nothing human remains).
+ */
+export declare function unwrapUserText(text: string): string;
+//# sourceMappingURL=injection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"injection.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/parse/injection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAa9C,CAAA;AAID,8EAA8E;AAC9E,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGpD;AAsBD,gFAAgF;AAChF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGzD;AAyBD,oFAAoF;AACpF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAQD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAYnD"}

package/lib/types/dsh-adapter/migrate/parse/injection.js

@@ -0,0 +1,127 @@
+/**
+ * Harness-injection recognition and user-text unwrapping.
+ *
+ * Every foreign agent writes machine text into its user role: environment
+ * blocks, instruction files, reminders, slash-command echoes. None of it is
+ * the human's words, so it must never open a turn or become a title. The
+ * other half is wrappers the harness puts AROUND real words (`<user_query>`,
+ * pasted-content envelopes, interrupt notices): those keep the words and
+ * drop the frame.
+ *
+ * Every scan here is linear: tag bodies are located with indexOf, never a
+ * lazy `[\s\S]*?` regex, whose per-unclosed-tag rescans a hostile single
+ * line can turn quadratic (deep-review m1 on the first claude adapter).
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/injection
+ */
+/**
+ * Line-start markers of injected blocks, matched case-insensitively after
+ * trimming. A user text that STARTS with one of these is harness output.
+ */
+export const INJECTED_PREFIXES = [
+    '<environment_context>',
+    '<system-reminder>',
+    '<user_instructions>',
+    '<local-command-caveat>',
+    '<local-command-stdout>',
+    '<command-name>',
+    '<command-message>',
+    '<task-notification>',
+    '<permissions>',
+    '<user_info>',
+    '# AGENTS.md instructions',
+    '# Context from my IDE setup:',
+];
+const LOWER_PREFIXES = INJECTED_PREFIXES.map(prefix => prefix.toLowerCase());
+/** Whether a user text is harness injection rather than the human's words. */
+export function isInjectedText(text) {
+    const head = text.trimStart().slice(0, 64).toLowerCase();
+    return LOWER_PREFIXES.some(prefix => head.startsWith(prefix));
+}
+/**
+ * Remove every `<tag>…</tag>` span. An opening tag with no closing tag
+ * swallows the rest of the text (the block was cut off, nothing after it is
+ * the user's).
+ */
+function removeTagSpans(text, tag) {
+    const open = `<${tag}>`;
+    const close = `</${tag}>`;
+    let out = '';
+    let from = 0;
+    for (;;) {
+        const start = text.indexOf(open, from);
+        if (start === -1)
+            return out + text.slice(from);
+        out += text.slice(from, start);
+        const end = text.indexOf(close, start + open.length);
+        if (end === -1)
+            return out;
+        from = end + close.length;
+    }
+}
+/** Strip inline `<system-reminder>` blocks (Claude Code puts them anywhere). */
+export function stripSystemReminders(text) {
+    if (!text.includes('<system-reminder>'))
+        return text.trim();
+    return removeTagSpans(text, 'system-reminder').trim();
+}
+/** Bodies of every `<user_query>` block; an unclosed tag runs to the end. */
+function userQueryBodies(text) {
+    const open = '<user_query>';
+    const close = '</user_query>';
+    const bodies = [];
+    let from = 0;
+    for (;;) {
+        const start = text.indexOf(open, from);
+        if (start === -1)
+            return bodies;
+        const bodyStart = start + open.length;
+        const end = text.indexOf(close, bodyStart);
+        bodies.push(text.slice(bodyStart, end === -1 ? undefined : end).trim());
+        if (end === -1)
+            return bodies;
+        from = end + close.length;
+    }
+}
+/** Notices a harness prepends when the user speaks over a running turn. */
+const INTERJECTION_PREFIXES = [
+    'The user interrupted the previous turn:',
+    'The user sent a message while you were working:',
+];
+/** Whether a user text is an interrupt notice (the previous turn was cut short). */
+export function isInterruptNotice(text) {
+    return text.trimStart().startsWith(INTERJECTION_PREFIXES[0]);
+}
+/** Drop `<pasted_content …>` / `</pasted_content …>` tags, keeping the pasted body. */
+function stripPastedTags(text) {
+    if (!text.includes('pasted_content'))
+        return text;
+    return text.replace(/<\/?pasted_content(?:\s[^<>]*)?>/gu, ' ').replace(/[ \t]{2,}/gu, ' ');
+}
+/**
+ * Reduce a user text to the human's own words.
+ *
+ * - `<user_query>` wrappers keep only their bodies — this also covers the
+ *   interrupt / "sent a message while you were working" notices, whose
+ *   human part is always inside a `<user_query>`;
+ * - a notice without a `<user_query>` keeps what follows the notice line;
+ * - pasted-content envelopes lose their tags but keep the pasted text.
+ *
+ * @returns The unwrapped, trimmed text ('' when nothing human remains).
+ */
+export function unwrapUserText(text) {
+    const lead = text.trimStart();
+    if (!text.includes('<') && !lead.startsWith('The user '))
+        return text.trim();
+    let body = text;
+    const queries = userQueryBodies(body);
+    if (queries.length > 0) {
+        body = queries.join('\n\n');
+    }
+    else {
+        const notice = INTERJECTION_PREFIXES.find(prefix => lead.startsWith(prefix));
+        if (notice !== undefined)
+            body = lead.slice(notice.length);
+    }
+    return stripPastedTags(body).trim();
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Line-delimited JSON reading shared by every migration source.
+ *
+ * Foreign stores are read defensively: a malformed line costs that line,
+ * never the file. Legal JSON that is not a record (`null`, scalars, arrays)
+ * is skipped silently — it is well-formed, just not a row — while text that
+ * fails to parse is COUNTED, so a truncated or corrupted source shows up in
+ * the import stats instead of vanishing quietly.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/jsonl
+ */
+/** A decoded JSON object row. */
+export type JsonRecord = Record<string, unknown>;
+/** Narrow an unknown JSON value to an object record (rejects `null` and arrays). */
+export declare function isRecord(value: unknown): value is JsonRecord;
+/** Parsed rows of one JSONL document. */
+export interface JsonlRows {
+    readonly records: readonly JsonRecord[];
+    /** Non-empty lines that were not valid JSON. */
+    readonly badLines: number;
+}
+/**
+ * Split and decode a JSONL document.
+ * @param raw - Whole file text; `\n` and `\r\n` line ends are both accepted.
+ * @returns Every object row in file order plus the count of unparseable lines.
+ */
+export declare function parseJsonl(raw: string): JsonlRows;
+//# sourceMappingURL=jsonl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/parse/jsonl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,iCAAiC;AACjC,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEhD,oFAAoF;AACpF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAE5D;AAED,yCAAyC;AACzC,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAA;IACvC,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAgBjD"}

package/lib/types/dsh-adapter/migrate/parse/jsonl.js

@@ -0,0 +1,40 @@
+/**
+ * Line-delimited JSON reading shared by every migration source.
+ *
+ * Foreign stores are read defensively: a malformed line costs that line,
+ * never the file. Legal JSON that is not a record (`null`, scalars, arrays)
+ * is skipped silently — it is well-formed, just not a row — while text that
+ * fails to parse is COUNTED, so a truncated or corrupted source shows up in
+ * the import stats instead of vanishing quietly.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/jsonl
+ */
+/** Narrow an unknown JSON value to an object record (rejects `null` and arrays). */
+export function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Split and decode a JSONL document.
+ * @param raw - Whole file text; `\n` and `\r\n` line ends are both accepted.
+ * @returns Every object row in file order plus the count of unparseable lines.
+ */
+export function parseJsonl(raw) {
+    const records = [];
+    let badLines = 0;
+    for (const line of raw.split('\n')) {
+        const text = line.endsWith('\r') ? line.slice(0, -1) : line;
+        if (text.trim() === '')
+            continue;
+        let value;
+        try {
+            value = JSON.parse(text);
+        }
+        catch {
+            badLines += 1;
+            continue;
+        }
+        if (isRecord(value))
+            records.push(value);
+    }
+    return { records, badLines };
+}

package/lib/types/dsh-adapter/migrate/parse/role-turns.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Flat role list → imported turns, plus the shared size measure.
+ *
+ * The first migration adapters normalized every source into an alternating
+ * user/assistant list. {@link fromRoleTurns} folds that list into the turn
+ * model mechanically — a user message opens a turn, every assistant message
+ * after it is one step — so an adapter that still produces the list imports
+ * exactly as it did before the turn model existed.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/role-turns
+ */
+import type { ImportStats, ImportTurn, MigrationSession, MigrationTurn } from '../types.js';
+/** Counters for a source that reports nothing it left out. */
+export declare function emptyStats(): ImportStats;
+/**
+ * Fold a role list into turns.
+ *
+ * A list that starts with an assistant message opens a turn with no prompt
+ * (the source lost its head); a trailing user message is a step-less turn.
+ */
+export declare function fromRoleTurns(list: readonly MigrationTurn[]): ImportTurn[];
+/**
+ * How many conversation messages an imported session carries: prompts,
+ * mid-turn inputs and assistant steps (tool results are not counted). For a
+ * role-list source this equals the list length.
+ */
+export declare function messageCount(session: Pick<MigrationSession, 'turns'>): number;
+//# sourceMappingURL=role-turns.d.ts.map

package/lib/types/dsh-adapter/migrate/parse/role-turns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role-turns.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/parse/role-turns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAe,WAAW,EAAE,UAAU,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAGxG,8DAA8D;AAC9D,wBAAgB,UAAU,IAAI,WAAW,CAExC;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,aAAa,EAAE,GAAG,UAAU,EAAE,CAqB1E;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,gBAAgB,EAAE,OAAO,CAAC,GAAG,MAAM,CAO7E"}

package/lib/types/dsh-adapter/migrate/parse/role-turns.js

@@ -0,0 +1,50 @@
+import { newStep } from './tools.js';
+/** Counters for a source that reports nothing it left out. */
+export function emptyStats() {
+    return { badLines: 0, droppedToolResults: 0, filtered: 0, meta: 0 };
+}
+/**
+ * Fold a role list into turns.
+ *
+ * A list that starts with an assistant message opens a turn with no prompt
+ * (the source lost its head); a trailing user message is a step-less turn.
+ */
+export function fromRoleTurns(list) {
+    const turns = [];
+    let current;
+    for (const message of list) {
+        if (message.role === 'user') {
+            current = { prompt: message.text, steps: [] };
+            turns.push(current);
+            continue;
+        }
+        if (current === undefined) {
+            current = { prompt: '', steps: [] };
+            turns.push(current);
+        }
+        const step = newStep(message.model);
+        const blocks = [];
+        if (message.reasoning !== undefined && message.reasoning !== '')
+            blocks.push({ type: 'reasoning', text: message.reasoning });
+        if (message.text !== '')
+            blocks.push({ type: 'text', text: message.text });
+        step.blocks = blocks;
+        current.steps.push(step);
+    }
+    return turns;
+}
+/**
+ * How many conversation messages an imported session carries: prompts,
+ * mid-turn inputs and assistant steps (tool results are not counted). For a
+ * role-list source this equals the list length.
+ */
+export function messageCount(session) {
+    let count = 0;
+    for (const turn of session.turns) {
+        if (turn.prompt !== '')
+            count += 1;
+        for (const step of turn.steps)
+            count += 1 + step.inputs.length;
+    }
+    return count;
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Title normalization shared by every migration source.
+ *
+ * One rule for all sources, so the same conversation shows the same title
+ * whichever entry imported it: trim, collapse inner whitespace (a title is
+ * one line), cap at {@link TITLE_MAX_CHARS} code points with a trailing `…`.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/title
+ */
+/** Longest normalized title, in code points (the ellipsis included). */
+export declare const TITLE_MAX_CHARS = 80;
+/**
+ * Normalize a candidate title.
+ * @param text - Raw title or first prompt.
+ * @returns The one-line title, or '' when the input is blank.
+ */
+export declare function normalizeTitle(text: string | undefined): string;
+//# sourceMappingURL=title.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"title.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/parse/title.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,wEAAwE;AACxE,eAAO,MAAM,eAAe,KAAK,CAAA;AAIjC;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAQ/D"}

package/lib/types/dsh-adapter/migrate/parse/title.js

@@ -0,0 +1,29 @@
+/**
+ * Title normalization shared by every migration source.
+ *
+ * One rule for all sources, so the same conversation shows the same title
+ * whichever entry imported it: trim, collapse inner whitespace (a title is
+ * one line), cap at {@link TITLE_MAX_CHARS} code points with a trailing `…`.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/title
+ */
+/** Longest normalized title, in code points (the ellipsis included). */
+export const TITLE_MAX_CHARS = 80;
+const ELLIPSIS = '…';
+/**
+ * Normalize a candidate title.
+ * @param text - Raw title or first prompt.
+ * @returns The one-line title, or '' when the input is blank.
+ */
+export function normalizeTitle(text) {
+    if (text === undefined)
+        return '';
+    const flat = text.trim().replace(/\s+/gu, ' ');
+    if (flat === '')
+        return '';
+    // Code points, not UTF-16 units: a cut must never split a surrogate pair.
+    const points = Array.from(flat);
+    if (points.length <= TITLE_MAX_CHARS)
+        return flat;
+    return `${points.slice(0, TITLE_MAX_CHARS - ELLIPSIS.length).join('').trimEnd()}${ELLIPSIS}`;
+}

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

@@ -0,0 +1,62 @@
+/**
+ * Tool-call pairing for imported conversations.
+ *
+ * The one hard rule for replaying tool traffic is wire legality: every tool
+ * call is answered by exactly one tool message before any later assistant
+ * message, and every tool message answers a call. Sources do not guarantee
+ * that — results arrive steps after their call (Claude batches them behind
+ * consecutive assistant rows), transcripts start mid-conversation, runs are
+ * interrupted before a result lands. This module restores the rule:
+ *
+ * - {@link CallIndex} attaches a late result to the STEP that made the call,
+ *   never to whatever step is newest;
+ * - {@link closeToolPairs} orders each step's results by call order, drops
+ *   orphans and duplicates (counted), and answers unanswered calls with an
+ *   empty result.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/tools
+ */
+import type { ImportStep, ImportTurn } from '../types.js';
+/** Largest tool-result text kept per result, in UTF-8 bytes. */
+export declare const TOOL_RESULT_MAX_BYTES: number;
+/** Placeholder written instead of image bytes (never base64 into the log). */
+export declare const IMAGE_PLACEHOLDER = "[image]";
+/** A fresh empty step. */
+export declare function newStep(model?: string): ImportStep;
+/**
+ * Clamp a tool-result text to {@link TOOL_RESULT_MAX_BYTES}, cutting on a
+ * character boundary and noting how much was dropped.
+ */
+export declare function clampToolText(text: string): string;
+/**
+ * Session-wide call-id → step index. Register a step's calls when the step
+ * is built; attach results as they arrive, wherever they arrive.
+ */
+export declare class CallIndex {
+    private readonly stepOf;
+    /** Results whose call id was never registered. */
+    orphans: number;
+    /** Index every tool-call block currently in `step`. */
+    register(step: ImportStep): void;
+    /** Whether a call with this id has been registered. */
+    has(callId: string): boolean;
+    /**
+     * Attach one result to the step that made the call.
+     * @returns false (and counts an orphan) when no such call is known.
+     */
+    attach(callId: string, text: string, isError: boolean): boolean;
+}
+/**
+ * Make every step wire-legal, in place.
+ *
+ * Per step: results follow call order; a result for a call not in the step,
+ * or a second result for one call, is dropped; a call without a result gets
+ * an empty one. Across the session, a call id reused by a later step (a
+ * source retry the source-specific cleanup did not collapse) is renamed
+ * `<id>#<n>` together with its result — the session log folds tool calls by
+ * id, and a duplicate id would swallow everything after it.
+ *
+ * @returns How many results were dropped.
+ */
+export declare function closeToolPairs(turns: readonly ImportTurn[]): number;
+//# sourceMappingURL=tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/parse/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEzD,gEAAgE;AAChE,eAAO,MAAM,qBAAqB,QAAY,CAAA;AAE9C,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,YAAY,CAAA;AAE1C,0BAA0B;AAC1B,wBAAgB,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAElD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CASlD;AAED;;;GAGG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD,kDAAkD;IAClD,OAAO,SAAI;IAEX,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAMhC,uDAAuD;IACvD,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAI5B;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;CAShE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,GAAG,MAAM,CAmCnE"}

package/lib/types/dsh-adapter/migrate/parse/tools.js

@@ -0,0 +1,110 @@
+/** Largest tool-result text kept per result, in UTF-8 bytes. */
+export const TOOL_RESULT_MAX_BYTES = 64 * 1024;
+/** Placeholder written instead of image bytes (never base64 into the log). */
+export const IMAGE_PLACEHOLDER = '[image]';
+/** A fresh empty step. */
+export function newStep(model) {
+    return model === undefined ? { inputs: [], blocks: [], results: [] } : { inputs: [], blocks: [], results: [], model };
+}
+/**
+ * Clamp a tool-result text to {@link TOOL_RESULT_MAX_BYTES}, cutting on a
+ * character boundary and noting how much was dropped.
+ */
+export function clampToolText(text) {
+    // Cheap pre-check: UTF-8 needs at most 3 bytes per UTF-16 unit.
+    if (text.length * 3 <= TOOL_RESULT_MAX_BYTES)
+        return text;
+    const bytes = Buffer.from(text, 'utf8');
+    if (bytes.length <= TOOL_RESULT_MAX_BYTES)
+        return text;
+    let end = TOOL_RESULT_MAX_BYTES;
+    // Back off continuation bytes (10xxxxxx) so the cut never splits a character.
+    while (end > 0 && (bytes[end] & 0xc0) === 0x80)
+        end -= 1;
+    return `${bytes.subarray(0, end).toString('utf8')}…[truncated ${bytes.length - end} bytes]`;
+}
+/**
+ * Session-wide call-id → step index. Register a step's calls when the step
+ * is built; attach results as they arrive, wherever they arrive.
+ */
+export class CallIndex {
+    stepOf = new Map();
+    /** Results whose call id was never registered. */
+    orphans = 0;
+    /** Index every tool-call block currently in `step`. */
+    register(step) {
+        for (const block of step.blocks) {
+            if (block.type === 'tool-call')
+                this.stepOf.set(block.id, step);
+        }
+    }
+    /** Whether a call with this id has been registered. */
+    has(callId) {
+        return this.stepOf.has(callId);
+    }
+    /**
+     * Attach one result to the step that made the call.
+     * @returns false (and counts an orphan) when no such call is known.
+     */
+    attach(callId, text, isError) {
+        const step = this.stepOf.get(callId);
+        if (step === undefined) {
+            this.orphans += 1;
+            return false;
+        }
+        step.results.push({ callId, text: clampToolText(text), isError });
+        return true;
+    }
+}
+/**
+ * Make every step wire-legal, in place.
+ *
+ * Per step: results follow call order; a result for a call not in the step,
+ * or a second result for one call, is dropped; a call without a result gets
+ * an empty one. Across the session, a call id reused by a later step (a
+ * source retry the source-specific cleanup did not collapse) is renamed
+ * `<id>#<n>` together with its result — the session log folds tool calls by
+ * id, and a duplicate id would swallow everything after it.
+ *
+ * @returns How many results were dropped.
+ */
+export function closeToolPairs(turns) {
+    let dropped = 0;
+    const seen = new Set();
+    for (const turn of turns) {
+        for (const step of turn.steps) {
+            const renamed = new Map();
+            step.blocks = step.blocks.map(block => {
+                if (block.type !== 'tool-call')
+                    return block;
+                let id = block.id;
+                for (let n = 2; seen.has(id); n += 1)
+                    id = `${block.id}#${n}`;
+                seen.add(id);
+                if (id === block.id)
+                    return block;
+                renamed.set(block.id, id);
+                return { ...block, id };
+            });
+            const byCall = new Map();
+            for (const result of step.results) {
+                const callId = renamed.get(result.callId) ?? result.callId;
+                if (byCall.has(callId)) {
+                    dropped += 1;
+                    continue;
+                }
+                byCall.set(callId, callId === result.callId ? result : { ...result, callId });
+            }
+            const ordered = [];
+            for (const block of step.blocks) {
+                if (block.type !== 'tool-call')
+                    continue;
+                ordered.push(byCall.get(block.id) ?? { callId: block.id, text: '', isError: false });
+                byCall.delete(block.id);
+            }
+            dropped += byCall.size;
+            step.results = ordered;
+        }
+    }
+    return dropped;
+}