dsh-code 0.7.0 → 0.9.0

package/lib/types/render/markdown.d.ts

@@ -3,13 +3,13 @@
  * block/inline parser producing styled line segments the Ink renderer maps
  * to colored text. No ANSI here — the app owns color mapping, tests own the
  * structure. The subset mirrors what agent replies actually emit: headings,
- * emphasis, inline/fenced code, flat lists, blockquotes, links, rules, and
- * wrapped paragraphs. Unknown syntax degrades to plain text (never throws).
+ * emphasis, inline/fenced code, flat lists, blockquotes, links, rules, GFM
+ * tables, and wrapped paragraphs. Unknown syntax degrades to plain text.
  *
  * @module @deepseek-ai/dsh-code/render/markdown
  */
 /** Style classes the renderer emits; the app maps them to colors/props. */
-export type MdStyle = 'plain' | 'bold' | 'italic' | 'boldItalic' | 'code' | 'accent' | 'dim' | 'strike';
+export type MdStyle = 'plain' | 'bold' | 'italic' | 'boldItalic' | 'code' | 'accent' | 'accentBold' | 'dim' | 'strike';
 /** One styled run of text. */
 export interface MdSegment {
     /** Visible text (no ANSI). */

package/lib/types/render/projection.d.ts

@@ -47,6 +47,8 @@ export interface ToolEntry {
     arguments: string;
     /** Bounded human-meaningful arguments preview for the tool card. */
     preview: string;
+    /** Bounded delegation prompt (subagent cards' second row), '' when none. */
+    prompt: string;
     /** Execution state; `running` until the paired result lands. */
     state: 'running' | 'done' | 'error';
     /** Bounded first text block of the result, empty until it lands. */
@@ -236,7 +238,10 @@ export interface TranscriptView {
     /**
      * Fold-internal timing anchors, never rendered: open step and tool-call
      * start timestamps the next `assistant/message` / `tool/result` resolves
-     * against. Keyed `turn:step` and by call id.
+     * against. Keyed `turn:step` and by call id. `turnSteps`/`turnTools`
+     * track which step/tool anchors still belong to the open turn so
+     * `turn/end` (and a superseding `step/start`) can sweep anchors an
+     * interruption left behind; `turnFiles` keys mutated paths by turn.
      */
     readonly anchors: {
         stepStart: Map<string, number>;
@@ -245,6 +250,8 @@ export interface TranscriptView {
         compactionTokens: Map<string, number>;
         lastPruneTokens: number;
         turnFiles: Map<number, Set<string>>;
+        turnSteps: Map<number, string>;
+        turnTools: Map<number, Set<string>>;
     };
 }
 /** A fresh, empty transcript view. */
@@ -256,8 +263,92 @@ export declare function createTranscriptView(): TranscriptView;
  * @returns the view after the event; the input view is never mutated.
  */
 export declare function projectEvent(view: TranscriptView, event: SessionEvent): TranscriptView;
+/**
+ * Mutable replay accumulator: folds a persisted log into the identical view
+ * `projectEvent` would produce, but in near-linear time. Where `projectEvent`
+ * is copy-on-write — every append/scan rebuilds the whole `entries` array, so
+ * folding a full log costs O(N²) — the accumulator appends by push, resolves
+ * id-keyed updates (tool/result, command/done, retry-started) through index
+ * maps, and tombstones retired pending rows, so the whole log folds in O(N)
+ * plus one compaction pass when tombstones exist.
+ *
+ * Index maps never delete: every appended row registers its index, so an id
+ * lookup miss provably means no matching row exists and the update is an O(1)
+ * no-op (a malicious/orphan-heavy log cannot force per-orphan full-array
+ * scans). Each id maps to ALL of its indices, so a duplicate id updates every
+ * matching row exactly like the copy-on-write reducer.
+ *
+ * @internal Exported only so tests can (a) prove replay ≡ sequential
+ * `projectEvent` folds and (b) assert the linear complexity deterministically
+ * via {@link ReplayAccumulator.ops}, which counts entry-level container work
+ * instead of relying on wall-clock thresholds. No public consumer.
+ */
+export interface ReplayAccumulator {
+    /** Working entry list; `undefined` marks a retired pending row (tombstone). */
+    entries: (TranscriptEntry | undefined)[];
+    /** callId → every index into `entries` holding a `tool` row with that id. */
+    toolIndex: Map<string, number[]>;
+    /** commandId → every index into `entries` holding a `command` row with that id. */
+    commandIndex: Map<string, number[]>;
+    /** retryId → every index into `entries` holding a `retry` row with that id. */
+    retryIndex: Map<string, number[]>;
+    /** messageId → every index into `entries` holding a `pending` row with that id. */
+    pendingIndex: Map<string, number[]>;
+    /** Tombstone count; zero means `entries` is already the final array. */
+    removedCount: number;
+    /** Mutable inbox id lists, mirroring `view.pending` order per target. */
+    pendingTurn: string[];
+    pendingStep: string[];
+    streaming: string;
+    streamingReasoning: string;
+    todos: readonly TodoItem[];
+    busy: boolean;
+    busySince: number;
+    model: string;
+    plan: boolean;
+    permission: string;
+    title: string;
+    sandbox: string;
+    goal: GoalFold | undefined;
+    stats: TranscriptStats;
+    stepStart: Map<string, number>;
+    toolStart: Map<string, number>;
+    firstChunkAt: Map<string, number>;
+    compactionTokens: Map<string, number>;
+    lastPruneTokens: number;
+    turnFiles: Map<number, Set<string>>;
+    turnSteps: Map<number, string>;
+    turnTools: Map<number, Set<string>>;
+    /** Entry-level container operations performed so far (test instrumentation). */
+    ops: number;
+}
+/** @internal A fresh replay accumulator whose state mirrors `createTranscriptView()`. */
+export declare function createReplayAccumulator(): ReplayAccumulator;
+/**
+ * Fold one session event into a replay accumulator. This mirrors
+ * {@link projectEvent} case for case — same stats arithmetic, same anchor
+ * set/delete behavior, same entry shapes — so the finished view is identical
+ * to a sequential fold; only the `entries` container operations are mutable.
+ *
+ * @internal Test-instrumentation path; `projectEvents` is the public entry.
+ */
+export declare function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent): void;
+/**
+ * Materialize the accumulated fold as a `TranscriptView`, compacting any
+ * retired tombstones. The anchors maps are handed through as-is (their
+ * content is identical to a sequential fold's).
+ *
+ * @internal Test-instrumentation path; `projectEvents` is the public entry.
+ */
+export declare function finishReplay(acc: ReplayAccumulator): TranscriptView;
 /**
  * Fold a replayed event history into one view.
+ *
+ * Folding is near-linear in the log size: the mutable replay accumulator
+ * appends in place and resolves id-keyed updates through index maps, so a
+ * long persisted session replays without the O(N²) copy-on-write rebuilds a
+ * naive sequential fold would incur. The result is identical to folding
+ * {@link projectEvent} per event in order.
  * @param events - events in `seq` order.
  * @returns the folded view.
  */
@@ -271,8 +362,11 @@ export declare function projectEvents(events: readonly SessionEvent[]): Transcri
  * the inbox claims or cancels them durably (`agent/inbox/spliced` removals,
  * `user/message` retirement), and an append-only `<Static>` flush cannot
  * erase a row that vanishes from the view — the retired row would ghost on
- * screen until the next source-backed replay. Everything else (including a
- * completed tail) is final: later events only APPEND new rows.
+ * screen until the next source-backed replay. Running commands join the
+ * mutable boundary for the same reason in reverse: `command/done` mutates the
+ * row's state/summary, so a flushed row would keep its stale running mark
+ * until a resize-triggered replay. Everything else (including a completed
+ * tail) is final: later events only APPEND new rows.
  * @param entries - the view's transcript entries in order.
  * @returns the count of entries safe to flush (0 for an empty transcript).
  */

package/lib/types/render/status.d.ts

@@ -9,7 +9,7 @@
  *
  * @module @deepseek-ai/dsh-tui/render/status
  */
-import type { ContextSegments, TranscriptStats } from './projection.ts';
+import type { TranscriptStats } from './projection.ts';
 /**
  * Compact token count: 517 / 12.2K / 517K / 1.2M (one decimal under three
  * digits), mirroring the web composer's StatsLine format.
@@ -40,7 +40,7 @@ export declare function cacheHitPercent(usage: TranscriptStats['usage']): number
  * Presentation tones for status spans; the footer maps each to a theme color
  * (Codex status-line accents: model/path/branch/state/usage categories).
  */
-export type StatusTone = 'model' | 'live' | 'path' | 'branch' | 'value' | 'label' | 'meta' | 'accent' | 'success' | 'warn' | 'error' | 'ctxSystem' | 'ctxPrompt' | 'ctxAssistant' | 'ctxThinking' | 'ctxTools';
+export type StatusTone = 'model' | 'live' | 'path' | 'branch' | 'value' | 'label' | 'meta' | 'accent' | 'success' | 'warn' | 'error' | 'ctxFill';
 /** One colored run inside the status bar. */
 export interface StatusSpan {
     text: string;
@@ -64,11 +64,9 @@ export interface StatusRow {
     hint: boolean;
 }
 /**
- * The footer layout: two stacked physical rows. Row 1 is the identity/state
- * row (busy dot, model, cwd, branch, plan, turns, tokens, title; goal,
- * sandbox, and permission badges). Row 2 is the run-meters row (mode, the
- * context progress bar, cache, and duration figures) and degrades to empty
- * before any row-1 content is touched.
+ * The footer layout: two stacked physical rows. Row 1 keeps the primary
+ * controls in model, cwd, mode, branch, context, permission order. Row 2
+ * carries every secondary session/run figure and degrades independently.
  */
 export interface StatusLayout {
     row1: StatusRow;
@@ -89,33 +87,21 @@ export declare const STATUS_CYCLE_HINT = " (shift+tab to cycle)";
 export declare const CONTEXT_BAR_WIDTH = 24;
 /** Occupancy at which the usage readout flips from brand blue to amber. */
 export declare const CONTEXT_WARN_PERCENT = 90;
-/** One content-type segment of the context bar (pure data; colors live in app.ts). */
-export interface ContextSegmentSpec {
-    key: keyof ContextSegments;
-    /** Tone the footer maps to a DeepSeek blue shade. */
-    tone: StatusTone;
-    /** Labels longest → shortest; the first one fitting the segment width wins. */
-    labels: readonly string[];
-}
-/** The five content types in conversation order, dark → light blue. */
-export declare const CONTEXT_SEGMENTS: readonly ContextSegmentSpec[];
-/**
- * Render context occupancy as a segmented bar: one DeepSeek-blue run per
- * content type (system/prompt/assistant/thinking/tools), column widths
- * proportional to their estimated token share, each with a centered label
- * that shortens to fit (system→sys→s). The remaining free tail is a dim
- * track whose right edge carries the usage readout (`12.3K/1.0M 25%`,
- * shrinking to the bare percent as the tail narrows). The readout flips to
- * amber once occupancy reaches the warning threshold; the segment blues stay
- * untouched so the composition remains readable at full context. The used
- * total comes from the reported `lastPromptTokens`, never from the estimates.
- * @param segments - estimated used tokens per content type.
+/**
+ * Render context occupancy as ONE stepless bar: a solid DeepSeek-blue fill
+ * run, a dim dotted free track, and the usage readout riding the track's
+ * right edge (`12.3K/1.0M 25%`, shrinking to the bare percent as the track
+ * narrows). No per-content-type segmentation. Column split is deterministic:
+ * the free share is `Math.round(free/window*width)` clamped to at least
+ * CONTEXT_MIN_FREE columns and at most the full width; the fill takes every
+ * remaining column, so a given occupancy always renders the identical bar.
+ * The readout flips to amber once occupancy reaches the warning threshold.
  * @param usedTokens - reported used tokens (drives the readout and percent).
  * @param contextWindow - route capacity.
  * @param width - total bar interior columns.
  * @returns tone-split spans for the footer to paint.
  */
-export declare function contextBar(segments: ContextSegments, usedTokens: number, contextWindow: number, width: number): readonly StatusSpan[];
+export declare function contextBar(usedTokens: number, contextWindow: number, width: number): readonly StatusSpan[];
 /**
  * One customizable status item (the Codex /statusline picker contract).
  * 'left' items render as pipe-separated clusters after the identity dot;
@@ -149,6 +135,12 @@ export declare const DEFAULT_STATUSLINE_ITEMS: readonly StatusItemId[];
  * @returns the normalized ordered item list.
  */
 export declare function parseStatuslineItems(value: unknown): readonly StatusItemId[];
+/**
+ * Extra left padding on the secondary row so its content aligns with the
+ * model name's left edge on the primary row (padding 2 + busy dot 2). The
+ * layout subtracts it from row 2's budget so the indent can never wrap it.
+ */
+export declare const STATUS_ROW2_INDENT = 2;
 /** Identity facts the runner resolves once at mount; empty strings drop out. */
 export interface StatusFacts {
     /** 'provider/model' selection serving this session. */
@@ -173,7 +165,7 @@ export interface StatusFacts {
     } | undefined;
     /** Whether plan mode is active (folded from 'plan/mode'). */
     plan: boolean;
-    /** Active permission preset (folded from 'permission/preset'), empty when unknown. */
+    /** Active or pending permission preset; empty only when the service is unavailable. */
     permission: string;
 }
 /**
@@ -185,12 +177,10 @@ export interface StatusFacts {
  */
 export declare function permissionTone(permission: string): StatusTone;
 /**
- * Compose the two-row footer layout under a column budget. Row 1 (identity
- * and state badges) degrades in a fixed order — cycle hint, then title, token
- * figures, turn/step counts, goal, divergent sandbox, permission badge — and
- * only then ellipsizes the identity cluster, so the row never wraps. Row 2
- * (mode, context bar, cache, duration figures) fits its own budget and
- * degrades to empty before any row-1 content is touched.
+ * Compose the two-row footer layout under a column budget. Row 1 keeps model,
+ * cwd, mode, branch, context, then the right-pinned permission badge and cycle
+ * hint. It drops hint, context, and permission before ellipsizing identity.
+ * Row 2 fits all secondary figures and state within its own budget.
  * @param facts - identity facts resolved by the runner.
  * @param stats - session figures folded from the durable log.
  * @param columns - usable columns for each row (before their left padding).

package/lib/types/render/text.d.ts

@@ -3,17 +3,21 @@
  * tool payloads, skill descriptions). Control characters — including ANSI
  * CSI/OSC escape sequences — would otherwise pass through Ink into the
  * terminal, letting output rewrite the screen or inject prompts. Newlines
- * and tabs survive; everything else in C0/C1 plus DEL becomes a visible
- * `\xNN` escape.
+ * survive; everything else in C0/C1 plus DEL becomes a visible `\xNN`
+ * escape, and bidi overrides / invisible format controls / Unicode line and
+ * paragraph separators become a visible `\uXXXX` escape (terminal emulators
+ * that render bidirectional text would otherwise reorder the displayed
+ * glyphs and let a command read as something it is not).
  *
  * @module @deepseek-ai/dsh-code/render/text
  */
 /**
- * Escape control characters so externally sourced text cannot drive the
- * terminal.
+ * Escape control and deceptive characters so externally sourced text cannot
+ * drive the terminal. C0/C1/DEL render as a literal `\xNN` escape; bidi,
+ * invisible-format, and separator controls render as a literal `\uXXXX`
+ * escape. Newlines and tabs survive (budgeted callers normalize tabs).
  * @param text - raw text from a session event, tool payload, or catalog.
- * @returns text with every control character (except `\n`, `\t`) rendered
- * as a literal `\xNN` escape.
+ * @returns display-safe text with every injectable character made visible.
  */
 export declare function displayText(text: string): string;
 /** Collapse external text to one terminal-safe logical row. */
@@ -36,7 +40,10 @@ export interface DisplayTail {
  * Keep only the newest display-safe text that fits a terminal rectangle.
  * The scan walks backward and stops as soon as the suffix is full, so a long
  * reasoning stream does not rescan its entire accumulated prefix per chunk.
- * Explicit newlines and terminal wrapping both consume rows.
+ * Explicit newlines and terminal wrapping both consume rows; tabs expand to
+ * two spaces so terminal tab stops (which render at contextual column 8
+ * boundaries, not at the budgeted cell count) cannot inflate the physical
+ * row count of the live region.
  * @param text - raw externally sourced text.
  * @param columns - available terminal columns.
  * @param rows - available terminal rows.

package/lib/types/render/tool-detail.d.ts

@@ -70,7 +70,9 @@ export type ToolDetail = {
  * Render one change as removed-then-added rows, hunked by common prefix and
  * suffix. A null before-image (file create) renders as pure additions. The
  * budget caps emitted rows and reports the cut, so a whole-file overwrite
- * never floods the transcript.
+ * never floods the transcript. Inputs are hard-capped before line splitting
+ * and the row list is built incrementally up to the budget — a crafted or
+ * replayed giant diff cannot force a full intermediate rows array.
  * @param oldText - prior content, or null for a create.
  * @param newText - content after the change.
  * @param budget - maximum rows to emit.

package/lib/types/render/tool-preview.d.ts

@@ -2,7 +2,10 @@
  * Bounded preview line for a tool invocation's raw JSON arguments: the first
  * human-meaningful string among the well-known keys (command, path, query, …)
  * with a fallback to the bounded raw JSON. Shared by the tool card in the
- * transcript and the approval bar's command preview.
+ * transcript and the approval bar's command preview. Arguments longer than
+ * {@link MAX_PARSE_CHARS} are never parsed: the preview is a display concern,
+ * and a synchronous `JSON.parse` plus string copies of an unbounded model
+ * payload must not run on the approval or projection paths.
  *
  * @module @deepseek-ai/dsh-code/render/tool-preview
  */
@@ -13,3 +16,13 @@
  * @returns the preview line; empty when nothing useful resolves.
  */
 export declare function toolArgumentsPreview(args: string, toolName: string): string;
+/**
+ * Bounded prompt preview for delegation-style tools (`subagent`): the
+ * `prompt` argument rendered as the card's second row, so the transcript
+ * shows what the child agent was asked — not just its description label —
+ * while it runs (Codex's SpawnAgent card preview). Anything else returns ''.
+ * @param toolName - the tool the arguments belong to.
+ * @param args - raw JSON arguments string as the model produced it.
+ * @returns the one-line prompt preview, or '' when none applies.
+ */
+export declare function toolPromptPreview(toolName: string, args: string): string;

package/lib/types/session-directory.d.ts

@@ -38,6 +38,8 @@ export interface SessionDirectoryOptions {
 export interface SessionRow {
     readonly id: string;
     readonly createdAt: number;
+    /** Last-activity timestamp: artifact mtime when known, else createdAt. */
+    readonly updatedAt: number;
     readonly cwd: string;
     readonly workspace: string;
     readonly parent?: string;
@@ -48,7 +50,64 @@ export interface SessionRow {
     readonly preset: string;
     readonly title?: string;
 }
-/** Filter/sort header-only records. No session log is loaded here. */
-export declare function projectSessionRows(records: readonly SessionRecord[], options: SessionDirectoryOptions): SessionRow[];
+/** True when the header describes a subagent conversation (durable lineage). */
+export declare function isSubagentSession(header: SessionHeader): boolean;
+/** Platform-consistent path equality for session cwd comparisons. */
+export declare function samePath(left: string | undefined, right: string): boolean;
+/**
+ * Unique header match by exact id or unique id prefix (root and subagent
+ * headers alike); the caller applies any lineage gate.
+ * @param headers - the persisted headers.
+ * @param wanted - the id or id prefix.
+ * @returns the uniquely matched header.
+ * @throws when nothing matches or the prefix is ambiguous.
+ */
+export declare function matchSessionId(headers: readonly SessionHeader[], wanted: string): SessionHeader;
+/** The newest persisted ROOT session pinned to this cwd, or undefined. */
+export declare function newestRootForCwd(headers: readonly SessionHeader[], cwd: string): SessionHeader | undefined;
+/**
+ * Filter/sort header-only records. No session log is loaded here. Sorting is
+ * by LAST ACTIVITY (`updated` — artifact mtime when the caller resolved one,
+ * else createdAt), matching the codex resume picker's default UpdatedAt
+ * ordering: a session you kept talking in outranks one created later but idle.
+ * @param records - the header-only records.
+ * @param options - filter/sort options.
+ * @param updated - per-session last-activity timestamps, when resolved.
+ */
+export declare function projectSessionRows(records: readonly SessionRecord[], options: SessionDirectoryOptions, updated?: ReadonlyMap<string, number>): SessionRow[];
 /** Merge page-local title observations without disturbing directory order. */
 export declare function mergeSessionTitles(rows: readonly SessionRow[], observations: readonly TitleObservationResult[]): SessionRow[];
+/**
+ * Encode a session id the way the JSONL backend does for its on-disk layout
+ * (`encodeSegment`: safe units literal, everything else `~XXXX`). Used ONLY to
+ * validate that a `locate()` path really is this session's directory before
+ * any deletion touches the filesystem — a local copy of the pure upstream
+ * contract, kept in sync with `session-persistence-jsonl/src/format.ts`.
+ */
+export declare function encodeSessionSegment(raw: string): string;
+/** The session-log artifact names the JSONL backend may create. */
+export declare const SESSION_ARTIFACT_NAMES: readonly string[];
+/**
+ * Guard one `locate()` artifact path before deletion (codex's scoped-path
+ * check, adapted to the JSONL layout): the file must be a `session.jsonl`
+ * artifact sitting in the directory named exactly `encodeSegment(id)`.
+ * @param artifact - the path the persistence backend located.
+ * @param id - the session id the artifact claims to belong to.
+ * @returns the owning session directory, or undefined when the layout is unexpected.
+ */
+export declare function sessionArtifactDirectory(artifact: string, id: string): string | undefined;
+/**
+ * Collect one session's deletion subtree: the id plus every record whose
+ * parent chain leads to it (codex deletes subagent threads with their root).
+ * @param records - the full directory listing.
+ * @param id - the root session id to delete.
+ * @returns the ids to delete, root first.
+ */
+export declare function collectDeletionSubtree(records: readonly SessionRecord[], id: string): string[];
+/**
+ * Codex-style relative time for session rows ("now", "5m ago", "3h ago",
+ * "2d ago"; older than a week falls back to the local date).
+ * @param timestamp - epoch milliseconds of the last activity.
+ * @param now - the pinned reference clock (one value per list render).
+ */
+export declare function formatRelativeTime(timestamp: number, now: number): string;

package/lib/types/store.d.ts

@@ -1,8 +1,19 @@
 /**
  * Observable transcript store: folds session events into the projection view
  * and notifies subscribers. The renderer subscribes through
- * `useSyncExternalStore`; the runner owns event feeding. The store owns no
- * timing — listeners fire synchronously after each applied event.
+ * `useSyncExternalStore`; the runner owns event feeding.
+ *
+ * Notification coalescing: the fold stays synchronous — `getView()` always
+ * returns the latest state the moment `apply` returns — but listener
+ * notification is scheduled on a microtask and deduplicated, so N events
+ * delivered inside one synchronous drain (the zai/GLM adapter drains its
+ * token buffer in sub-millisecond bursts) produce ONE React re-render.
+ * Synchronous per-event notification instead cascades one
+ * `useSyncExternalStore` force-update per token inside a single flush; the
+ * reconciler counts those as nested passive updates and floods React's
+ * "Maximum update depth exceeded" warning past 50 events, besides rendering
+ * the whole live tree once per token. A microtask keeps latency within the
+ * same macrotask, before Ink's throttled paint.
  *
  * @module @deepseek-ai/dsh-tui/store
  */

package/lib/types/subagents.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Live subagent activity feed: a bounded, display-only projection of CHILD
+ * session events. The transcript store folds only the root session (the
+ * durable truth this TUI renders); subagent conversations are their own
+ * sessions, and before this module their events were dropped entirely —
+ * a running subagent was invisible until its parent tool call settled.
+ *
+ * This is NOT a second transcript: each child folds to ONE row (label,
+ * running state, bounded last-activity text), capped at
+ * {@link MAX_SUBAGENT_ROWS}. Rows are advisory display state, rebuilt from
+ * live events; nothing here persists or replays. Notification is coalesced
+ * to one microtask per delivery burst, mirroring the transcript store's
+ * contract (per-token synchronous notify once cascaded past React's nested
+ * update limit on the GLM thinking path).
+ *
+ * @module @deepseek-ai/dsh-code/subagents
+ */
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+/** Hard row cap: a fan-out larger than this stays summarized by the head. */
+export declare const MAX_SUBAGENT_ROWS = 8;
+/** One live subagent row in the feed. */
+export interface SubagentRow {
+    /** Child session id. */
+    readonly id: string;
+    /** Display label (session title when observed, else a short id form). */
+    readonly label: string;
+    /** Coarse lifecycle state folded from the child's events. */
+    readonly state: 'running' | 'idle' | 'done';
+    /** Bounded last-activity text for the status line. */
+    readonly activity: string;
+    /** Last fold time (ms, event clock) — newest-first ordering key. */
+    readonly updatedAt: number;
+}
+/** The read-only snapshot surface the renderer subscribes to. */
+export interface SubagentFeedView {
+    /** Subscribe to feed changes; returns the unsubscribe function. */
+    subscribe(listener: () => void): () => void;
+    /** Read the current rows (identity-stable between changes). */
+    getSnapshot(): readonly SubagentRow[];
+}
+/**
+ * Fold one child-session event into its feed row (pure).
+ * Unknown event kinds leave the row untouched.
+ * @param previous - the row's current state, when any.
+ * @param sessionId - the child session id.
+ * @param event - the child session event.
+ * @returns the next row state.
+ */
+export declare function foldSubagentRow(previous: SubagentRow | undefined, sessionId: string, event: SessionEvent): SubagentRow;
+/**
+ * Create one subagent feed. `apply` folds a child event (the caller gates
+ * which sessions are children); `reset` clears on a session switch. Row
+ * order is first-seen; the snapshot array is frozen and only replaced when
+ * a row actually changed.
+ * @returns the mutable feed handle plus its `SubagentFeedView`.
+ */
+export declare function createSubagentFeed(): SubagentFeedView & {
+    apply(sessionId: string, event: SessionEvent): void;
+    reset(): void;
+};

package/lib/types/version.d.ts

@@ -0,0 +1,5 @@
+/** Installed dsh-code version exposed by the terminal header. */
+/** Read one package manifest version without making terminal startup depend on it. */
+export declare function readPackageVersion(manifest?: import("url").URL): string;
+/** Version of the installed dsh-code package. */
+export declare const DSH_CODE_VERSION: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-code",
   "description": "Claude-Code-style interactive TUI bundle for DeepSeek Harness (dsh): DeepSeek-blue whale banner, live session transcript, and a blended status line",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "type": "module",
   "bin": {
     "deepseek": "./bin/deepseek.mjs",