dsh-code 1.0.6 → 1.0.7

package/lib/session-query.mjs

@@ -0,0 +1,149 @@
+import { createHash } from "node:crypto";
+import SqliteSessionQueryEngine from "@deepseek-ai/dsh-session-query-sqlite";
+import { SessionQueryError, assertSessionHeadersCompatible, buildSessionEventSearchDocuments, readColdSessionLog } from "@deepseek-ai/dsh-session-query";
+//#region src/session-query.ts
+/**
+* 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.
+*/
+const STABLE_OBSERVATION_ATTEMPTS = 2;
+function assertNotAborted(signal) {
+	if (signal?.aborted) throw new SessionQueryError("session-search aborted", "SESSION_QUERY_ABORTED");
+}
+function isAbort(error) {
+	return error instanceof SessionQueryError && error.code === "SESSION_QUERY_ABORTED";
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : "unknown error";
+}
+function observeSession(header, inheritedEventCount, events) {
+	const detachedHeader = structuredClone(header);
+	const detachedEvents = events.map((event) => structuredClone(event));
+	return {
+		header: detachedHeader,
+		inheritedEventCount,
+		documents: buildSessionEventSearchDocuments(detachedHeader.id, detachedEvents),
+		fingerprint: createHash("sha256").update(JSON.stringify({
+			header: detachedHeader,
+			inheritedEventCount,
+			events: detachedEvents
+		})).digest("base64url")
+	};
+}
+function sameHeader(a, b) {
+	return a.id === b.id && a.createdAt === b.createdAt && a.cwd === b.cwd && a.parentSession === b.parentSession && a.isSeeded === b.isSeeded && (a.delegationDepth ?? 0) === (b.delegationDepth ?? 0) && a.agentPreset === b.agentPreset;
+}
+function materializePersistenceSnapshots(snapshots) {
+	if (!Array.isArray(snapshots)) throw new Error("persistence snapshots must be an array");
+	const result = /* @__PURE__ */ new Map();
+	for (const snapshot of snapshots) {
+		if (typeof snapshot.revision !== "string") throw new Error("persistence snapshot revision must be a string");
+		const header = structuredClone(snapshot.header);
+		if (result.has(header.id)) throw new Error(`persistence listed duplicate session "${header.id}"`);
+		result.set(header.id, {
+			header,
+			revision: snapshot.revision
+		});
+	}
+	return result;
+}
+function samePersistenceSnapshots(before, after) {
+	if (before.size !== after.size) return false;
+	for (const [id, first] of before) {
+		const second = after.get(id);
+		if (second === void 0 || first.revision !== second.revision || !sameHeader(first.header, second.header)) return false;
+	}
+	return true;
+}
+/**
+* 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.
+*/
+async function observeStableWithSkip(engine, indexed, signal, readCold = readColdSessionLog) {
+	for (let attempt = 0; attempt < STABLE_OBSERVATION_ATTEMPTS; attempt += 1) {
+		assertNotAborted(signal);
+		const persistenceBinding = engine._persistenceBinding;
+		const persistence = persistenceBinding.service;
+		const initiallyLive = new Set(engine.ctx.sessions.list().map((session) => session.id));
+		let persisted = /* @__PURE__ */ new Map();
+		if (persistence !== void 0) try {
+			const canReuseIndexed = engine._lastPersistenceIdentity === void 0 || engine._lastPersistenceIdentity === persistenceBinding.identity;
+			const listOptions = signal === void 0 ? void 0 : { signal };
+			const before = await persistence.list(listOptions);
+			assertNotAborted(signal);
+			persisted = materializePersistenceSnapshots(before);
+			for (const entry of persisted.values()) {
+				if (canReuseIndexed && indexed.get(entry.header.id)?.revision === entry.revision) continue;
+				if (initiallyLive.has(entry.header.id) || engine.ctx.sessions.get(entry.header.id) !== void 0) continue;
+				assertNotAborted(signal);
+				try {
+					const loaded = await readCold(persistence, entry.header.id, signal);
+					assertNotAborted(signal);
+					assertSessionHeadersCompatible(entry.header, loaded.header);
+					entry.loaded = observeSession(loaded.header, loaded.inheritedEventCount, loaded.events);
+				} catch (error) {
+					if (isAbort(error) || signal?.aborted) throw error;
+					if (engine._persistenceBinding !== persistenceBinding) break;
+					entry.unreadable = errorMessage(error);
+					engine.ctx.logger?.warn("session-search skipped unreadable session %s: %s", entry.header.id, entry.unreadable);
+				}
+			}
+			assertNotAborted(signal);
+			const afterSnapshots = await persistence.list(listOptions);
+			assertNotAborted(signal);
+			const after = materializePersistenceSnapshots(afterSnapshots);
+			if (!samePersistenceSnapshots(persisted, after)) continue;
+			if (engine._persistenceBinding !== persistenceBinding) continue;
+		} catch (error) {
+			if (isAbort(error) || signal?.aborted) throw new SessionQueryError("session-search aborted", "SESSION_QUERY_ABORTED", { cause: error });
+			if (engine._persistenceBinding !== persistenceBinding) continue;
+			if (error instanceof SessionQueryError) throw error;
+			throw new SessionQueryError(`session-search persistence observation failed: ${errorMessage(error)}`, "SESSION_QUERY_PERSISTENCE_FAILED", { cause: error });
+		}
+		const live = /* @__PURE__ */ new Map();
+		for (const session of engine.ctx.sessions.list()) {
+			const observed = observeSession(session.header, session.inheritedEventCount, session.snapshotEvents());
+			const durable = persisted.get(session.id);
+			if (durable !== void 0 && durable.loaded === void 0) {
+				live.set(session.id, observed);
+				continue;
+			}
+			if (durable !== void 0) assertSessionHeadersCompatible(observed.header, durable.header);
+			live.set(session.id, observed);
+		}
+		if (!(initiallyLive.size === live.size && [...initiallyLive].every((id) => live.has(id)))) continue;
+		return {
+			persistenceBinding,
+			persisted,
+			live
+		};
+	}
+	throw new SessionQueryError("session-search persistence observation did not stabilize after one retry", "SESSION_QUERY_PERSISTENCE_FAILED");
+}
+const EngineBase = SqliteSessionQueryEngine;
+/** The engine this bundle mounts in place of the base `session-query-sqlite` row. */
+var SkipTolerantSessionQueryEngine = class extends EngineBase {
+	async _observeStable(indexed, signal) {
+		return await observeStableWithSkip(this, indexed, signal);
+	}
+};
+//#endregion
+export { SkipTolerantSessionQueryEngine, SkipTolerantSessionQueryEngine as default, observeStableWithSkip };

package/lib/types/app.d.ts

@@ -18,6 +18,7 @@ import type { CommandDescriptor } from '@deepseek-ai/dsh-commands';
 import type { ContentBlock, FileBlock, ImageBlock } from '@deepseek-ai/dsh-llm';
 import type { AuthorizationInteraction, AuthorizationStatus } from '@deepseek-ai/dsh-authorization';
 import { type ThemeName } from './theme.ts';
+import type { LauncherUpdateStatus } from './update.ts';
 import type { TranscriptStore } from './store.ts';
 import { type TranscriptEntry } from './render/projection.ts';
 import type { ApprovalStore } from './approval.ts';
@@ -139,8 +140,10 @@ export interface AppProps {
     logoutProviderAuthorization?(row: ProviderAuthorizationRow): Promise<void>;
     openAuthorizationUrl?(url: string): boolean;
     copyTextValue?(text: string): Promise<void>;
-    /** Cycle to the next permission preset (Shift+Tab); returns the new label. */
-    cyclePermission(): string;
+    /** Cycle to the next mode station (Shift+Tab): a permission preset or a plan switch; returns the notice label. */
+    cycleMode(): string;
+    /** Pre-session plan choice: shows the plan badge before the first session exists. */
+    pendingPlan?: boolean;
     /** Select or inspect a permission preset without requiring a pre-existing session. */
     setPermission(id: string): string;
     /** Export the transcript to a markdown file (/export [path]); reports via notices. */
@@ -170,6 +173,10 @@ export interface AppProps {
     loadPlugins(): readonly PluginRow[];
     /** Caller-visible background jobs (the host jobs registry, read-only). */
     loadJobs(): readonly JobRow[];
+    /** Probe the launcher's aligned update plan (read-only; never installs). */
+    probeUpdate(): Promise<LauncherUpdateStatus>;
+    /** Run the launcher's aligned update; streams sanitized lines; resolves with the exit code. */
+    applyUpdate(onLine: (line: string) => void): Promise<number>;
     /** Registers the app's notice channel with the runner (called once on mount). */
     onBridgeReady(bridge: {
         notify(text: string, tone?: NoticeTone): void;

package/lib/types/index.d.ts

@@ -85,6 +85,33 @@ export interface QueuedSubmission {
  * An untagged (synchronous) or pending-session ('') submission always passes.
  */
 export declare function submissionBelongsToSession(origin: string | undefined, activeSessionId: string | undefined): boolean;
+/** One Shift+Tab station decision for the mode cycle. */
+export type ModeCycleDecision = {
+    readonly kind: 'permission';
+    readonly preset: string;
+} | {
+    readonly kind: 'plan-on';
+} | {
+    readonly kind: 'plan-off';
+    readonly preset: string;
+};
+/**
+ * Decide the next Shift+Tab station. The cycle keeps the preset table's
+ * own order (most restrictive first) and inserts ONE plan station between
+ * the most restrictive preset and the wrap target: with the shipped three
+ * presets the user sees workspace-write → danger-full-access → read-only
+ * → plan → workspace-write. Plan IS the most restrictive preset plus the
+ * plan prompt layer — entering it switches nothing (the cycle is already
+ * parked on read-only), and leaving it lands on the next preset after the
+ * most restrictive one. Without the /plan command the cycle is exactly the
+ * preset table.
+ */
+export declare function planCycleDecision(input: {
+    readonly names: readonly string[];
+    readonly current: string;
+    readonly inPlan: boolean;
+    readonly planAvailable: boolean;
+}): ModeCycleDecision | undefined;
 /**
  * Order-preserving gate for composer input while the startup prompt/images
  * are still preparing. Anything submitted before the startup delivery settles

package/lib/types/kernel-panels.d.ts

@@ -2,6 +2,7 @@
 import { type ReactElement } from 'react';
 import type { ModelDirectory, ModelRow } from './models.ts';
 import type { SubagentRow } from './subagents.ts';
+import type { ScheduleRow } from './render/projection.ts';
 import type { PermissionRow } from './permissions.ts';
 import type { PresetRow } from './presets.ts';
 import type { PluginRow } from './plugin-inventory.ts';
@@ -165,3 +166,25 @@ export declare function SubagentPanel({ current, load, pick, inherit, close }: {
     inherit(): void;
     close(): void;
 }): ReactElement;
+/**
+ * The /schedule panel: the read-only catalog of active reminders folded from
+ * durable schedule/change events (the web ui-schedule contract: overdue
+ * first, then ascending target; the model creates and cancels through its
+ * schedule_* tools, the panel only shows state). A local second-hand keeps
+ * the relative labels live while the panel is open.
+ */
+export interface ScheduleDisplayRow {
+    readonly key: string;
+    readonly text: string;
+    readonly tone?: 'error';
+}
+/** Human frequency label: one-shot kinds read as Once, every rows carry the interval. */
+export declare function scheduleFrequency(row: ScheduleRow): string;
+/** Relative label for the next target: in N unit, or N unit overdue. */
+export declare function scheduleRelative(targetAt: number, now: number): string;
+/** Ordered display rows: overdue first (error tone), then ascending target. */
+export declare function scheduleDisplayRows(rows: readonly ScheduleRow[], now: number): readonly ScheduleDisplayRow[];
+export declare function SchedulePanel({ rows, close }: {
+    rows(): readonly ScheduleRow[];
+    close(): void;
+}): ReactElement;

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

@@ -155,8 +155,9 @@ export declare function replaceRangePreservingCursor(value: string, cursor: numb
  */
 export declare function composerMaxRows(terminalRows: number): number;
 /**
- * History navigation starts with Up on an empty draft, or after visual
- * movement has reached the directional text edge of an unchanged recalled
- * entry. Every other position remains under textarea movement.
+ * History navigation starts with Up on an empty draft, or continues from an
+ * unchanged recalled entry whenever the caret sits on either text edge
+ * (start or end) - moving the caret into the interior returns the keys to
+ * ordinary editing until an edge is reached again.
  */
 export declare function shouldRecallNavigate(value: string, cursor: number, lastRecalled: string | null, direction: -1 | 1): boolean;

package/lib/types/render/ime-cursor.d.ts

@@ -0,0 +1,60 @@
+/**
+ * IME cursor anchoring for the composer.
+ *
+ * Ink keeps the real terminal cursor hidden and parks it just below the
+ * dynamic tree (after the status row). IME composition text and candidate
+ * windows anchor to that real cursor cell - VS Code's integrated terminal
+ * positions its hidden IME textarea there, and Windows consoles behave the
+ * same - so CJK input appeared at the bottom of the screen instead of at the
+ * caret. The anchor moves the real cursor onto the caret cell without
+ * touching Ink's relative erase ledger:
+ *
+ * - the displacement is owned: before any foreign write or re-anchor, the
+ *   wrapper cancels it (cursor down, column 1), so every writer - Ink's
+ *   log-update rewrites, the resize replay, protocol pushes - keeps seeing
+ *   the cursor exactly where it was left;
+ * - log-update frame chunks (which start with the erase-line sequence) get
+ *   the anchor re-appended inside the same write, so a repaint can never
+ *   leave the cursor behind - in particular the caret blink keeps the anchor
+ *   stable while an IME composition is open, because the terminal parses the
+ *   rewrite and the re-anchor as one atomic update.
+ *
+ * @module @deepseek-ai/dsh-code/render/ime-cursor
+ */
+/** Cancel `rows` of owned upward displacement and return to column 1. */
+export declare function imeCursorRestore(rows: number): string;
+/** Move onto the caret cell: `rows` up from Ink's parked row, 0-based column. */
+export declare function imeCursorMove(rows: number, column: number): string;
+/**
+ * Rows between the caret cell and Ink's parked cursor row: the band's bottom
+ * blank row, the editor window rows below the caret, the status footer, and
+ * Ink's own below-frame row. Rows above the composer (gutter, live content)
+ * never enter this distance.
+ */
+export declare function imeCursorRowsUp(input: {
+    editorWindowRows: number;
+    caretRowInWindow: number;
+    rowsBelowComposer: number;
+}): number;
+/** The installed anchor handle. */
+export interface ImeCursorAnchor {
+    /** Anchor on the caret cell: `rows` above Ink's parked row at the 0-based
+     * `column`; `rows <= 0` releases the anchor. */
+    anchor(rows: number, column: number): void;
+    /** Cancel the displacement, restore the original write path, and detach. */
+    release(): void;
+}
+/**
+ * Take over `stream.write` so the anchor displacement stays invisible to every
+ * other writer. Idempotent per stream: a second install returns the live
+ * handle. Returns `undefined` on non-TTY streams where anchoring is meaningless.
+ */
+export declare function installImeCursorAnchor(stream: NodeJS.WriteStream): ImeCursorAnchor | undefined;
+/**
+ * Keep the real terminal cursor on the composer's caret cell while `active`
+ * (the editable composer). The second effect runs after every commit without
+ * a dep list: frame rewrites restore the anchor themselves, but any other
+ * write (protocol push, resize replay) leaves the cursor at Ink's parked
+ * position, and the next commit re-anchors it.
+ */
+export declare function useImeCursorAnchor(active: boolean, rows: number, column: number): void;

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

@@ -219,6 +219,38 @@ 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. */
@@ -265,6 +297,8 @@ export interface TranscriptView {
     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
@@ -360,6 +394,7 @@ export interface ReplayAccumulator {
     systemPrompt: string;
     sandbox: string;
     goal: GoalFold | undefined;
+    schedules: readonly ScheduleRow[];
     stats: TranscriptStats;
     stepStart: Map<string, number>;
     toolStart: Map<string, number>;

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-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/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>;