@toddzheng024/dscode-bundle 0.7.12 → 0.7.13

package/vendor/tui/types/session-directory.d.ts

@@ -1,190 +0,0 @@
-/** Lightweight session-directory projection for the /resume picker. */
-import { type SessionEvent, type SessionHeader } from '@deepseek-ai/dsh-session';
-export interface SessionRecord {
-    readonly header: SessionHeader;
-    readonly live: boolean;
-    readonly persisted: boolean;
-}
-export interface TitleObservationResult {
-    readonly sessionId: string;
-    readonly status: 'fulfilled' | 'rejected';
-    readonly value?: {
-        readonly title?: {
-            readonly title?: string;
-            readonly text?: string;
-        };
-    };
-}
-export interface SessionLogSnapshot {
-    readonly session: SessionHeader;
-    readonly events: SessionEvent[];
-}
-/** Structural upstream SessionQuery surface used by the TUI. */
-export interface SessionQueryService {
-    listSessions(signal?: AbortSignal): Promise<SessionRecord[]>;
-    readTitleSnapshots(ids: readonly string[], signal?: AbortSignal): Promise<TitleObservationResult[]>;
-    readSession(id: string, signal?: AbortSignal): Promise<SessionLogSnapshot>;
-    /** Cross-session full-text search (SQLite FTS engine; openAt may gate it). */
-    searchSessions(request: {
-        query: string;
-        limit?: number;
-    }, exec?: {
-        signal?: AbortSignal;
-    }): Promise<{
-        items: readonly {
-            header: SessionHeader;
-            live: boolean;
-            persisted: boolean;
-            bestMatch: {
-                snippet: string;
-                time: number;
-            };
-        }[];
-    }>;
-}
-export type SessionScope = 'roots' | 'all';
-export type CwdScope = 'all' | 'current';
-export type SessionSort = 'newest' | 'oldest';
-export interface SessionDirectoryOptions {
-    readonly sessions: SessionScope;
-    readonly cwd: CwdScope;
-    readonly sort: SessionSort;
-    readonly currentCwd: string;
-    readonly query: string;
-}
-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;
-    readonly subagent: boolean;
-    readonly resumable: boolean;
-    readonly live: boolean;
-    readonly persisted: boolean;
-    readonly preset: string;
-    readonly title?: string;
-}
-/** True only for delegated subagents; ordinary forks also carry lineage. */
-export declare function isSubagentSession(header: SessionHeader): 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 to
- * validate and derive session directories — 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;
-/**
- * Encode a project cwd the way the JSONL backend groups sessions on disk
- * (`projectKey`: separators collapse to one `-`, everything else mirrors
- * `encodeSegment`, bounded to 251 chars). A local copy of the pure upstream
- * contract, kept in sync with `session-persistence-jsonl/src/format.ts`.
- */
-export declare function encodeProjectKey(cwd: string): string;
-/**
- * Derive one session's artifact directory under the JSONL backend root,
- * mirroring the upstream `<root>/<projectKey(cwd)>/<encodeSegment(id)>/`
- * layout (0.1.5 `sessionDir`/`projectDir`).
- * @param root - the JSONL backend's configured session root.
- * @param cwd - the session's pinned working directory, when the header has one.
- * @param id - the session id.
- * @returns the absolute session directory path.
- */
-export declare function sessionDirectoryFor(root: string, cwd: string | undefined, id: string): string;
-/**
- * The canonical session-log artifact filenames the JSONL backend may create:
- * format v0 writes the bare `session.jsonl` name; v1+ write
- * `session.vN.jsonl`, each generation optionally zstd-compressed. Multiple
- * immutable generations may coexist in one session directory (0.1.5). The
- * range follows the installed session package's `SESSION_FORMAT_VERSION`, so
- * a future generation joins the enumeration with the dependency bump.
- */
-export declare function sessionArtifactNames(): readonly string[];
-/** True for one canonical session-log artifact filename the backend may own. */
-export declare function isSessionArtifactName(name: string): boolean;
-/**
- * Guard a derived session directory before deletion (codex's scoped-path
- * check, adapted to the JSONL layout): the directory's base name must be
- * exactly `encodeSegment(id)` beneath its project grouping.
- * @param dir - the derived session artifact directory.
- * @param id - the session id the directory claims to belong to.
- * @returns the guarded directory, or undefined when the layout is unexpected.
- */
-export declare function sessionArtifactDirectory(dir: string, id: string): string | undefined;
-/**
- * The JSONL backend's configured session root, when the mounted backend
- * exposes one. The upstream service contract dropped `locate()` in 0.1.5
- * (artifact paths are backend-private; only refusal diagnostics carry them),
- * so the TUI derives artifact paths from the backend's public plugin config.
- * Backends without a JSONL-style config (or a foreign shape) yield undefined
- * and callers degrade: mtime sorting falls back to createdAt and /delete
- * refuses, exactly as before.
- */
-export declare function jsonlSessionRoot(persistence: unknown): 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[];
-/** One validated node of a deletion plan. */
-export interface DeletionPlanNode {
-    /** Session id to remove. */
-    readonly id: string;
-    /** Distance from the deletion root (0 for the root itself). */
-    readonly depth: number;
-}
-/** A fully preflighted subtree deletion, or the refusal that produced none. */
-export type SessionDeletionPlan = {
-    readonly ok: true;
-    readonly nodes: readonly DeletionPlanNode[];
-} | {
-    readonly ok: false;
-    readonly reason: string;
-};
-/**
- * Plan one session-subtree deletion with NO filesystem side effects: collect
- * the doomed lineage, refuse when the root or ANY member is live (a live
- * child would outlive its deleted parent) or missing from the listing, and
- * order the result children-first so the executor can never leave a deleted
- * parent behind surviving children. Artifact-location guards stay at the
- * call site; this is the pure preflight they complete.
- * @param records - the full directory listing.
- * @param id - the root session id to delete.
- * @returns the ordered plan, or a user-facing refusal reason.
- */
-export declare function planSessionDeletion(records: readonly SessionRecord[], id: string): SessionDeletionPlan;
-/**
- * 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/vendor/tui/types/session-query.d.ts

@@ -1,92 +0,0 @@
-/**
- * Skip-tolerant session-query engine for this terminal.
- *
- * The upstream SqliteSessionQueryEngine reconciliation observes EVERY
- * persisted session before each search, and ONE unreadable source (for
- * example a pre-release session artifact the frozen format codecs reject)
- * fails the whole pass with SESSION_QUERY_PERSISTENCE_FAILED — every
- * cross-session search dies because of a single old file nobody opened
- * otherwise. This subclass overrides only the observation loop so an
- * unreadable source is skipped with a warning and the rest of the corpus
- * indexes normally; skipped sessions are retried on later reconciliations
- * and rejoin automatically once a host that can read them is installed.
- *
- * Vendored surface note: `_observeStable` and its module-local helpers are
- * private upstream; this file re-declares the observation loop against the
- * pinned @deepseek-ai line (see package.json peers) and must be re-checked
- * whenever that line moves. The engine class and the tool boundary also
- * share ONE physical parent-package instance through this bundle, which
- * restores instanceof-based typed error messages on the search path.
- */
-import SqliteSessionQueryEngine, { type Config } from '@deepseek-ai/dsh-session-query-sqlite';
-import { buildSessionEventSearchDocuments } from '@deepseek-ai/dsh-session-query';
-import type { SessionEvent, SessionHeader, SessionId, SessionLogOffset } from '@deepseek-ai/dsh-session';
-import type { SessionPersistenceRevision, SessionPersistenceSnapshot } from '@deepseek-ai/dsh-session-persistence';
-/** One observed session: detached header plus its derived search documents. */
-interface ObservedSession {
-    header: SessionHeader;
-    inheritedEventCount: SessionLogOffset;
-    documents: readonly ReturnType<typeof buildSessionEventSearchDocuments>[number][];
-    fingerprint: string;
-}
-/** One persisted snapshot as the reconciliation sees it (loaded once readable). */
-interface ObservedPersistedSession {
-    header: SessionHeader;
-    revision: SessionPersistenceRevision;
-    loaded?: ObservedSession;
-    /** Diagnosis for a cold read that failed; the session stays unindexed. */
-    unreadable?: string;
-}
-/** The engine-internal state the observation loop touches. */
-export interface EngineSurface {
-    readonly ctx: {
-        sessions: {
-            list(): readonly {
-                header: SessionHeader;
-                inheritedEventCount: SessionLogOffset;
-                snapshotEvents(): readonly SessionEvent[];
-                id: SessionId;
-            }[];
-            get(id: SessionId): unknown;
-        };
-        logger?: {
-            warn(format: string, ...args: readonly unknown[]): void;
-        };
-    };
-    readonly _persistenceBinding: {
-        readonly identity: symbol;
-        readonly service?: {
-            list(options?: {
-                readonly signal?: AbortSignal;
-            }): Promise<readonly SessionPersistenceSnapshot[]>;
-        };
-    };
-    _lastPersistenceIdentity: symbol | undefined;
-}
-type ColdRead = (persistence: NonNullable<EngineSurface['_persistenceBinding']['service']>, id: SessionId, signal: AbortSignal | undefined) => Promise<{
-    header: SessionHeader;
-    inheritedEventCount: SessionLogOffset;
-    events: readonly SessionEvent[];
-}>;
-/**
- * The skip-tolerant observation pass: structurally the upstream loop, with
- * the per-source cold read wrapped so one unreadable session degrades to a
- * warning instead of failing every search. Exported for unit tests with an
- * injectable cold reader.
- */
-export declare function observeStableWithSkip(engine: EngineSurface, indexed: ReadonlyMap<SessionId, {
-    revision: SessionPersistenceRevision;
-}>, signal: AbortSignal | undefined, readCold?: ColdRead): Promise<{
-    persistenceBinding: EngineSurface['_persistenceBinding'];
-    persisted: Map<SessionId, ObservedPersistedSession>;
-    live: Map<SessionId, ObservedSession>;
-}>;
-declare const EngineBase: abstract new (ctx: never, config: Config) => EngineSurface & object;
-/** The engine this bundle mounts in place of the base `session-query-sqlite` row. */
-export declare class SkipTolerantSessionQueryEngine extends EngineBase {
-    _observeStable(indexed: ReadonlyMap<SessionId, {
-        revision: SessionPersistenceRevision;
-    }>, signal: AbortSignal | undefined): Promise<unknown>;
-}
-declare const _default: typeof SqliteSessionQueryEngine;
-export default _default;

package/vendor/tui/types/session-switch.d.ts

@@ -1,17 +0,0 @@
-/** Latest-wins, idle-bound queue for safe Agent session changes. */
-export interface IdleActivity {
-    readonly status: 'idle' | 'running';
-    whenIdle(): Promise<void>;
-}
-export declare class SessionSwitchQueue<T> {
-    private readonly execute;
-    private readonly failed;
-    private pending;
-    private pumping;
-    constructor(execute: (value: T) => Promise<void>, failed: (error: unknown) => void);
-    /** Queue a request; a later request replaces any request still waiting. */
-    request(activity: IdleActivity, value: T): 'queued' | 'started';
-    /** Cancel only work that has not begun activation. */
-    cancel(): boolean;
-    private pump;
-}

package/vendor/tui/types/settings-file.d.ts

@@ -1,41 +0,0 @@
-/**
- * Serialized, crash-atomic persistence for the small user-level JSON files
- * under the DSH home (statusline.json, theme.json). Two guarantees the bare
- * floating `writeFile` path could not give:
- *
- * 1. Every save is appended to ONE chain, so rapid consecutive edits land
- *    in submission order and the last snapshot is the one on disk (parallel
- *    floating writes let an older snapshot finish last and win).
- * 2. Each write goes to a sibling temp file first and is renamed into
- *    place, so a crash mid-write can never leave a half-written JSON
- *    document behind.
- *
- * The chain itself never rejects: a failed write is reported to that
- * save's caller while later saves keep their turn.
- *
- * @module @deepseek-ai/dsh-code/settings-file
- */
-/**
- * Write one file atomically: create the parent directory, write to a
- * uniquely named temp file, and rename it into place. A crash midway
- * can never leave a half-written document behind. Unique temp names
- * keep concurrent writers (two terminals, two chains in one process)
- * from sharing one temp path.
- */
-export declare function writeFileAtomically(path: string, text: string): Promise<void>;
-/** The serialized persistence surface; flush() is handed to the quit sequence. */
-export interface UserSettingsPersistence {
-    /**
-     * Queue one file snapshot. Resolves when the chain reaches (and renames)
-     * it; rejects only to THIS caller when its own write failed.
-     */
-    save(path: string, text: string): Promise<void>;
-    /** Wait for every queued write; safe to call repeatedly. */
-    flush(): Promise<void>;
-}
-/**
- * Create the shared settings-write chain. One instance per process keeps
- * every user-level JSON file mutually serialized.
- * @returns the persistence handle.
- */
-export declare function createUserSettingsPersistence(): UserSettingsPersistence;

package/vendor/tui/types/skills.d.ts

@@ -1,47 +0,0 @@
-/**
- * User-invocable skill watch for the `/` completion menu: the in-process
- * equivalent of the web ui-skill trigger source. Skills are NOT commands —
- * picking one lands the literal `/name ` text in the input, and submitting
- * it as a normal prompt lets the host's tool-skill pre-step inject the body
- * (the only entry point for model-disabled skills). Command descriptors win
- * on a name collision; see the runner's dispatch.
- *
- * @module @deepseek-ai/dsh-code/skills
- */
-import type { Context } from '@deepseek-ai/cordis';
-import type { Agent } from '@deepseek-ai/dsh-agent';
-/** One completion-menu row derived from a user-invocable skill. */
-export interface SkillRow {
-    /** Skill name; the literal `/name` text is what a pick lands. */
-    name: string;
-    /** Human-readable description (suffixed when model-invocation is off). */
-    description: string;
-    /** Whether the model may also invoke this skill by name. */
-    modelInvocable: boolean;
-}
-/** The skill-catalog snapshot the completion menu subscribes to. */
-export interface SkillsView {
-    /** Name-sorted user-invocable rows; empty until the first load lands. */
-    readonly rows: readonly SkillRow[];
-    /** Latest catalog-read failure; the help panel exposes it in place. */
-    readonly error?: string;
-    /** Subscribe to catalog changes; returns the unsubscribe function. */
-    subscribe(listener: () => void): () => void;
-    /** Retarget the agent whose workspace the catalog is read for. */
-    setAgent(agent: Agent): void;
-}
-/** Internal shape shared by {@link watchSkills} and its test doubles. */
-interface SkillsWatch extends SkillsView {
-    setAgent(agent: Agent): void;
-}
-/**
- * Watch the user-invocable skill catalog for one agent's workspace. The first
- * load starts when the owning agent is known (`setAgent`); `skills/change`
- * and agent retargets re-read. Read failures keep the last good rows (the
- * next change notification is the retry surface) — a missing `skills`
- * service leaves the view permanently empty.
- * @param ctx - context carrying the `skills` service (optional).
- * @returns the view the completion menu subscribes to.
- */
-export declare function watchSkills(ctx: Context, fallbackCwd?: string): SkillsWatch;
-export {};

package/vendor/tui/types/startup.d.ts

@@ -1,65 +0,0 @@
-/**
- * The interactive terminal app's command-line provider: parses `--resume`,
- * `--continue`, `--session`, `--mode`, `--theme`, `--image`, an optional
- * initial prompt, and `--help`, then
- * publishes {@link TUI_STARTUP_SERVICE} for the runner to consume lazily.
- * Follows the headless bundle's startup shape (a commander action publishing
- * a service through {@link parseCmdline}).
- *
- * Semantics:
- * - `--resume <id|prefix>` — continue the persisted session whose id or unique
- *   id-prefix matches; the TUI replays its transcript and appends to the same
- *   durable log.
- * - `--continue` / `-c` — resume the most recently modified persisted session
- *   whose project directory matches the current working directory.
- * - `--session <id>` — create a new session under an explicit identity (the
- *   id must not exist yet).
- * - `--theme <dark|light|prismatic|rainbow|auto>` — the color palette; auto follows the
- *   terminal (dark fallback until OSC-11 detection lands).
- * - no flags — a fresh session with a minted id.
- *
- * @module @deepseek-ai/dsh-tui/startup
- */
-import type { Context } from '@deepseek-ai/cordis';
-import { type ThemeName } from './theme.ts';
-/** Stable Cordis plugin name. */
-export declare const name = "tui-startup";
-/** Services required before the invocation can be resolved. */
-export declare const inject: string[];
-/** How the runner obtains its session identity. */
-export type TuiStartup = ({
-    readonly kind: 'fresh';
-    readonly mode?: string;
-} & TuiStartupInput) | ({
-    readonly kind: 'named';
-    readonly sessionId: string;
-    readonly mode?: string;
-} & TuiStartupInput) | ({
-    readonly kind: 'resume';
-    readonly sessionId: string;
-} & TuiStartupInput) | ({
-    readonly kind: 'latest';
-} & TuiStartupInput);
-interface TuiStartupInput {
-    readonly theme?: ThemeName;
-    readonly prompt?: string;
-    readonly images?: readonly string[];
-}
-export interface TuiStartupOptions {
-    readonly resume?: string;
-    readonly continue?: boolean;
-    readonly session?: string;
-    readonly mode?: string;
-    readonly theme?: ThemeName;
-    readonly prompt?: string;
-    readonly images?: readonly string[];
-}
-/** Pure option policy shared by Commander and tests. */
-export declare function resolveTuiStartup(options: TuiStartupOptions): TuiStartup;
-/**
- * Parse the invocation and publish the startup service. Mutual exclusions are
- * usage errors rejected from the action before anything is provided.
- * @param ctx - plugin context carrying the command line and exit request.
- */
-export declare function apply(ctx: Context): void;
-export {};

package/vendor/tui/types/store.d.ts

@@ -1,58 +0,0 @@
-/**
- * Observable transcript store: folds session events into the projection view
- * and notifies subscribers. The renderer subscribes through
- * `useSyncExternalStore`; the runner owns event feeding.
- *
- * Folding runs on the same mutable replay accumulator the persisted-log
- * path uses (`replayProjectEvent`: id-indexed row updates, in-place
- * appends), so a live structural event costs O(1) entry work regardless of
- * transcript length — the copy-on-write fold rebuilt the whole entries
- * array per event, making a growing session quadratic. An immutable
- * `TranscriptView` snapshot is materialized only when a changed view is
- * READ (once per rendered frame under the notification throttle, never per
- * event), and every snapshot copies its arrays, so a view already handed
- * out never observes later folds.
- *
- * Notification coalescing: the fold stays synchronous — `getView()` always
- * returns the latest state the moment `apply` returns — but listener
- * notification is frame-throttled (~16ms) and deduplicated. The zai/GLM
- * adapter delivers tokens as a sustained stream of sub-millisecond,
- * microtask-spaced bursts: per-burst notification renders at microtask
- * cadence, which chained SyncLane `useSyncExternalStore` rerenders past
- * React's nested-update limit ("Maximum update depth exceeded"), while a
- * bare `setImmediate` merges a whole macrotask turn's bursts into one
- * chunky repaint (streaming text visibly staggers). The frame budget gives
- * both: an event ≥16ms after the last paint notifies via `setImmediate`
- * (sub-millisecond latency for sparse/first tokens), and anything denser
- * defers to the next 16ms boundary — a 60fps render cap that also breaks
- * the nesting chain by construction.
- *
- * @module @deepseek-ai/dsh-tui/store
- */
-import type { AssistantStreamFrame } from '@deepseek-ai/dsh-agent';
-import type { SessionEvent } from '@deepseek-ai/dsh-session';
-import { type TranscriptView } from './render/projection.ts';
-/** The externally readable, event-fed transcript store for one session. */
-export interface TranscriptStore {
-    /** The current view; the same object identity until an event changes it. */
-    getView(): TranscriptView;
-    /** Subscribe to view changes; returns the unsubscribe function. */
-    subscribe(listener: () => void): () => void;
-    /** Fold one session event; ignored events change nothing and notify nobody. */
-    apply(event: SessionEvent): void;
-    /** Fold one live assistant-stream frame; frames without visible deltas stay silent. */
-    applyStreamFrame(frame: AssistantStreamFrame): void;
-    /** Drop the folded view entirely (/clear): the next event starts a fresh one. */
-    reset(): void;
-}
-/**
- * Create one transcript store, optionally seeded with replayed history. The
- * seed folds synchronously BEFORE the first render, so a resumed session
- * paints its full transcript on mount (no live `session/event` fires for
- * constructor seeds — the store's `session/event` feed only carries new
- * appends).
- * @param replay - persisted events in `seq` order (e.g. a resumed session's
- * constructor seed); folded once and never re-notified.
- * @returns the store the runner feeds and the renderer subscribes to.
- */
-export declare function createTranscriptStore(replay?: readonly SessionEvent[]): TranscriptStore;

package/vendor/tui/types/subagents.d.ts

@@ -1,70 +0,0 @@
-/**
- * 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}. The cap is a display budget, not a fan-out
- * limit: a new running child evicts the OLDEST settled row when one
- * exists, and while every row is busy the newcomer waits off-screen — but
- * the observed-session total (getTotalSeen) keeps counting, so status
- * totals never under-report the fan-out. Rows are advisory display
- * state, rebuilt from live events; nothing here persists or replays.
- * Notification is coalesced
- * by the same ~16ms frame throttle as the transcript store (per-burst
- * microtask notify chained SyncLane rerenders past React's nested update
- * limit; a bare macrotask merge repaints a whole turn's bursts at once).
- *
- * @module @deepseek-ai/dsh-code/subagents
- */
-import type { SessionEvent } from '@deepseek-ai/dsh-session';
-/** Hard row cap: overflow evicts the oldest settled row; a fully busy feed waits. */
-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[];
-    /**
-     * Distinct child sessions observed since the last reset. The row cap is
-     * a display budget, not a count of the fan-out; totals surface this.
-     */
-    getTotalSeen(): number;
-}
-/**
- * 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/vendor/tui/types/terminal-title.d.ts

@@ -1,66 +0,0 @@
-/**
- * Terminal tab/window title management for the TUI.
- *
- * Terminals label their tab from the window title, which an application sets
- * with an OSC 0 sequence; without one the tab shows the process name ("node").
- * The title text is untrusted display content (session names arrive through
- * events and user input), so it is sanitized before emission: control
- * characters and bidi/invisible formatting codepoints are stripped, whitespace
- * runs collapse to single spaces, and the result is bounded. Clearing writes
- * an empty OSC payload and the terminal falls back to its own default; the
- * previously set title is not portable to read back and is never restored.
- *
- * @module @deepseek-ai/dsh-code/terminal-title
- */
-/** Tab label before a session carries a name. */
-export declare const DEFAULT_TERMINAL_TITLE = "deepseek";
-/** Practical upper bound on title length, in visible characters: long enough
- * for session names, short enough for tab bars and window managers. */
-export declare const MAX_TERMINAL_TITLE_CHARS = 240;
-/** Normalize untrusted title text into one bounded display line: disallowed
- * codepoints dropped, whitespace runs collapsed to single spaces, leading and
- * trailing whitespace removed, length bounded. */
-export declare function sanitizeTerminalTitle(text: string): string;
-/** Build one OSC 0 title sequence. An empty sanitized title yields an empty
- * string: emitting nothing is distinct from clearing, which is a separate
- * policy decision made by the caller. */
-export declare function terminalTitleSequence(text: string): string;
-/** Clear the managed title with an empty OSC payload; the terminal falls back
- * to its own default label. */
-export declare function clearTerminalTitleSequence(): string;
-/**
- * Resolve the VS Code stable user-settings file for one platform and
- * environment: `%APPDATA%` on Windows, the bundle data folder on macOS (NOT
- * XDG `~/.config` — VS Code never reads that path there, so writing it
- * silently no-ops and the tab kept showing the process name "node"), and
- * XDG config on Linux.
- */
-export declare function vscodeSettingsPath(platform: NodeJS.Platform, env: NodeJS.ProcessEnv): string | undefined;
-/** Outcome of the VS Code settings alignment. */
-export interface VsCodeTitleSettingResult {
-    wrote: boolean;
-    reason?: 'not-vscode' | 'unparseable' | 'key-present' | 'error';
-}
-/** VS Code renders an application-set tab title only when
- * "terminal.integrated.tabs.title" maps to the sequence variable; the editor
- * default shows the process name instead ("node" for a Node CLI). Inside a VS
- * Code integrated terminal, align the user settings once: if the key is
- * absent, insert it and keep a one-shot backup of the original file. A value
- * the user already set is never overwritten, an unparseable file is never
- * touched, and every failure degrades to a no-op - the OSC and process-title
- * channels keep working everywhere else. */
-export declare function ensureVsCodeTabTitleSetting(options?: {
-    env?: NodeJS.ProcessEnv;
-    settingsFile?: string;
-    isTTY?: boolean;
-}): VsCodeTitleSettingResult;
-/**
- * Keep the terminal tab label on `title` (sanitized; empty titles leave the
- * current label alone). Two delivery channels run in parallel: the OSC 0
- * sequence to stdout, and the host process title. Writes are deduplicated by
- * title, and on unmount the managed title is cleared and the process title
- * restored so the host shell regains its default label.
- */
-export declare function useTerminalTitle(title: string, options?: {
-    clearOnUnmount?: boolean;
-}): void;