@deepseek-harness-tui/dsh-tui 0.12.0 → 0.14.0

package/lib/types/backends/claude/modelEnv.d.ts

@@ -0,0 +1,64 @@
+/** The truth API the model list consumes (structural: no import cycle). */
+export interface ModelEnvTruth {
+    /** The model the channel actually routes `requestedId` to, when the
+     *  configuration says it differs; undefined = display as-is. */
+    actualFor(requestedId: string): string | undefined;
+}
+/**
+ * The active channel profile's mapping (channels.ts): `models` are exact
+ * requested-id → actual entries (matched exactly, then base-normalized);
+ * `tiers` map a tier keyword (haiku/opus/sonnet/fable, plus the reserved
+ * `default` for the any-model rule) to the model serving it — the settings
+ * env heuristics promoted to the user's own data, so they outrank both the
+ * legacy model-names.json and the env itself.
+ */
+export interface ChannelModelSource {
+    readonly models?: Readonly<Record<string, string>>;
+    readonly tiers?: Readonly<Record<string, string>>;
+}
+/** Read the env the CLI applies from `<configDir>/settings.json` (best-effort:
+ *  absent/unreadable/malformed means no values, never an error). */
+export declare function readSettingsEnvForModels(configDir: string): Record<string, string | undefined>;
+/**
+ * The user-maintained local map, `<DATA_DIR>/backends/claude/model-names.json`
+ * (`{ "claude-opus-5-5[1m]": "glm-5.3[1M]", ... }`): ids a relay channel
+ * disguises → the name to display. Optional and additive on top of the
+ * settings env tiers; checked first so a hand-written entry always wins
+ * (the /provider-style escape hatch when the channel tool renames its env
+ * shape). Best-effort: absent/unreadable/malformed reads as no entries.
+ */
+export declare function readLocalModelNames(dir: string): Readonly<Record<string, string>>;
+/** Build the channel-model truth from the tier env the caller resolved
+ *  (mergedModelEnv — the CLI's own three-layer order, see there) plus the
+ *  optional local model-names.json map, which outranks it — and the active
+ *  channel profile (channels.ts), which outranks everything. */
+export declare function readModelEnvTruth(env: Record<string, string | undefined>, localNames?: Readonly<Record<string, string>>, channel?: ChannelModelSource): ModelEnvTruth;
+/**
+ * Whether the env the CLI child runs with already routes to `model`
+ * through its model slots: some slot's value — compared as base ids,
+ * `[1M]`-style suffixes and letter case ignored — names the same model.
+ * The session's explicit `model` query parameter can then be omitted:
+ * the CLI's SDK path (2.1.284+) resolves an explicit model against the
+ * bundled official catalog and fail-fasts a non-official name (a relay
+ * model) as `[claude-code:unrecognized_model]`, while the same name in
+ * an env slot routes fine — the parameter would only add a failing
+ * catalog check on top of routing that already serves that model.
+ */
+export declare function envSlotsServeModel(env: Record<string, string | undefined>, model: string): boolean;
+/** The env the CLI child actually applies, in the CLI's own order: keys
+ *  the TUI put in the flag layer (`injectedKeys`: the channel connection,
+ *  the first-party pin) > the settings file's `env` > the inherited env.
+ *  The CLI applies the settings `env` over the environment it inherited, so
+ *  an inherited key only fills gaps. Empty live values never clobber
+ *  anything. */
+export declare function mergedModelEnv(configDir: string, liveEnv: Readonly<Record<string, string | undefined>>, injectedKeys?: ReadonlySet<string>): Record<string, string | undefined>;
+/** The env "import from settings" reads: the settings file plus the
+ *  inherited environment (settings first), without the TUI's own
+ *  injections. Reading those back would import the channel the TUI itself
+ *  activated: switch settings to relay B, import, get relay A back. */
+export declare function importedModelEnv(configDir: string, liveEnv: Readonly<Record<string, string | undefined>>, injectedKeys?: ReadonlySet<string>): Record<string, string | undefined>;
+/** One-shot wiring for the session: settings env of `configDir` + live env
+ *  (the CLI's flag > settings > inherited order), the optional local
+ *  model-names.json map, and the active channel profile. */
+export declare function modelTruthFrom(configDir: string, liveEnv: Readonly<Record<string, string | undefined>>, localNames?: Readonly<Record<string, string>>, channel?: ChannelModelSource, injectedKeys?: ReadonlySet<string>): ModelEnvTruth;
+//# sourceMappingURL=modelEnv.d.ts.map

package/lib/types/backends/claude/modelEnv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelEnv.d.ts","sourceRoot":"","sources":["../../../../src/backends/claude/modelEnv.ts"],"names":[],"mappings":"AA+BA,2EAA2E;AAC3E,MAAM,WAAW,aAAa;IAC5B;oEACgE;IAChE,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;CACnD;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAClD,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAClD;AAOD;oEACoE;AACpE,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAY9F;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAYjF;AAED;;;gEAGgE;AAChE,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EACvC,UAAU,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM,EACjD,OAAO,CAAC,EAAE,kBAAkB,GAC3B,aAAa,CAiDf;AASD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EACvC,KAAK,EAAE,MAAM,GACZ,OAAO,CAQT;AAED;;;;;gBAKgB;AAChB,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,EACrD,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GACjC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAQpC;AAED;;;uEAGuE;AACvE,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,EACrD,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GACjC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAOpC;AAED;;4DAE4D;AAC5D,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,EACrD,UAAU,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM,EACjD,OAAO,CAAC,EAAE,kBAAkB,EAC5B,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GACjC,aAAa,CAEf"}

package/lib/types/backends/claude/modelEnv.js

@@ -0,0 +1,199 @@
+/**
+ * The channel's real model names, from the environment the CLI child runs
+ * with. Relay channels sell cosmetic tier names ("Opus 5.5 (1M)") while
+ * routing the request to a different model — and the runtime stream cannot
+ * correct the display, because such relays echo the requested name back in
+ * `message_start.model` (observed on a bigmodel.cn anthropic-compat channel:
+ * a `claude-opus-5-5` request echoed `claude-opus-5-5` while the same channel
+ * leaked the real `glm-5.3-flash` on the haiku tier). The user's own
+ * ANTHROPIC_*_MODEL mapping in the settings `env` is the only honest source,
+ * so the model list surfaces it: when a row's requested id maps to a
+ * different configured model, the label becomes the actual model and the
+ * cosmetic name moves into the description. Real Claude setups (no such
+ * env, or a mapping that resolves to the same model) render exactly as
+ * before.
+ *
+ * @module dsh-tui/backends/claude/modelEnv
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+/** tier keyword → the env keys naming its configured model. */
+const TIER_ENV_KEYS = [
+    ['haiku', 'ANTHROPIC_DEFAULT_HAIKU_MODEL', 'ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME'],
+    ['opus', 'ANTHROPIC_DEFAULT_OPUS_MODEL', 'ANTHROPIC_DEFAULT_OPUS_MODEL_NAME'],
+    ['sonnet', 'ANTHROPIC_DEFAULT_SONNET_MODEL', 'ANTHROPIC_DEFAULT_SONNET_MODEL_NAME'],
+    ['fable', 'ANTHROPIC_DEFAULT_FABLE_MODEL', 'ANTHROPIC_DEFAULT_FABLE_MODEL_NAME'],
+];
+/** Compare ids without the `[1m]` context-window suffix or letter case. */
+const baseOf = (id) => id.replace(/\[(1m)\]$/i, '').toLowerCase();
+const pick = (env, key) => {
+    const value = env[key];
+    return typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined;
+};
+/** Read the env the CLI applies from `<configDir>/settings.json` (best-effort:
+ *  absent/unreadable/malformed means no values, never an error). */
+export function readSettingsEnvForModels(configDir) {
+    try {
+        const raw = JSON.parse(readFileSync(join(configDir, 'settings.json'), 'utf8'));
+        if (raw.env === null || typeof raw.env !== 'object' || Array.isArray(raw.env))
+            return {};
+        const out = {};
+        for (const [key, value] of Object.entries(raw.env)) {
+            if (typeof value === 'string')
+                out[key] = value;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * The user-maintained local map, `<DATA_DIR>/backends/claude/model-names.json`
+ * (`{ "claude-opus-5-5[1m]": "glm-5.3[1M]", ... }`): ids a relay channel
+ * disguises → the name to display. Optional and additive on top of the
+ * settings env tiers; checked first so a hand-written entry always wins
+ * (the /provider-style escape hatch when the channel tool renames its env
+ * shape). Best-effort: absent/unreadable/malformed reads as no entries.
+ */
+export function readLocalModelNames(dir) {
+    try {
+        const raw = JSON.parse(readFileSync(join(dir, 'model-names.json'), 'utf8'));
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+            return {};
+        const out = {};
+        for (const [key, value] of Object.entries(raw)) {
+            if (key.trim() !== '' && typeof value === 'string' && value.trim() !== '')
+                out[key.trim()] = value.trim();
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+/** Build the channel-model truth from the tier env the caller resolved
+ *  (mergedModelEnv — the CLI's own three-layer order, see there) plus the
+ *  optional local model-names.json map, which outranks it — and the active
+ *  channel profile (channels.ts), which outranks everything. */
+export function readModelEnvTruth(env, localNames = {}, channel) {
+    return {
+        actualFor(requestedId) {
+            if (requestedId === '')
+                return undefined;
+            // The active channel profile is the user's own data: its exact models
+            // map wins over every heuristic below (like model-names.json, an
+            // explicit entry is always honored — even one mapping an id to itself).
+            const channelModels = channel?.models;
+            if (channelModels !== undefined) {
+                const exact = channelModels[requestedId];
+                if (exact !== undefined)
+                    return exact;
+            }
+            const base = baseOf(requestedId);
+            if (channelModels !== undefined) {
+                for (const [key, value] of Object.entries(channelModels)) {
+                    if (baseOf(key) === base)
+                        return value;
+                }
+            }
+            // Then the profile's tier rules — the env heuristics promoted to user
+            // data, guarded the same way (a tier mapping to the requested model
+            // itself changes nothing; the lower sources still get their say).
+            const channelTiers = channel?.tiers;
+            if (channelTiers !== undefined) {
+                for (const [tier, actual] of Object.entries(channelTiers)) {
+                    if (tier !== 'default' && base.includes(tier)) {
+                        return baseOf(actual) !== base ? actual : undefined;
+                    }
+                }
+                const fallback = channelTiers.default;
+                if (fallback !== undefined) {
+                    return base !== 'default' && baseOf(fallback) !== base ? fallback : undefined;
+                }
+            }
+            const local = localNames[requestedId];
+            if (local !== undefined)
+                return local;
+            for (const [key, value] of Object.entries(localNames)) {
+                if (baseOf(key) === base)
+                    return value;
+            }
+            const id = base;
+            for (const [tier, modelKey, nameKey] of TIER_ENV_KEYS) {
+                if (id.includes(tier)) {
+                    const actual = pick(env, modelKey) ?? pick(env, nameKey);
+                    return actual !== undefined && baseOf(actual) !== id ? actual : undefined;
+                }
+            }
+            const fallback = pick(env, 'ANTHROPIC_MODEL');
+            return fallback !== undefined && id !== 'default' && baseOf(fallback) !== id ? fallback : undefined;
+        },
+    };
+}
+/** The model slots the CLI's env routing reads: `ANTHROPIC_MODEL` pins
+ *  every tier, `ANTHROPIC_DEFAULT_<TIER>_MODEL` one tier's slot. */
+const SLOT_ENV_KEYS = [
+    'ANTHROPIC_MODEL',
+    ...TIER_ENV_KEYS.map(([, modelKey]) => modelKey),
+];
+/**
+ * Whether the env the CLI child runs with already routes to `model`
+ * through its model slots: some slot's value — compared as base ids,
+ * `[1M]`-style suffixes and letter case ignored — names the same model.
+ * The session's explicit `model` query parameter can then be omitted:
+ * the CLI's SDK path (2.1.284+) resolves an explicit model against the
+ * bundled official catalog and fail-fasts a non-official name (a relay
+ * model) as `[claude-code:unrecognized_model]`, while the same name in
+ * an env slot routes fine — the parameter would only add a failing
+ * catalog check on top of routing that already serves that model.
+ */
+export function envSlotsServeModel(env, model) {
+    if (model === '')
+        return false;
+    const base = baseOf(model);
+    for (const key of SLOT_ENV_KEYS) {
+        const slot = pick(env, key);
+        if (slot !== undefined && baseOf(slot) === base)
+            return true;
+    }
+    return false;
+}
+/** The env the CLI child actually applies, in the CLI's own order: keys
+ *  the TUI put in the flag layer (`injectedKeys`: the channel connection,
+ *  the first-party pin) > the settings file's `env` > the inherited env.
+ *  The CLI applies the settings `env` over the environment it inherited, so
+ *  an inherited key only fills gaps. Empty live values never clobber
+ *  anything. */
+export function mergedModelEnv(configDir, liveEnv, injectedKeys) {
+    const merged = readSettingsEnvForModels(configDir);
+    for (const [key, value] of Object.entries(liveEnv)) {
+        if (typeof value !== 'string' || value.trim() === '')
+            continue;
+        if (injectedKeys?.has(key) === true)
+            merged[key] = value;
+        else if (!Object.hasOwn(merged, key))
+            merged[key] = value;
+    }
+    return merged;
+}
+/** The env "import from settings" reads: the settings file plus the
+ *  inherited environment (settings first), without the TUI's own
+ *  injections. Reading those back would import the channel the TUI itself
+ *  activated: switch settings to relay B, import, get relay A back. */
+export function importedModelEnv(configDir, liveEnv, injectedKeys) {
+    const merged = readSettingsEnvForModels(configDir);
+    for (const [key, value] of Object.entries(liveEnv)) {
+        if (injectedKeys?.has(key) === true)
+            continue;
+        if (typeof value === 'string' && value.trim() !== '' && !Object.hasOwn(merged, key))
+            merged[key] = value;
+    }
+    return merged;
+}
+/** One-shot wiring for the session: settings env of `configDir` + live env
+ *  (the CLI's flag > settings > inherited order), the optional local
+ *  model-names.json map, and the active channel profile. */
+export function modelTruthFrom(configDir, liveEnv, localNames = {}, channel, injectedKeys) {
+    return readModelEnvTruth(mergedModelEnv(configDir, liveEnv, injectedKeys), localNames, channel);
+}

package/lib/types/backends/claude/narrow.d.ts

@@ -0,0 +1,10 @@
+/** Narrowing helpers for the untyped SDK frames and transcript records. */
+export type Rec = Readonly<Record<string, unknown>>;
+/** A plain object (not an array), else undefined. */
+export declare const rec: (value: unknown) => Rec | undefined;
+export declare const str: (value: unknown) => string | undefined;
+/** A finite number, else undefined. */
+export declare const num: (value: unknown) => number | undefined;
+export declare const arr: (value: unknown) => readonly unknown[];
+export declare const errorText: (error: unknown) => string;
+//# sourceMappingURL=narrow.d.ts.map

package/lib/types/backends/claude/narrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"narrow.d.ts","sourceRoot":"","sources":["../../../../src/backends/claude/narrow.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAE3E,MAAM,MAAM,GAAG,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAEnD,qDAAqD;AACrD,eAAO,MAAM,GAAG,GAAI,OAAO,OAAO,KAAG,GAAG,GAAG,SACsD,CAAA;AAEjG,eAAO,MAAM,GAAG,GAAI,OAAO,OAAO,KAAG,MAAM,GAAG,SAA0D,CAAA;AAExG,uCAAuC;AACvC,eAAO,MAAM,GAAG,GAAI,OAAO,OAAO,KAAG,MAAM,GAAG,SAAoF,CAAA;AAElI,eAAO,MAAM,GAAG,GAAI,OAAO,OAAO,KAAG,SAAS,OAAO,EAAuC,CAAA;AAE5F,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,MAAgE,CAAA"}

package/lib/types/backends/claude/narrow.js

@@ -0,0 +1,8 @@
+/** Narrowing helpers for the untyped SDK frames and transcript records. */
+/** A plain object (not an array), else undefined. */
+export const rec = (value) => typeof value === 'object' && value !== null && !Array.isArray(value) ? value : undefined;
+export const str = (value) => typeof value === 'string' ? value : undefined;
+/** A finite number, else undefined. */
+export const num = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+export const arr = (value) => Array.isArray(value) ? value : [];
+export const errorText = (error) => error instanceof Error ? error.message : String(error);

package/lib/types/backends/claude/older-history.d.ts

@@ -0,0 +1,16 @@
+import type { SessionCapabilities } from '../../agent/capabilities.js';
+export interface ClaudeTranscriptHistoryDeps {
+    /** The session (a function when it can change: a conversation reset moves
+     *  the CLI to a new session id, whose file has no older history yet). */
+    readonly sessionId: string | (() => string);
+    readonly cwd: string;
+    /** The CLI's config directory (where its `projects/` live). */
+    configDir(): string;
+    /** Where the resumed chain began (a compaction), if it did. */
+    readonly compactedFrom?: string;
+    /** Entries per older slice (bounded; tests lower it). */
+    readonly sliceEntries?: number;
+    readonly debug?: (message: string) => void;
+}
+export declare function createClaudeTranscriptHistory(deps: ClaudeTranscriptHistoryDeps): NonNullable<SessionCapabilities['transcript']>;
+//# sourceMappingURL=older-history.d.ts.map

package/lib/types/backends/claude/older-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"older-history.d.ts","sourceRoot":"","sources":["../../../../src/backends/claude/older-history.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA;AAOtE,MAAM,WAAW,2BAA2B;IAC1C;6EACyE;IACzE,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,CAAA;IAC3C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,+DAA+D;IAC/D,SAAS,IAAI,MAAM,CAAA;IACnB,+DAA+D;IAC/D,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;IAC/B,yDAAyD;IACzD,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3C;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,2BAA2B,GAAG,WAAW,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC,CAiF/H"}

package/lib/types/backends/claude/older-history.js

@@ -0,0 +1,101 @@
+/**
+ * The `transcript` capability of a Claude session: "load
+ * earlier" restores folded rows from, and prepends history older than the
+ * resumed chain out of, the session's own transcript file — read-only,
+ * synchronous, bounded (transcript-file.ts), replayed by the same replay as
+ * a resume (replay.ts), so older rows look exactly like resumed ones.
+ *
+ * Older history exists only when the resumed chain began at a compaction
+ * (`ClaudeReplay.compactedFrom`): slices are walked back one compaction
+ * segment at a time (a long segment in bounded slices), newest first; the
+ * cursor only moves on, so a repeated "load earlier" never repeats a slice.
+ */
+import { statSync } from 'node:fs';
+import { t } from '../../i18n.js';
+import { replayClaudeTranscript } from './replay.js';
+import { cursorBefore, headBoundary, locateClaudeTranscript, olderSlice, readTranscriptEntries } from './transcript-file.js';
+export function createClaudeTranscriptHistory(deps) {
+    const debug = deps.debug ?? (() => undefined);
+    const sessionIdOf = () => typeof deps.sessionId === 'function' ? deps.sessionId() : deps.sessionId;
+    let boundId = sessionIdOf();
+    let path;
+    let cursor = deps.compactedFrom === undefined ? 'done' : 'start';
+    /**
+     * The parsed file, keyed by its size and mtime: a "load earlier" press
+     * parses the transcript once per change, not once per call (record and
+     * older on the same press share it), and the full-record replay is kept
+     * with it.
+     */
+    let parsed;
+    /** The session moved to another id: its file, no older segments known. */
+    const follow = () => {
+        const id = sessionIdOf();
+        if (id === boundId)
+            return;
+        boundId = id;
+        path = undefined;
+        parsed = undefined;
+        cursor = 'done';
+    };
+    const load = () => {
+        follow();
+        path ??= locateClaudeTranscript(boundId, deps.configDir());
+        if (path === undefined)
+            throw new Error(t('claude-transcript-missing', { id: boundId }));
+        const stat = statSync(path);
+        if (parsed !== undefined && parsed.size === stat.size && parsed.mtimeMs === stat.mtimeMs)
+            return parsed;
+        const { entries, badLines } = readTranscriptEntries(path);
+        if (badLines > 0)
+            debug(`claude: ${badLines} malformed transcript line(s) skipped`);
+        parsed = { size: stat.size, mtimeMs: stat.mtimeMs, entries };
+        return parsed;
+    };
+    const replay = (entries) => replayClaudeTranscript(entries, { cwd: deps.cwd, debug }).events;
+    return {
+        record() {
+            const file = load();
+            file.record ??= replay(file.entries.filter(entry => (entry.type === 'user' || entry.type === 'assistant') && entry.isSidechain !== true));
+            return file.record;
+        },
+        hasOlder: () => {
+            follow();
+            return cursor !== 'done';
+        },
+        older() {
+            if (cursor === 'done')
+                return [];
+            const file = load();
+            const entries = file.entries;
+            if (file.byUuid === undefined) {
+                file.byUuid = new Map();
+                for (const entry of entries)
+                    if (typeof entry.uuid === 'string')
+                        file.byUuid.set(entry.uuid, entry);
+            }
+            const byUuid = file.byUuid;
+            let current;
+            if (cursor === 'start') {
+                const head = headBoundary(entries, byUuid, deps.compactedFrom);
+                current = head === undefined ? undefined : cursorBefore(head, byUuid);
+            }
+            else {
+                current = cursor;
+            }
+            // A slice with nothing to show (all hidden) moves on to the next one;
+            // a corrupted tree cannot send the walk round in a circle.
+            const visited = new Set();
+            while (current !== undefined && !visited.has(current.end)) {
+                visited.add(current.end);
+                const slice = olderSlice(byUuid, current, deps.sliceEntries);
+                current = slice.next;
+                if (slice.entries.length > 0) {
+                    cursor = current ?? 'done';
+                    return replay(slice.entries);
+                }
+            }
+            cursor = 'done';
+            return [];
+        },
+    };
+}

package/lib/types/backends/claude/options.d.ts

@@ -0,0 +1,181 @@
+/**
+ * The Claude Code fidelity profile: the `query()` options that make a dsh-tui Claude session behave like `claude`
+ * in the same project — the CLI's own system prompt, every settings source
+ * (CLAUDE.md, hooks, MCP, plugins load as in the CLI), its tool preset, an
+ * explicit start permission mode, streaming partials, subagent text and
+ * per-task stop, file checkpoints, and the host's permission callback.
+ *
+ * `OPTION_POLICY` classifies every SDK option. It is checked with
+ * `satisfies Record<keyof Options, …>`: an option the SDK adds or removes
+ * fails `tsc` here until someone decides what the profile does with it.
+ */
+import type { CanUseTool, OnElicitation, OnUserDialog, Options, PermissionMode, SettingSource } from '@anthropic-ai/claude-agent-sdk';
+import type { ClaudeSdkModule } from './sdk.js';
+import './sdk-warnings.js';
+export declare const OPTION_POLICY: {
+    readonly abortController: "set";
+    readonly additionalDirectories: "later";
+    readonly projectConfigRoot: "omit";
+    readonly agent: "omit";
+    readonly agents: "omit";
+    readonly allowedTools: "set";
+    readonly canUseTool: "set";
+    readonly continue: "omit";
+    readonly cwd: "set";
+    readonly disallowedTools: "omit";
+    readonly toolAliases: "omit";
+    readonly tools: "set";
+    readonly env: "set";
+    readonly executable: "omit";
+    readonly executableArgs: "omit";
+    readonly extraArgs: "set";
+    readonly fallbackModel: "omit";
+    readonly enableFileCheckpointing: "set";
+    readonly toolConfig: "omit";
+    readonly forkSession: "side";
+    readonly betas: "omit";
+    readonly hooks: "omit";
+    readonly onElicitation: "set";
+    readonly onUserDialog: "set";
+    readonly supportedDialogKinds: "set";
+    readonly perTaskStopAffordance: "set";
+    readonly persistSession: "side";
+    readonly sessionStore: "omit";
+    readonly sessionStoreFlush: "omit";
+    readonly loadTimeoutMs: "omit";
+    readonly includeHookEvents: "set";
+    readonly includePartialMessages: "set";
+    readonly forwardSubagentText: "set";
+    readonly verbatimPrompts: "omit";
+    readonly thinking: "omit";
+    readonly effort: "set";
+    readonly maxThinkingTokens: "omit";
+    readonly maxTurns: "side";
+    readonly maxBudgetUsd: "omit";
+    readonly taskBudget: "omit";
+    readonly mcpServers: "omit";
+    readonly model: "set";
+    readonly outputFormat: "omit";
+    readonly pathToClaudeCodeExecutable: "set";
+    readonly permissionMode: "set";
+    readonly planModeInstructions: "omit";
+    readonly allowDangerouslySkipPermissions: "set";
+    readonly permissionPromptToolName: "omit";
+    readonly permissionPrompts: "omit";
+    readonly plugins: "omit";
+    readonly pluginDelivery: "omit";
+    readonly promptSuggestions: "omit";
+    readonly agentProgressSummaries: "omit";
+    readonly resume: "set";
+    readonly sessionId: "set";
+    readonly resumeSessionAt: "later";
+    readonly resumeDropsTurn: "later";
+    readonly sandbox: "omit";
+    readonly settings: "set";
+    readonly managedSettings: "omit";
+    readonly settingSources: "set";
+    readonly skills: "omit";
+    readonly debug: "omit";
+    readonly debugFile: "omit";
+    readonly stderr: "set";
+    readonly strictMcpConfig: "omit";
+    readonly systemPrompt: "set";
+    readonly title: "omit";
+    readonly spawnClaudeCodeProcess: "omit";
+};
+/** Every settings source, so CLAUDE.md, hooks, MCP and plugins load as in
+ *  the CLI (`project` is the one that brings CLAUDE.md). */
+export declare const SETTING_SOURCES: SettingSource[];
+/** The plan-tracking tools the todo panel renders (the Task* family
+ *  replaced TodoWrite in CLI 2.1.284). The preset defers them, so
+ *  `allowedTools` brings them in and pre-approves them; `tools` stays the
+ *  preset (an explicit list would replace the whole default set). */
+export declare const TODO_PANEL_TOOLS: readonly string[];
+/** What the start-mode resolution decided, and why (for a notice). */
+export interface StartPermissionMode {
+    readonly mode: PermissionMode;
+    /** Set when the configured mode was not honoured. */
+    readonly downgradedFrom?: PermissionMode;
+    readonly source: 'env' | 'pref' | 'settings' | 'default';
+    /** `DSH_TUI_CLAUDE_PERMISSION_MODE` was set to a value the override refuses. */
+    readonly ignoredOverride?: string;
+    /** The remembered pick was `bypassPermissions`, which a new session never
+     *  starts in (it was resolved as if nothing were remembered). */
+    readonly bypassNotCarried?: true;
+}
+/**
+ * The explicit start permission mode (never omitted: the CLI default may be
+ * `auto`). `DSH_TUI_CLAUDE_PERMISSION_MODE` is a developer override for live
+ * tests and the only way to start in `bypassPermissions`
+ * (docs/configuration.md). Next comes `pref`, the user's remembered
+ * `/permission` pick (`~/.dsh-tui/backends/claude/prefs.json`): it skips the
+ * settings cascade (no escalation filter, no downgrade notice) — except a
+ * remembered `bypassPermissions`, which is never carried into a new session
+ * (Claude Code itself wants an explicit flag on every start): it resolves as
+ * if nothing were remembered and says so (`bypassNotCarried`). An illegal
+ * persisted value reads as no choice. Otherwise the user's settings cascade
+ * after the CLI's own trust filter for escalating modes from repo-committed
+ * files; otherwise `default`.
+ *
+ * Starting elsewhere restricts nothing: the bypass gate rides along on every
+ * query (`buildQueryOptions`), so `/permission` may switch into
+ * `bypassPermissions` at any point of the session.
+ */
+export declare function resolveStartPermissionMode(sdk: Pick<ClaudeSdkModule, 'resolveSettings' | 'filterEscalatingDefaultMode'>, cwd: string, env?: NodeJS.ProcessEnv, pref?: string): Promise<StartPermissionMode>;
+export type ProfileInput = {
+    readonly cwd: string;
+    readonly permissionMode: PermissionMode;
+    readonly executable: string | undefined;
+    readonly env: Record<string, string>;
+    readonly canUseTool: CanUseTool;
+    /** MCP elicitation and the CLI's user dialogs (dialogs.ts); absent = the
+     *  SDK defaults (elicitation declined, no dialog kinds declared). */
+    readonly onElicitation?: OnElicitation;
+    readonly onUserDialog?: OnUserDialog;
+    readonly supportedDialogKinds?: readonly string[];
+    readonly stderr: (data: string) => void;
+    readonly abortController: AbortController;
+    /** Fall back to echoed user messages when the CLI has no lifecycle frames. */
+    readonly replayUserMessages: boolean;
+    /** Start model / effort (the user's persisted choice); absent = the CLI's. */
+    readonly model?: string;
+    readonly effort?: string;
+    /** The auth plan's flag layer (auth.ts) as a file path
+     *  (flag-settings.ts); absent = none. */
+    readonly settingsFile?: string;
+} & (
+/** A new session under this id … */
+{
+    readonly sessionId: string;
+    readonly resume?: undefined;
+}
+/** … or the same session resumed (the SDK refuses both together). */
+ | {
+    readonly resume: string;
+    readonly sessionId?: undefined;
+});
+/** What a side query (`/btw`, `/recap`; side-query.ts) runs with. */
+export interface SideQueryInput {
+    readonly cwd: string;
+    /** The session it forks (persisted). */
+    readonly resume: string;
+    readonly env: Record<string, string>;
+    /** The flag layer as a file path (flag-settings.ts). */
+    readonly settingsFile?: string;
+    readonly executable: string | undefined;
+    readonly abortController: AbortController;
+    readonly stderr: (data: string) => void;
+    readonly model?: string;
+}
+/**
+ * The side query's options: a throwaway fork of the
+ * conversation (`resume` + `forkSession`, `persistSession:false` — no
+ * transcript written), no tools, one turn, the session's model, and the
+ * session's own system prompt, settings sources, environment, credential
+ * and route pin. Nothing can ask for permission (no tools; any request is
+ * refused).
+ */
+export declare function buildSideQueryOptions(input: SideQueryInput): Options;
+/** Assemble the `query()` options of one session. */
+export declare function buildQueryOptions(input: ProfileInput): Options;
+//# sourceMappingURL=options.d.ts.map

package/lib/types/backends/claude/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../../src/backends/claude/options.ts"],"names":[],"mappings":"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"}