dsh-code 0.8.0 → 0.9.0

package/lib/types/app.d.ts

@@ -25,6 +25,7 @@ import type { ProviderSettingsDirectory, ProviderTargetView } from './provider-s
 import type { QuestionStore } from './questions.ts';
 import type { SkillsView, SkillRow } from './skills.ts';
 import type { MentionCandidate } from './mentions.ts';
+import type { SubagentFeedView } from './subagents.ts';
 import type { PresetRow } from './presets.ts';
 import type { PermissionRow } from './permissions.ts';
 import type { PluginRow } from './plugin-inventory.ts';
@@ -39,6 +40,8 @@ export interface AppProps {
     approval: ApprovalStore;
     /** ask_user_question store fed by the single UI provider. */
     questions: QuestionStore;
+    /** Live subagent activity feed (child sessions of the current root). */
+    subagents: SubagentFeedView;
     /** Live slash-command descriptor list (completion candidates). */
     commands: CommandsView;
     /** Live user-invocable skill catalog (completion candidates). */
@@ -75,6 +78,14 @@ export interface AppProps {
     loadMentions(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]>;
     /** Apply one /model selection (with an advertised reasoning effort, when picked); returns the display label. */
     selectModel(row: ModelRow, effortId?: string): string;
+    /** The /subagent override label, '' when delegated agents follow the current model. */
+    subagentModel: string;
+    /** Apply one /subagent model pick; returns the override label. */
+    setSubagentModel(row: ModelRow, effortId?: string): string;
+    /** Drop the /subagent override (delegated agents follow the current model). */
+    clearSubagentModel(): void;
+    /** Delete one session subtree; resolves with the outcome line. */
+    deleteSession(id: string): Promise<string>;
     /** Load provider/settings/credential facts for the optional /model provider stage. */
     loadModelProviders?(): Promise<ProviderSettingsDirectory>;
     /** Subscribe to Harness credential/settings/adapter invalidations while /model is open. */
@@ -101,6 +112,8 @@ export interface AppProps {
     createSession(mode?: string): void;
     loadSessions(options: SessionDirectoryOptions, signal?: AbortSignal): Promise<readonly SessionRow[]>;
     loadSessionTranscript(id: string, signal?: AbortSignal): Promise<string>;
+    /** Load this session's subagent conversations (children by lineage). */
+    loadSubagents(): Promise<readonly SessionRow[]>;
     switchSession(row: SessionRow): void;
     cancelSessionSwitch(): boolean;
     loadPlugins(): readonly PluginRow[];

package/lib/types/approval.d.ts

@@ -29,10 +29,12 @@ export interface PendingApproval {
 }
 /** The pending-question snapshot the renderer subscribes to. */
 export interface ApprovalSnapshot {
-    /** The pending question, or undefined when none is being asked. */
+    /** The question on screen (queue head), or undefined when none is asked. */
     pending: PendingApproval | undefined;
     /** Presentational: an answer was submitted, the ask has not settled yet. */
     answered: boolean;
+    /** Further asks waiting behind the on-screen one (FIFO, Codex-style). */
+    queued: number;
 }
 /** Store the pending question lands in; the renderer reads, the answerer writes. */
 export interface ApprovalStore {

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

@@ -1,6 +1,7 @@
 /** Bounded, composer-safe panels for preset, session, and plugin kernel views. */
 import { type ReactElement } from 'react';
-import type { ModelRow } from './models.ts';
+import type { ModelDirectory, ModelRow } from './models.ts';
+import type { SubagentRow } from './subagents.ts';
 import type { PermissionRow } from './permissions.ts';
 import type { PresetRow } from './presets.ts';
 import type { PluginRow } from './plugin-inventory.ts';
@@ -23,11 +24,19 @@ export declare function PluginPanel({ load, close, initialQuery }: {
     close(): void;
     initialQuery?: string;
 }): ReactElement;
-export declare function ResumePanel({ currentCwd, load, readTranscript, select, close }: {
+export declare function ResumePanel({ currentCwd, load, readTranscript, select, requestDelete, deleteConfirmId, reloadToken, deleteMode, close }: {
     currentCwd: string;
     load(options: SessionDirectoryOptions, signal?: AbortSignal): Promise<readonly SessionRow[]>;
     readTranscript(id: string, signal?: AbortSignal): Promise<string>;
     select(row: SessionRow): void;
+    /** Arm the composer-based delete confirm for one row (App owns the keys). */
+    requestDelete?(row: SessionRow): void;
+    /** The row id awaiting y/n in the composer, when any (App-owned). */
+    deleteConfirmId?: string;
+    /** Bump to reload the listing (e.g. after a deletion). */
+    reloadToken?: number;
+    /** Opened via /delete: hint-first delete mode. */
+    deleteMode?: boolean;
     close(): void;
 }): ReactElement;
 /**
@@ -57,12 +66,15 @@ export declare function StatuslinePanel({ enabled, change, close }: {
 /**
  * The `/model` reasoning-effort stage (the Codex model → reasoning popup
  * contract): one bounded list over the selected model's adapter-advertised
- * effort levels, with the effective effort and the model default marked.
- * A model WITHOUT an adapter-declared default leads with a "Default"
- * (provider-default) row — the web effort pane's first entry — so the user
- * can clear a picked level back to provider behavior instead of being forced
- * to choose an advertised one. Enter applies one level; Esc returns to the
- * model list without applying.
+ * effort levels — in the adapter's own display order, ids verbatim (the
+ * kernel treats them as opaque and rejects anything else) — with the
+ * effective effort and the model default marked. A model WITHOUT an
+ * adapter-declared default leads with a "Default" (provider-default) row —
+ * the web effort pane's first entry — so the user can clear a picked level
+ * back to provider behavior. A model advertising no levels opens the same
+ * stage with an explicit empty state (the web pane's "no levels" copy)
+ * instead of a bare failure notice. Enter applies one level; Esc returns to
+ * the model list without applying.
  */
 export declare function EffortPanel({ row, current, select, back }: {
     /** The model row whose advertised levels this stage lists. */
@@ -74,3 +86,41 @@ export declare function EffortPanel({ row, current, select, back }: {
     /** Return to the model list without applying. */
     back(): void;
 }): ReactElement;
+/**
+ * The /agents panel (the Codex agent-picker contract, read-only): this
+ * conversation's subagent conversations — live rows from the activity feed
+ * first, persisted children the feed has not seen this process after — with
+ * Enter/t opening the child's full transcript in the shared read-only
+ * document view (the same projection the exporter uses).
+ */
+export declare function AgentsPanel({ live, load, readTranscript, close }: {
+    /** Live feed rows (child sessions observed this process). */
+    live: readonly SubagentRow[];
+    /** Load this session's persisted child sessions by lineage. */
+    load(): Promise<readonly SessionRow[]>;
+    /** Read one child session's full transcript as markdown. */
+    readTranscript(id: string, signal?: AbortSignal): Promise<string>;
+    close(): void;
+}): ReactElement;
+/**
+ * The /subagent model panel: which model configuration delegated subagents
+ * run on. The kernel seeds child agents from the parent's CREATE-TIME
+ * AgentOptions, so a mid-session /model switch would otherwise leave them on
+ * the launch-time route; the TUI mirrors the selection onto subagent-origin
+ * requests (or an explicit override picked here) via an agent/request
+ * listener. The leading "inherit" row restores follow-the-current-model
+ * behavior; picking a model with several advertised efforts opens the same
+ * effort stage /model uses. Effort overrides are not offered separately —
+ * the kernel's AgentOptions has no effort channel for children, so the level
+ * rides the selected model exactly as /model applies it.
+ */
+export declare function SubagentPanel({ current, load, pick, inherit, close }: {
+    /** Display label of the override in force, '' when following the current model. */
+    current: string;
+    load(): Promise<ModelDirectory>;
+    /** Apply one model (with an advertised effort, when picked) as the override. */
+    pick(row: ModelRow, effortId?: string): void;
+    /** Drop the override: subagents follow the current model again. */
+    inherit(): void;
+    close(): void;
+}): ReactElement;

package/lib/types/models.d.ts

@@ -9,7 +9,7 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import type { ModelSelection } from '@deepseek-ai/dsh-agent';
-import { type LlmModelReasoningInfo } from '@deepseek-ai/dsh-llm';
+import { type LlmCallConfig, type LlmModelReasoningInfo } from '@deepseek-ai/dsh-llm';
 /** Display metadata for one adapter-owned reasoning effort (mirrors `LlmReasoningEffortInfo`). */
 export interface ModelReasoningEffort {
     /** Opaque value accepted by the model's `GenerateOptions.reasoningEffort`. */
@@ -87,6 +87,20 @@ export declare function resolveEffectiveSelection(picked: ModelSelection | undef
 export declare function buildModelSelection(row: ModelRow, effortId?: string): ModelSelection;
 /** Display label for one applied selection: `provider/model` or `provider/model@effort`. */
 export declare function modelSelectionLabel(selection: ModelSelection): string;
+/**
+ * Apply one model selection onto a resolved request config — the exact
+ * semantics of the kernel's `installModelSelection` request listener,
+ * extracted so the TUI can mirror it for subagent-origin requests: children
+ * spawned by the subagent tool inherit the parent's CREATE-TIME AgentOptions,
+ * which a mid-session /model switch never touches, so delegated work would
+ * otherwise keep running on the launch-time route. An absent effort strips
+ * any inherited effort (restoring the selected model's provider default),
+ * matching the kernel listener field-for-field.
+ * @param resolved - the config the inner chain produced.
+ * @param selection - the selection to enforce.
+ * @returns the overridden config.
+ */
+export declare function applyModelSelectionToConfig(resolved: LlmCallConfig, selection: ModelSelection): LlmCallConfig;
 /**
  * Load the selectable model directory from the live `ctx.llm` registry.
  * Providers are listed synchronously; each provider's models are discovered

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

@@ -47,6 +47,8 @@ export interface ToolEntry {
     arguments: string;
     /** Bounded human-meaningful arguments preview for the tool card. */
     preview: string;
+    /** Bounded delegation prompt (subagent cards' second row), '' when none. */
+    prompt: string;
     /** Execution state; `running` until the paired result lands. */
     state: 'running' | 'done' | 'error';
     /** Bounded first text block of the result, empty until it lands. */

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

@@ -16,3 +16,13 @@
  * @returns the preview line; empty when nothing useful resolves.
  */
 export declare function toolArgumentsPreview(args: string, toolName: string): string;
+/**
+ * Bounded prompt preview for delegation-style tools (`subagent`): the
+ * `prompt` argument rendered as the card's second row, so the transcript
+ * shows what the child agent was asked — not just its description label —
+ * while it runs (Codex's SpawnAgent card preview). Anything else returns ''.
+ * @param toolName - the tool the arguments belong to.
+ * @param args - raw JSON arguments string as the model produced it.
+ * @returns the one-line prompt preview, or '' when none applies.
+ */
+export declare function toolPromptPreview(toolName: string, args: string): string;

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

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

package/lib/types/subagents.d.ts

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

package/package.json

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