@askdkc/dsh-cli 0.11.3

package/lib/types/dsh-adapter/compat/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Compat boundary — every inelegant patch aimed at the harness core lives
+ * here, behind one import seam, so the render/interaction code stays clean.
+ *
+ * House rules for modules in this directory:
+ *  - Each patch carries its own capability probe and self-disables or
+ *    degrades to pre-patch behavior when upstream absorbs the quirk.
+ *  - Optional compatibility patches degrade to pre-patch behavior. Required
+ *    transcript contracts fail loudly rather than fabricating an empty log.
+ *  - A patch states plainly which upstream change would retire it.
+ *
+ * Current residents:
+ *  - liveSession: rc.2 `events`/`seedLength` vs alpha.4
+ *    `snapshotEvents`/`seq`/`isSeeded`/`inheritedEventCount`. Seed copies
+ *    slice the source log; they never use `sessions.fork()` as an extractor.
+ *    A child snapshot length cannot reliably be used as the inherited cut.
+ *  - sessionLog: tolerant title reads plus offline rename/delete helpers for
+ *    persisted sessions that are not currently owned by a live Agent, the
+ *    resume-seam registration of vouched-for legacy event types into every
+ *    reachable KNOWN_SESSION_EVENT_TYPES copy (retiring the day upstream's
+ *    shared catalog adopts the types or ships a real registration API —
+ *    issue #153), and the bounded read-only log reader behind the session
+ *    tree (chunked I/O, lazy zstd frame walk, event + scan budgets,
+ *    inherited-prefix skip).
+ * @module dsh-cli/compat
+ */
+export { appendInterruptedTurnEnd, liveSessionCreateOptions, liveSessionListingFields, liveSessionOffset, sliceLiveSessionSeed, snapshotLiveSessionEvents, } from './liveSession.js';
+export { appendSessionTitle, defaultMaxScanned, deleteSessionLog, ensureLegacySessionEventTypes, findSessionLogFile, LEGACY_SESSION_EVENT_TYPES, readPhysicalHeaderSeedLength, readPhysicalHeaderSeedLengthForSession, readSessionEventsFromFile, readSessionEventsFromLog, readSessionTitleFromLog, type SessionLogRead, sessionsRoots, userTitleData, } from './sessionLog.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/dsh-adapter/compat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/compat/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EACL,wBAAwB,EACxB,wBAAwB,EACxB,wBAAwB,EACxB,iBAAiB,EACjB,oBAAoB,EACpB,yBAAyB,GAC1B,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,6BAA6B,EAC7B,kBAAkB,EAClB,0BAA0B,EAC1B,4BAA4B,EAC5B,sCAAsC,EACtC,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,KAAK,cAAc,EACnB,aAAa,EACb,aAAa,GACd,MAAM,iBAAiB,CAAA"}

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

@@ -0,0 +1,28 @@
+/**
+ * Compat boundary — every inelegant patch aimed at the harness core lives
+ * here, behind one import seam, so the render/interaction code stays clean.
+ *
+ * House rules for modules in this directory:
+ *  - Each patch carries its own capability probe and self-disables or
+ *    degrades to pre-patch behavior when upstream absorbs the quirk.
+ *  - Optional compatibility patches degrade to pre-patch behavior. Required
+ *    transcript contracts fail loudly rather than fabricating an empty log.
+ *  - A patch states plainly which upstream change would retire it.
+ *
+ * Current residents:
+ *  - liveSession: rc.2 `events`/`seedLength` vs alpha.4
+ *    `snapshotEvents`/`seq`/`isSeeded`/`inheritedEventCount`. Seed copies
+ *    slice the source log; they never use `sessions.fork()` as an extractor.
+ *    A child snapshot length cannot reliably be used as the inherited cut.
+ *  - sessionLog: tolerant title reads plus offline rename/delete helpers for
+ *    persisted sessions that are not currently owned by a live Agent, the
+ *    resume-seam registration of vouched-for legacy event types into every
+ *    reachable KNOWN_SESSION_EVENT_TYPES copy (retiring the day upstream's
+ *    shared catalog adopts the types or ships a real registration API —
+ *    issue #153), and the bounded read-only log reader behind the session
+ *    tree (chunked I/O, lazy zstd frame walk, event + scan budgets,
+ *    inherited-prefix skip).
+ * @module dsh-cli/compat
+ */
+export { appendInterruptedTurnEnd, liveSessionCreateOptions, liveSessionListingFields, liveSessionOffset, sliceLiveSessionSeed, snapshotLiveSessionEvents, } from './liveSession.js';
+export { appendSessionTitle, defaultMaxScanned, deleteSessionLog, ensureLegacySessionEventTypes, findSessionLogFile, LEGACY_SESSION_EVENT_TYPES, readPhysicalHeaderSeedLength, readPhysicalHeaderSeedLengthForSession, readSessionEventsFromFile, readSessionEventsFromLog, readSessionTitleFromLog, sessionsRoots, userTitleData, } from './sessionLog.js';

package/lib/types/dsh-adapter/compat/liveSession.d.ts

@@ -0,0 +1,79 @@
+import type { CreateAgentOptions } from '@deepseek-ai/dsh-agent';
+import type { Session, SessionEvent, SessionId } from '@deepseek-ai/dsh-session';
+/**
+ * Snapshot of a live Session log, including any fork-inherited prefix.
+ * Reuses upstream's frozen cache when the log has not appended.
+ * A missing or non-array snapshot is a live Session contract violation.
+ */
+export declare function snapshotLiveSessionEvents(session: unknown): readonly SessionEvent[];
+/**
+ * Exclusive log offset (`seq = log.length`). Empty log is 0, not -1, and this
+ * is not the last event's seq.
+ */
+export declare function liveSessionOffset(session: unknown): number;
+/**
+ * Physical/wire `seedLength` for a live Session: present whenever an exact
+ * copied/inherited prefix is marked as seeded, independently of whether the
+ * header records `parentSession`. Fresh unseeded sessions omit it.
+ * `isSeeded: true` without `inheritedEventCount` is an unknown cut — never
+ * coerced to 0.
+ */
+export declare function liveSessionPhysicalSeedLength(session: unknown): number | undefined;
+/** Listing-shaped fields for overlaying a live Session onto the session tree. */
+export declare function liveSessionListingFields(session: unknown): {
+    readonly id: string | undefined;
+    readonly cwd: string | undefined;
+    readonly createdAt: number | undefined;
+    readonly parentSession: string | undefined;
+    readonly origin: string | undefined;
+    readonly delegationDepth: number | undefined;
+    readonly agentPreset: string | undefined;
+    readonly seedLength: number | undefined;
+};
+/**
+ * Copy of the source log through an inclusive event seq. Omitted boundary
+ * means the whole log and still rejects an open turn. Never calls
+ * `sessions.fork()`.
+ */
+export declare function sliceLiveSessionSeed(session: unknown, boundary?: number): SessionEvent[];
+export interface LiveSessionSeedMetadata {
+    readonly meta: {
+        readonly seedLength?: number;
+        readonly isSeeded?: boolean;
+    };
+    readonly inheritedEventCount?: number;
+}
+/**
+ * Create-time seed ownership fields. Every copied source prefix is inherited
+ * state for domain projections, even when `/fork` deliberately omits
+ * `parentSession` so the copy is presented as an independent root. The exact
+ * cut distinguishes copied history from child-owned events. Not every
+ * projection skips inherited events: newer inbox folds restore pending input
+ * from them, so rewind must cancel that work through the child's Inbox API.
+ * A child snapshot length cannot reliably be used as the cut because
+ * construction may append `session/end-seed`.
+ */
+export declare function liveSessionSeedMetadata(session: unknown, inheritedCount: number): LiveSessionSeedMetadata;
+/** Close an open turn with the `turn/end` shape a real user cancellation writes. */
+export declare function appendInterruptedTurnEnd(seed: SessionEvent[], turn: number): void;
+/** Close a V3 fork's open inherited turn as child-owned events, after its marker. */
+export declare function closeLiveForkTurn(session: Session, turn: number): void;
+export interface LiveSessionCreateRequest {
+    readonly sessionId: SessionId;
+    readonly seed: readonly SessionEvent[];
+    /** Live Session whose shape identifies the active upstream runtime line. */
+    readonly runtimeSession: unknown;
+    readonly inheritedCount: number;
+    readonly cwd: string;
+    readonly parentSession?: SessionId;
+    readonly agentPreset?: string;
+    readonly agentOptions: CreateAgentOptions['agentOptions'];
+    readonly setup?: CreateAgentOptions['setup'];
+}
+/**
+ * Dual-runtime seed metadata for `agents.create`. The only
+ * CreateAgentOptions assertion lives here: rc.2 meta carries `seedLength`,
+ * alpha.4 carries `isSeeded` plus top-level `inheritedEventCount`.
+ */
+export declare function liveSessionCreateOptions(request: LiveSessionCreateRequest): CreateAgentOptions;
+//# sourceMappingURL=liveSession.d.ts.map

package/lib/types/dsh-adapter/compat/liveSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveSession.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/compat/liveSession.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAoChF;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,YAAY,EAAE,CAWnF;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAI1D;AAMD;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAQlF;AAED,iFAAiF;AACjF,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG;IAC1D,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1C,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5C,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IACxC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;CACxC,CAcA;AASD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,YAAY,EAAE,CA4BxF;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE;QACb,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;QAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAC5B,CAAA;IACD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;CACtC;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,MAAM,GACrB,uBAAuB,CAQzB;AAED,oFAAoF;AACpF,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CASjF;AAED,qFAAqF;AACrF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAoBtE;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;IAC7B,QAAQ,CAAC,IAAI,EAAE,SAAS,YAAY,EAAE,CAAA;IACtC,4EAA4E;IAC5E,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAA;IAChC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,CAAA;IAClC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,YAAY,EAAE,kBAAkB,CAAC,cAAc,CAAC,CAAA;IACzD,QAAQ,CAAC,KAAK,CAAC,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAA;CAC7C;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,wBAAwB,GAAG,kBAAkB,CAiB9F"}

package/lib/types/dsh-adapter/compat/liveSession.js

@@ -0,0 +1,223 @@
+/**
+ * Live Session compatibility facade.
+ *
+ * rc.2 / alpha.3 expose `Session.events` and header `seedLength`. alpha.4
+ * deletes `events` in favour of `snapshotEvents` / `eventAt` / exclusive
+ * `seq`, and moves fork lineage from header `seedLength` onto `isSeeded` plus
+ * `Session.inheritedEventCount`. Feature detection stays here; callers must
+ * not probe the two shapes themselves.
+ *
+ * `ctx.sessions.fork()` is not a seed extractor: it creates and registers a
+ * real child. A child snapshot MAY include child-owned `session/end-seed`,
+ * so snapshot length cannot reliably be inferred as the inherited cut.
+ * Seed copies are sliced from the *source* snapshot through an inclusive
+ * event seq. The cut is that source-slice length (or
+ * `Session.inheritedEventCount` / physical `seedLength`), never a child
+ * snapshot length.
+ *
+ * Physical JSONL still stores optional `seedLength`. That encoding belongs to
+ * `sessionLog` / `sessions/header`, not this module.
+ *
+ * @module dsh-cli/compat/liveSession
+ */
+import * as dshSession from '@deepseek-ai/dsh-session';
+function liveOf(session) {
+    if (session === null || typeof session !== 'object') {
+        throw new Error('live Session contract violation: session is not an object');
+    }
+    return session;
+}
+function brandCtor(name) {
+    const ctor = dshSession[name];
+    return typeof ctor === 'function' ? ctor : undefined;
+}
+function brandSessionSeq(value) {
+    return brandCtor('SessionSeq')?.(value) ?? value;
+}
+function brandSessionLogOffset(value) {
+    return brandCtor('SessionLogOffset')?.(value) ?? value;
+}
+function asNonNegativeInt(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 && !Object.is(value, -0)
+        ? value
+        : undefined;
+}
+/**
+ * Snapshot of a live Session log, including any fork-inherited prefix.
+ * Reuses upstream's frozen cache when the log has not appended.
+ * A missing or non-array snapshot is a live Session contract violation.
+ */
+export function snapshotLiveSessionEvents(session) {
+    const live = liveOf(session);
+    if (typeof live.snapshotEvents === 'function') {
+        const snap = live.snapshotEvents();
+        if (!Array.isArray(snap)) {
+            throw new Error('live Session contract violation: snapshotEvents() did not return an array');
+        }
+        return snap;
+    }
+    if (Array.isArray(live.events))
+        return live.events;
+    throw new Error('live Session contract violation: neither snapshotEvents() nor events is available');
+}
+/**
+ * Exclusive log offset (`seq = log.length`). Empty log is 0, not -1, and this
+ * is not the last event's seq.
+ */
+export function liveSessionOffset(session) {
+    const seq = asNonNegativeInt(liveOf(session).seq);
+    if (seq !== undefined)
+        return seq;
+    return snapshotLiveSessionEvents(session).length;
+}
+function usesIsSeeded(session) {
+    return typeof liveOf(session).header?.['isSeeded'] === 'boolean';
+}
+/**
+ * Physical/wire `seedLength` for a live Session: present whenever an exact
+ * copied/inherited prefix is marked as seeded, independently of whether the
+ * header records `parentSession`. Fresh unseeded sessions omit it.
+ * `isSeeded: true` without `inheritedEventCount` is an unknown cut — never
+ * coerced to 0.
+ */
+export function liveSessionPhysicalSeedLength(session) {
+    const live = liveOf(session);
+    const header = live.header;
+    if (header !== undefined && typeof header['isSeeded'] === 'boolean') {
+        if (header['isSeeded'] !== true)
+            return undefined;
+        return asNonNegativeInt(live.inheritedEventCount);
+    }
+    return asNonNegativeInt(header?.['seedLength']);
+}
+/** Listing-shaped fields for overlaying a live Session onto the session tree. */
+export function liveSessionListingFields(session) {
+    const header = liveOf(session).header ?? {};
+    const text = (value) => typeof value === 'string' && value.length > 0 ? value : undefined;
+    return {
+        id: text(header['id']),
+        cwd: text(header['cwd']),
+        createdAt: asNonNegativeInt(header['createdAt']),
+        parentSession: text(header['parentSession']),
+        origin: text(header['origin']),
+        delegationDepth: asNonNegativeInt(header['delegationDepth']),
+        agentPreset: text(header['agentPreset']),
+        seedLength: liveSessionPhysicalSeedLength(session),
+    };
+}
+function assertTurnClosed(sliced, boundaryLabel) {
+    const lastTurn = sliced.findLast(event => event.type === 'turn/start' || event.type === 'turn/end');
+    if (lastTurn?.type === 'turn/start') {
+        throw new Error(`fork boundary ${boundaryLabel} ends inside open turn ${String(lastTurn.data.turn)}`);
+    }
+}
+/**
+ * Copy of the source log through an inclusive event seq. Omitted boundary
+ * means the whole log and still rejects an open turn. Never calls
+ * `sessions.fork()`.
+ */
+export function sliceLiveSessionSeed(session, boundary) {
+    const events = snapshotLiveSessionEvents(session);
+    const offset = liveSessionOffset(session);
+    if (events.length !== offset) {
+        throw new Error(`live Session contract violation: snapshot length ${events.length} does not match exclusive seq ${offset}`);
+    }
+    if (boundary === undefined) {
+        const sliced = [...events];
+        if (sliced.length === 0)
+            return sliced;
+        assertTurnClosed(sliced, String(offset - 1));
+        return sliced;
+    }
+    if (!Number.isSafeInteger(boundary) || boundary < 0 || Object.is(boundary, -0)) {
+        throw new Error(`fork boundary must be a non-negative safe integer, got ${String(boundary)}`);
+    }
+    if (boundary >= offset) {
+        const lastSeq = offset === 0 ? 'none' : String(offset - 1);
+        throw new Error(`fork boundary ${boundary} does not exist (last seq: ${lastSeq})`);
+    }
+    const boundaryEvent = events[boundary];
+    if (boundaryEvent === undefined || boundaryEvent.seq !== boundary) {
+        throw new Error(`fork boundary ${boundary} does not match a contiguous event seq`);
+    }
+    const sliced = events.slice(0, boundary + 1);
+    assertTurnClosed(sliced, String(boundary));
+    return sliced;
+}
+/**
+ * Create-time seed ownership fields. Every copied source prefix is inherited
+ * state for domain projections, even when `/fork` deliberately omits
+ * `parentSession` so the copy is presented as an independent root. The exact
+ * cut distinguishes copied history from child-owned events. Not every
+ * projection skips inherited events: newer inbox folds restore pending input
+ * from them, so rewind must cancel that work through the child's Inbox API.
+ * A child snapshot length cannot reliably be used as the cut because
+ * construction may append `session/end-seed`.
+ */
+export function liveSessionSeedMetadata(session, inheritedCount) {
+    if (usesIsSeeded(session)) {
+        return {
+            meta: { isSeeded: true },
+            inheritedEventCount: brandSessionLogOffset(inheritedCount),
+        };
+    }
+    return { meta: { seedLength: inheritedCount } };
+}
+/** Close an open turn with the `turn/end` shape a real user cancellation writes. */
+export function appendInterruptedTurnEnd(seed, turn) {
+    const last = seed[seed.length - 1];
+    if (last === undefined)
+        return;
+    seed.push({
+        type: 'turn/end',
+        seq: brandSessionSeq(Number(last.seq) + 1),
+        time: last.time + 1,
+        data: { turn, reason: { kind: 'aborted', reason: { kind: 'user' } } },
+    });
+}
+/** Close a V3 fork's open inherited turn as child-owned events, after its marker. */
+export function closeLiveForkTurn(session, turn) {
+    for (const event of dshSession.interruptedTurnClosers(snapshotLiveSessionEvents(session))) {
+        switch (event.type) {
+            case 'tool/result':
+                session.append('tool/result', event.data, {
+                    surfaceOp: event.surfaceOp,
+                    ...(event.sourceEventSeqs === undefined ? {} : { sourceEventSeqs: event.sourceEventSeqs }),
+                });
+                break;
+            case 'step/end':
+                session.append('step/end', event.data);
+                break;
+            case 'turn/end':
+                if (event.data.turn !== turn)
+                    throw new Error('fork turn closure does not match its selected turn');
+                session.append('turn/end', { turn, reason: { kind: 'aborted', reason: { kind: 'user' } } });
+                break;
+            default:
+                throw new Error(`unsupported fork closure event: ${event.type}`);
+        }
+    }
+}
+/**
+ * Dual-runtime seed metadata for `agents.create`. The only
+ * CreateAgentOptions assertion lives here: rc.2 meta carries `seedLength`,
+ * alpha.4 carries `isSeeded` plus top-level `inheritedEventCount`.
+ */
+export function liveSessionCreateOptions(request) {
+    const seedMetadata = liveSessionSeedMetadata(request.runtimeSession, request.inheritedCount);
+    return {
+        sessionId: request.sessionId,
+        seed: request.seed,
+        meta: {
+            cwd: request.cwd,
+            ...(request.parentSession === undefined ? {} : { parentSession: request.parentSession }),
+            ...seedMetadata.meta,
+            ...(request.agentPreset === undefined ? {} : { agentPreset: request.agentPreset }),
+        },
+        ...(seedMetadata.inheritedEventCount === undefined
+            ? {}
+            : { inheritedEventCount: seedMetadata.inheritedEventCount }),
+        agentOptions: request.agentOptions,
+        ...(request.setup === undefined ? {} : { setup: request.setup }),
+    };
+}

package/lib/types/dsh-adapter/compat/messages.d.ts

@@ -0,0 +1,15 @@
+import type { ContentBlock } from '@deepseek-ai/dsh-llm';
+/** 0.1.7 puts tool output on the message; older logs wrap it in one block. */
+export declare function toolResultPayload(message: {
+    readonly content?: readonly ContentBlock[];
+    readonly isError?: boolean;
+} | undefined): {
+    content: readonly ContentBlock[];
+    isError: boolean;
+};
+/** Preserve old checkpoints while recognizing the V4 producer-owned source. */
+export declare function isCompactionCheckpointSource(source: {
+    kind: string;
+    plugin?: string;
+}): boolean;
+//# sourceMappingURL=messages.d.ts.map

package/lib/types/dsh-adapter/compat/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/compat/messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAExD,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IACzC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,YAAY,EAAE,CAAA;IAC1C,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAC3B,GAAG,SAAS,GAAG;IAAE,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAarE;AAED,+EAA+E;AAC/E,wBAAgB,4BAA4B,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAE/F"}

package/lib/types/dsh-adapter/compat/messages.js

@@ -0,0 +1,15 @@
+/** 0.1.7 puts tool output on the message; older logs wrap it in one block. */
+export function toolResultPayload(message) {
+    const first = message?.content?.[0];
+    if (first?.type === 'tool-result') {
+        return {
+            content: Array.isArray(first.content) ? first.content : [],
+            isError: first.isError === true,
+        };
+    }
+    return { content: message?.content ?? [], isError: message?.isError === true };
+}
+/** Preserve old checkpoints while recognizing the V4 producer-owned source. */
+export function isCompactionCheckpointSource(source) {
+    return source.kind === 'compact-checkpoint' || (source.kind === 'plugin' && source.plugin === 'compact');
+}

package/lib/types/dsh-adapter/compat/persistence.d.ts

@@ -0,0 +1,21 @@
+import type { SessionEvent, SessionHeader, SessionId } from '@deepseek-ai/dsh-session';
+interface StoredSession {
+    readonly meta: SessionHeader;
+    readonly events: readonly SessionEvent[];
+    readonly inheritedEventCount?: number;
+}
+/** Read-only persistence seam for legacy services and per-session handles. */
+export interface SessionReader {
+    load?(id: SessionId): Promise<StoredSession>;
+    open?(id: SessionId, access: 'read'): Promise<{
+        readonly header: SessionHeader;
+        readonly inheritedEventCount?: number;
+        read(): Promise<{
+            readonly events: readonly SessionEvent[];
+        }>;
+        close(): Promise<void>;
+    }>;
+}
+export declare function readPersistedSession(source: SessionReader, id: SessionId): Promise<StoredSession>;
+export {};
+//# sourceMappingURL=persistence.d.ts.map

package/lib/types/dsh-adapter/compat/persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/compat/persistence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AAGtF,UAAU,aAAa;IACrB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAA;IAC5B,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAA;IACxC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;CACtC;AAED,8EAA8E;AAC9E,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;IAC5C,IAAI,CAAC,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;QAC5C,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAA;QAC9B,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;QACrC,IAAI,IAAI,OAAO,CAAC;YAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAA;SAAE,CAAC,CAAA;QAC7D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;KACvB,CAAC,CAAA;CACH;AAED,wBAAsB,oBAAoB,CAAC,MAAM,EAAE,aAAa,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,CAavG"}

package/lib/types/dsh-adapter/compat/persistence.js

@@ -0,0 +1,17 @@
+import { ensureLegacySessionEventTypes } from './sessionLog.js';
+export async function readPersistedSession(source, id) {
+    ensureLegacySessionEventTypes();
+    if (typeof source.open === 'function') {
+        const handle = await source.open(id, 'read');
+        try {
+            const { events } = await handle.read();
+            return { meta: handle.header, events, inheritedEventCount: handle.inheritedEventCount };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    if (typeof source.load === 'function')
+        return source.load(id);
+    throw new Error('dsh-tui: session persistence has no read API');
+}