dsh-code 1.0.5 → 1.0.7

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

@@ -6,7 +6,8 @@
  *
  * @module @deepseek-ai/dsh-tui/render/projection
  */
-import { type ImageBlock, type MessageId } from '@deepseek-ai/dsh-llm';
+import { type ImageBlock, type MessageId, type StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { FileAttachmentRef } from '@deepseek-ai/dsh-attachment';
 import type { SessionEvent } from '@deepseek-ai/dsh-session';
 import type { TodoItem } from '@deepseek-ai/dsh-tool-todo';
 import { type ToolDetail } from './tool-detail.ts';
@@ -20,6 +21,8 @@ export interface UserEntry {
     notice: boolean;
     /** Durable image references carried by this prompt. */
     images?: readonly ImageBlock['attachment'][];
+    /** Durable file references carried by this prompt (0.1.5 file blocks). */
+    files?: readonly FileAttachmentRef[];
 }
 /** One user message waiting in the agent inbox (the web's queued-message row). */
 export interface PendingEntry {
@@ -32,6 +35,8 @@ export interface PendingEntry {
     text: string;
     /** Durable image references queued with this prompt. */
     images?: readonly ImageBlock['attachment'][];
+    /** Durable file references queued with this prompt (0.1.5 file blocks). */
+    files?: readonly FileAttachmentRef[];
 }
 /** One authoritative assembled assistant reply. */
 export interface AssistantEntry {
@@ -214,11 +219,43 @@ export interface TranscriptStats {
      */
     reasoningEffort: string;
 }
+/** One active reminder folded from durable `schedule/change` events. */
+export interface ScheduleRow {
+    readonly id: string;
+    readonly kind: 'after' | 'at' | 'every';
+    readonly prompt: string;
+    /** Next due time (epoch ms); the /schedule panel derives overdue/relative labels. */
+    readonly targetAt: number;
+    /** Recurrence seconds for 'every' rows, undefined otherwise. */
+    readonly everySeconds?: number;
+}
+/**
+ * The durable `schedule/change` payload shape this fold consumes. Upstream
+ * strict-decodes the whole transition stream before appending, so unknown
+ * ids here are corrupt-input edges that degrade to a no-op.
+ */
+export interface ScheduleChangeLike {
+    readonly operation: 'create' | 'delete' | 'dispatch';
+    readonly schedule?: {
+        readonly id: string;
+        readonly kind: 'after' | 'at' | 'every';
+        readonly prompt: string;
+        readonly afterSeconds?: number;
+        readonly everySeconds?: number;
+        readonly scheduledAt: string;
+    };
+    readonly id?: string;
+    readonly acceptedAt?: string;
+}
+/** Fold one `schedule/change` into the active-reminder list (create/delete/dispatch). */
+export declare function applyScheduleChange(rows: readonly ScheduleRow[], data: ScheduleChangeLike): readonly ScheduleRow[];
+/** First anchor-aligned target after `acceptedAt`, stepping from the previous aligned target. */
+export declare function nextEveryTarget(previousTarget: number, acceptedAt: number, everySeconds: number): number;
 /** The complete TUI transcript view for one session. */
 export interface TranscriptView {
     /** Settled entries in log order. */
     entries: readonly TranscriptEntry[];
-    /** Bounded text tail accumulated from `assistant/chunk` deltas since the last flush. */
+    /** Bounded text tail accumulated from live stream frames since the last settlement. */
     streaming: string;
     /** Bounded thinking tail accumulated from reasoning deltas since the last flush. */
     streamingReasoning: string;
@@ -249,10 +286,19 @@ export interface TranscriptView {
     permission: string;
     /** Latest session title folded from the last `session/title` event, empty before one. */
     title: string;
+    /**
+     * Effective system prompt assembled from `system/message` surface nodes
+     * (v3): the head node's text joined with every later non-empty node, blank
+     * lines between. Empty before the first system node or when every node is
+     * empty ("no system prompt").
+     */
+    systemPrompt: string;
     /** Sandbox-mode override folded from the last `sandbox/mode` event, empty when never switched. */
     sandbox: string;
     /** Current long-running goal folded from the last `goal/change`, undefined when cleared. */
     goal: GoalFold | undefined;
+    /** Active reminders folded from `schedule/change` events, oldest target first at render. */
+    schedules: readonly ScheduleRow[];
     /**
      * Ordered live message ids per inbox target, mirrored from
      * `agent/inbox/spliced` exactly like the upstream Inbox projection — the
@@ -279,12 +325,16 @@ export interface TranscriptView {
         turnFiles: Map<number, Set<string>>;
         turnSteps: Map<number, string>;
         turnTools: Map<number, Set<string>>;
+        /** Live `system/message` surface nodes by event seq (empty string = an empty node). */
+        systemNodes: Map<number, string>;
     };
 }
 /** Human-readable bounded image labels for transcript, inspector, and export surfaces. */
 export declare function imageLabels(images: readonly ImageBlock['attachment'][] | undefined): string;
-/** Prompt text with its durable image labels, without exposing local paths or bytes. */
-export declare function promptDisplayText(entry: Pick<UserEntry | PendingEntry, 'text' | 'images'>): string;
+/** Human-readable bounded file labels for the same surfaces (0.1.5 file blocks). */
+export declare function fileLabels(files: readonly FileAttachmentRef[] | undefined): string;
+/** Prompt text with its durable image and file labels, without exposing local paths or bytes. */
+export declare function promptDisplayText(entry: Pick<UserEntry | PendingEntry, 'text' | 'images' | 'files'>): string;
 /** A fresh, empty transcript view. */
 export declare function createTranscriptView(): TranscriptView;
 /**
@@ -341,8 +391,10 @@ export interface ReplayAccumulator {
     plan: boolean;
     permission: string;
     title: string;
+    systemPrompt: string;
     sandbox: string;
     goal: GoalFold | undefined;
+    schedules: readonly ScheduleRow[];
     stats: TranscriptStats;
     stepStart: Map<string, number>;
     toolStart: Map<string, number>;
@@ -352,6 +404,8 @@ export interface ReplayAccumulator {
     turnFiles: Map<number, Set<string>>;
     turnSteps: Map<number, string>;
     turnTools: Map<number, Set<string>>;
+    /** Live `system/message` surface nodes by event seq (empty string = an empty node). */
+    systemNodes: Map<number, string>;
     /** Entry-level container operations performed so far (test instrumentation). */
     ops: number;
 }
@@ -400,6 +454,28 @@ export declare function snapshotReplayView(acc: ReplayAccumulator): TranscriptVi
  * @returns the folded view.
  */
 export declare function projectEvents(events: readonly SessionEvent[]): TranscriptView;
+/**
+ * Fold one process-local assistant-stream chunk frame (session-log v2+ keeps
+ * durable logs settlement-only; live typing rides the `agent/assistant-stream`
+ * agent event). Same first-token anchoring the durable `assistant/chunk` event
+ * used to carry: the first non-empty delta anchors the TTFT and empty
+ * keep-alive deltas do not count. The caller maps the frame's attempt to the
+ * `turn:step` key (the start frame owns turn/step; chunk frames do not).
+ * @param acc - the live replay accumulator.
+ * @param key - the `turn:step` key the attempt's start frame declared.
+ * @param time - the frame's safe-integer timestamp.
+ * @param chunk - the model chunk the frame carries.
+ * @returns whether the accumulator changed (the store stays silent otherwise).
+ */
+export declare function applyAssistantStreamChunk(acc: ReplayAccumulator, key: string, time: number, chunk: StreamChunk): boolean;
+/**
+ * Drop the live streaming tails without a settlement (an `agent/assistant-stream`
+ * end frame with an `abandoned` outcome, or a session switch). The next start
+ * frame rebuilds from scratch.
+ * @param acc - the live replay accumulator.
+ * @returns whether any tail text was discarded.
+ */
+export declare function clearAssistantStream(acc: ReplayAccumulator): boolean;
 /**
  * The append-only flush boundary for a transcript view: the count of entries
  * no later event can remove. Entries at or beyond this index are mutable and

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

@@ -33,7 +33,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' | 'ctxFill';
+export type StatusTone = 'model' | 'live' | 'path' | 'branch' | 'value' | 'label' | 'meta' | 'accent' | 'success' | 'plan' | 'warn' | 'error' | 'ctxFill';
 /** One colored run inside the status bar. */
 export interface StatusSpan {
     text: string;

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

@@ -1,5 +1,5 @@
 /** Lightweight session-directory projection for the /resume picker. */
-import type { SessionEvent, SessionHeader } from '@deepseek-ai/dsh-session';
+import { type SessionEvent, type SessionHeader } from '@deepseek-ai/dsh-session';
 export interface SessionRecord {
     readonly header: SessionHeader;
     readonly live: boolean;
@@ -77,23 +77,58 @@ export declare function projectSessionRows(records: readonly SessionRecord[], op
 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
+ * (`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;
-/** 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.
+ * 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 sessionArtifactDirectory(artifact: string, id: string): string | undefined;
+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).

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

@@ -0,0 +1,92 @@
+/**
+ * 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/lib/types/store.d.ts

@@ -29,6 +29,7 @@
  *
  * @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. */
@@ -39,6 +40,8 @@ export interface TranscriptStore {
     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;
 }

package/lib/types/terminal-title.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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;
+/** 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;

package/lib/types/update-panel.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The /update panel: one bounded surface over the launcher update
+ * pipeline. The panel never decides versions itself — it renders the
+ * launcher `update --json` probe (plan plus refusals), takes one
+ * confirmation, then streams `update --apply` progress and reports the
+ * result with a restart hint. Every alignment guarantee (host pinned to
+ * the release peers line, companion plugins carried, downgrade and
+ * local-checkout refusals) lives in the launcher and is only displayed
+ * here.
+ */
+import { type ReactElement } from 'react';
+import type { LauncherUpdateStatus } from './update.ts';
+/** Retained apply-progress lines (ring tail; npm output is ephemeral). */
+export declare const UPDATE_OUTPUT_CAP = 800;
+/** Keep the newest UPDATE_OUTPUT_CAP lines of streamed update output. */
+export declare function clipUpdateLines(lines: readonly string[]): readonly string[];
+/** One display row of the update surface. */
+export interface UpdateRow {
+    readonly key: string;
+    readonly text: string;
+    readonly tone?: 'ok' | 'warn' | 'error' | 'dim';
+}
+/** The plan view derived from one probe: facts to show and whether apply may run. */
+export interface UpdatePlanView {
+    readonly rows: readonly UpdateRow[];
+    readonly runnable: boolean;
+}
+/** Rendered facts of one probe: current/target versions, actions, refusals. */
+export declare function updatePlanView(status: LauncherUpdateStatus): UpdatePlanView;
+/** Panel lifecycle phases; the footer names the keys each phase accepts. */
+export type UpdatePhase = 'probe' | 'error' | 'plan' | 'apply' | 'done';
+/** Footer hint line per phase; the plan phase names the confirm key only when runnable. */
+export declare function updateFooter(phase: UpdatePhase, runnable: boolean, upToDate: boolean): string;
+/**
+ * The /update surface: probe on open (and on r), confirm with enter/y,
+ * stream the aligned apply, and land on a bounded result view. Escape is
+ * locked while the apply child runs — killing npm mid-install is exactly
+ * the half-updated state this command exists to prevent.
+ */
+export declare function UpdatePanel({ probe, apply, close, notify }: {
+    /** Read-only probe of the launcher update status (never installs). */
+    probe(): Promise<LauncherUpdateStatus>;
+    /** Run the aligned update; streams sanitized progress lines. */
+    apply(onLine: (line: string) => void): Promise<number>;
+    /** Close the panel (App keeps ownership of the flag). */
+    close(): void;
+    /** One bounded cross-surface notice (phase completions). */
+    notify(text: string, tone?: 'info' | 'warning' | 'error'): void;
+}): ReactElement;

package/lib/types/update.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Child-process adapter for the launcher update pipeline. The launcher
+ * (bin/deepseek.mjs) stays the single owner of update semantics — plan,
+ * guards, and the aligned install sequence — so the TUI only spawns
+ * `update --json` (read-only probe) and `update --apply` (streamed run)
+ * and never re-implements version-line decisions.
+ */
+import { type ChildProcess } from 'node:child_process';
+/** Spawn double acceptable to the adapter (tests inject an EventEmitter). */
+export type SpawnLike = (command: string, args: readonly string[], options: {
+    readonly stdio: readonly string[];
+    readonly windowsHide: boolean;
+}) => ChildProcess;
+/** Structured `update --json` payload; mirrors the launcher buildUpdateStatus. */
+export interface LauncherUpdateStatus {
+    readonly code: {
+        readonly running: string;
+        readonly latest: string | null;
+    };
+    readonly host: {
+        readonly installed: string | null;
+        readonly targetLine: string | null;
+    };
+    readonly profile: {
+        readonly spec: string | null;
+        readonly mounted: string | null;
+        readonly localCheckout: boolean;
+    };
+    readonly plan: {
+        readonly dshSpec: string;
+        readonly codeSpec: string;
+        readonly pluginSpecs: readonly string[];
+    };
+    readonly blockers: {
+        readonly registry: string | null;
+        readonly downgrade: boolean;
+        readonly localCheckout: readonly string[] | null;
+    };
+    readonly upToDate: boolean;
+}
+/** The launcher entrypoint that ships beside this bundle (lib/../bin). */
+export declare function launcherUpdateCommand(args: readonly string[], moduleUrl?: string): {
+    readonly command: string;
+    readonly args: string[];
+};
+/**
+ * Split a streamed chunk sequence into complete display lines: CR is
+ * stripped, a chunk boundary may split a line, and the trailing partial
+ * stays pending until its newline arrives (npm writes whole lines, but a
+ * pipe may cut anywhere). Blank lines carry no progress information and
+ * are dropped so the panel budget is not spent on gaps.
+ */
+export declare function createLineSplitter(onLine: (line: string) => void): (chunk: string) => void;
+/**
+ * Probe the aligned update status. Read-only: `update --json` never
+ * installs anything. The probe is bounded (npm view may hang on a broken
+ * network) and resolves with the parsed status.
+ */
+export declare function probeLauncherUpdate(spawnProcess?: SpawnLike): Promise<LauncherUpdateStatus>;
+/**
+ * Run the aligned update (`update --apply`) as a child process and stream
+ * its sanitized progress lines to the caller. Resolves with the child
+ * exit code (0 success); rejects only when the process could not start.
+ * No timeout: an npm install may legitimately take minutes.
+ */
+export declare function applyLauncherUpdate(onLine: (line: string) => void, spawnProcess?: SpawnLike): Promise<number>;