dsh-code 0.8.0 → 0.9.1

package/src/approval.ts

@@ -1,135 +1,161 @@
-/**
- * The terminal approval answerer: one `approval/request` waterfall listener
- * that renders the pending question as a y/n bar and resolves the decision
- * back into the waterfall. Mirrors the web host's composer takeover — the
- * service (audit pair, policy gate, fail-closed defaults) all live in
- * dsh-base; this module only answers for agents this TUI owns.
- *
- * Vocabulary note: a client answerer may only ever resolve `'allowed-once'`
- * or `'rejected'`; `'cancelled'` belongs to the request signal and
- * `'unavailable'` to the fail-closed waterfall default.
- *
- * @module @deepseek-ai/dsh-code/approval
- */
-
-import type { Context } from '@deepseek-ai/cordis'
-import type { Agent } from '@deepseek-ai/dsh-agent'
-import type { ApprovalOutcome, ApprovalRequest } from '@deepseek-ai/dsh-user-approval'
-
-/** The answer values a client answerer may resolve with. */
-export type ApprovalAnswer = 'allowed-once' | 'rejected'
-
-/** One pending approval question, derived from the request for rendering. */
-export interface PendingApproval {
-  /** The asker's human-readable explanation, or a generic fallback. */
-  headline: string
-  /** The tool the question is about. */
-  toolName: string
-  /** Command-line preview resolved from the paired streaming tool call. */
-  command: string
-  /** Resolve the ask; calling twice is inert (one-shot latch). */
-  answer(outcome: ApprovalAnswer): void
-}
-
-/** The pending-question snapshot the renderer subscribes to. */
-export interface ApprovalSnapshot {
-  /** The pending question, or undefined when none is being asked. */
-  pending: PendingApproval | undefined
-  /** Presentational: an answer was submitted, the ask has not settled yet. */
-  answered: boolean
-}
-
-/** Store the pending question lands in; the renderer reads, the answerer writes. */
-export interface ApprovalStore {
-  /** Subscribe to pending-state changes; returns the unsubscribe function. */
-  subscribe(listener: () => void): () => void
-  /** Read the current snapshot (identity-stable between changes). */
-  getSnapshot(): ApprovalSnapshot
-}
-
-/**
- * Create the approval store and mount the answerer listener on the context.
- * The listener claims only requests for `owns`-owned agents and defers every
- * other request back into the waterfall (`next()`), so sibling answerers stay
- * usable. An aborted ask never reaches the human. Plugin teardown removes the
- * listener; the service then fails its own question closed.
- * @param ctx - plugin context whose event bus carries `approval/request`.
- * @param owns - agents this terminal answers for.
- * @param preview - resolves a tool-call preview for a pending request (the
- * request contract carries no arguments; the UI self-serves from the
- * transcript projection via `callId`).
- * @returns the store the renderer subscribes to.
- */
-export function mountApprovalAnswerer(
-  ctx: Context,
-  owns: (agent: Agent) => boolean,
-  preview: (request: ApprovalRequest) => string,
-): ApprovalStore {
-  let snapshot: ApprovalSnapshot = { pending: undefined, answered: false }
-  const listeners = new Set<() => void>()
-  const set = (next: ApprovalSnapshot): void => {
-    snapshot = next
-    for (const listener of listeners) listener()
-  }
-
-  ctx.on('approval/request', (request: ApprovalRequest, next: () => Promise<ApprovalOutcome>) => {
-    if (!owns(request.agent)) return next()
-    // An already-aborted ask never reaches the human (mirrors the host bridge).
-    if (request.signal?.aborted === true) return Promise.resolve<ApprovalOutcome>('cancelled')
-
-    let resolved = false
-    let settle!: (outcome: ApprovalOutcome) => void
-    const signal = request.signal
-    const onAbort = (): void => withdraw()
-    // Detach on every settle so an answered ask never retains a listener on
-    // the tool call's signal (long turns ask many times; each ask must let go).
-    const detachAbort = (): void => {
-      if (signal !== undefined) signal.removeEventListener('abort', onAbort)
-    }
-    const withdraw = (): void => {
-      if (resolved) return
-      resolved = true
-      detachAbort()
-      set({ pending: undefined, answered: false })
-      // The service's signal race would conclude 'cancelled' anyway; settle
-      // the same way so this listener never dangles a pending promise.
-      settle('cancelled')
-    }
-    if (signal !== undefined) {
-      signal.addEventListener('abort', onAbort, { once: true })
-    }
-    const pending: PendingApproval = {
-      headline: request.reason ?? `tool ${request.toolName} asks for your approval`,
-      toolName: request.toolName,
-      command: preview(request),
-      answer: (outcome: ApprovalAnswer): void => {
-        // One-shot latch: a second keypress after submission is inert.
-        if (resolved) return
-        resolved = true
-        detachAbort()
-        set({ pending, answered: true })
-        settle(outcome)
-      },
-    }
-    set({ pending, answered: false })
-
-    return new Promise<ApprovalOutcome>((resolve) => {
-      settle = resolve
-    }).then((outcome) => {
-      if (outcome !== 'cancelled') set({ pending: undefined, answered: false })
-      return outcome
-    })
-  })
-
-  return {
-    subscribe(listener: () => void): () => void {
-      listeners.add(listener)
-      return () => {
-        listeners.delete(listener)
-      }
-    },
-    getSnapshot(): ApprovalSnapshot {
-      return snapshot
-    },
-  }
-}
+/**
+ * The terminal approval answerer: one `approval/request` waterfall listener
+ * that renders the pending question as a y/n bar and resolves the decision
+ * back into the waterfall. Mirrors the web host's composer takeover — the
+ * service (audit pair, policy gate, fail-closed defaults) all live in
+ * dsh-base; this module only answers for agents this TUI owns.
+ *
+ * Vocabulary note: a client answerer may only ever resolve `'allowed-once'`
+ * or `'rejected'`; `'cancelled'` belongs to the request signal and
+ * `'unavailable'` to the fail-closed waterfall default.
+ *
+ * @module @deepseek-ai/dsh-code/approval
+ */
+
+import type { Context } from '@deepseek-ai/cordis'
+import type { Agent } from '@deepseek-ai/dsh-agent'
+import type { ApprovalOutcome, ApprovalRequest } from '@deepseek-ai/dsh-user-approval'
+
+/** The answer values a client answerer may resolve with. */
+export type ApprovalAnswer = 'allowed-once' | 'rejected'
+
+/** One pending approval question, derived from the request for rendering. */
+export interface PendingApproval {
+  /** The asker's human-readable explanation, or a generic fallback. */
+  headline: string
+  /** The tool the question is about. */
+  toolName: string
+  /** Command-line preview resolved from the paired streaming tool call. */
+  command: string
+  /** Resolve the ask; calling twice is inert (one-shot latch). */
+  answer(outcome: ApprovalAnswer): void
+}
+
+/** The pending-question snapshot the renderer subscribes to. */
+export interface ApprovalSnapshot {
+  /** 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 {
+  /** Subscribe to pending-state changes; returns the unsubscribe function. */
+  subscribe(listener: () => void): () => void
+  /** Read the current snapshot (identity-stable between changes). */
+  getSnapshot(): ApprovalSnapshot
+}
+
+/**
+ * Create the approval store and mount the answerer listener on the context.
+ * The listener claims only requests for `owns`-owned agents and defers every
+ * other request back into the waterfall (`next()`), so sibling answerers stay
+ * usable. An aborted ask never reaches the human. Plugin teardown removes the
+ * listener; the service then fails its own question closed.
+ * @param ctx - plugin context whose event bus carries `approval/request`.
+ * @param owns - agents this terminal answers for.
+ * @param preview - resolves a tool-call preview for a pending request (the
+ * request contract carries no arguments; the UI self-serves from the
+ * transcript projection via `callId`).
+ * @returns the store the renderer subscribes to.
+ */
+export function mountApprovalAnswerer(
+  ctx: Context,
+  owns: (agent: Agent) => boolean,
+  preview: (request: ApprovalRequest) => string,
+): ApprovalStore {
+  /** One live ask: its pending view plus the one-shot settle plumbing. */
+  interface Slot {
+    readonly pending: PendingApproval
+    answered: boolean
+  }
+  const queue: Slot[] = []
+  let snapshot: ApprovalSnapshot = { pending: undefined, answered: false, queued: 0 }
+  const listeners = new Set<() => void>()
+  const publish = (): void => {
+    const head = queue[0]
+    snapshot = {
+      pending: head === undefined ? undefined : head.pending,
+      answered: head !== undefined && head.answered,
+      queued: Math.max(0, queue.length - 1),
+    }
+    for (const listener of listeners) listener()
+  }
+  const removeSlot = (slot: Slot): void => {
+    const at = queue.indexOf(slot)
+    if (at !== -1) queue.splice(at, 1)
+  }
+
+  ctx.on('approval/request', (request: ApprovalRequest, next: () => Promise<ApprovalOutcome>) => {
+    if (!owns(request.agent)) return next()
+    // An already-aborted ask never reaches the human (mirrors the host bridge).
+    if (request.signal?.aborted === true) return Promise.resolve<ApprovalOutcome>('cancelled')
+
+    let resolved = false
+    let settle!: (outcome: ApprovalOutcome) => void
+    const signal = request.signal
+    const onAbort = (): void => withdraw()
+    // Detach on every settle so an answered ask never retains a listener on
+    // the tool call's signal (long turns ask many times; each ask must let go).
+    const detachAbort = (): void => {
+      if (signal !== undefined) signal.removeEventListener('abort', onAbort)
+    }
+    const withdraw = (): void => {
+      if (resolved) return
+      resolved = true
+      detachAbort()
+      removeSlot(slot)
+      publish()
+      // The service's signal race would conclude 'cancelled' anyway; settle
+      // the same way so this listener never dangles a pending promise.
+      settle('cancelled')
+    }
+    if (signal !== undefined) {
+      signal.addEventListener('abort', onAbort, { once: true })
+    }
+    const slot: Slot = {
+      answered: false,
+      pending: {
+        headline: request.reason ?? `tool ${request.toolName} asks for your approval`,
+        toolName: request.toolName,
+        command: preview(request),
+        answer: (outcome: ApprovalAnswer): void => {
+          // One-shot latch: a second keypress after submission is inert.
+          if (resolved) return
+          resolved = true
+          detachAbort()
+          slot.answered = true
+          publish()
+          settle(outcome)
+        },
+      },
+    }
+    queue.push(slot)
+    publish()
+
+    return new Promise<ApprovalOutcome>((resolve) => {
+      settle = resolve
+    }).then((outcome) => {
+      if (outcome !== 'cancelled') {
+        removeSlot(slot)
+        publish()
+      }
+      return outcome
+    })
+  })
+
+  return {
+    subscribe(listener: () => void): () => void {
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+    getSnapshot(): ApprovalSnapshot {
+      return snapshot
+    },
+  }
+}

package/src/index.ts

@@ -12,7 +12,7 @@
 import { randomUUID } from 'node:crypto'
 import { readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
-import { mkdir, writeFile as writeFileAsync } from 'node:fs/promises'
+import { mkdir, rm, stat, writeFile as writeFileAsync } from 'node:fs/promises'
 import { basename, dirname, join } from 'node:path'
 import { createElement } from 'react'
 import type { Context } from '@deepseek-ai/cordis'
@@ -33,7 +33,7 @@ import { App, type NoticeTone } from './app.ts'
 import { mountApprovalAnswerer, type ApprovalStore } from './approval.ts'
 import { isSlashLine, watchCommands, type CommandsView } from './commands.ts'
 import { internals, type TuiMount } from './internals.ts'
-import { buildModelSelection, loadModelDirectory, resolveEffectiveSelection, type ModelRow } from './models.ts'
+import { buildModelSelection, applyModelSelectionToConfig, loadModelDirectory, modelSelectionLabel, resolveEffectiveSelection, type ModelRow } from './models.ts'
 import {
   loadProviderSettings,
   removeProviderSettings,
@@ -44,6 +44,7 @@ import {
 import { createMentions, type MentionsApi } from './mentions.ts'
 import { mountQuestionProvider, type QuestionStore } from './questions.ts'
 import { createTranscriptStore, type TranscriptStore } from './store.ts'
+import { createSubagentFeed, type SubagentFeedView } from './subagents.ts'
 import { parseStatuslineItems } from './render/status.ts'
 import { HISTORY_MAX_ENTRIES, parseHistoryFile, serializeHistoryList } from './history.ts'
 import { watchSkills, type SkillsView } from './skills.ts'
@@ -63,11 +64,14 @@ import {
 import { listPluginRows } from './plugin-inventory.ts'
 import { parseThemeName, setTheme, type ThemeName } from './theme.ts'
 import {
+  collectDeletionSubtree,
   isSubagentSession,
   matchSessionId,
   mergeSessionTitles,
   newestRootForCwd,
   projectSessionRows,
+  SESSION_ARTIFACT_NAMES,
+  sessionArtifactDirectory,
   type SessionDirectoryOptions,
   type SessionQueryService,
   type SessionRow,
@@ -274,7 +278,10 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   if (agents === undefined || defaultModel === undefined || sessions === undefined) return
 
   const cwd = process.cwd()
-  const defaults = defaultModel.currentSelection()
+  // Live deployment default (web selectModel parity): read on every use, not
+  // snapshotted at launch, so a /model pick this process saves becomes the
+  // default for sessions composed afterwards without a restart.
+  const currentDefaults = (): ModelSelection => defaultModel.currentSelection()
   const presets = agentPresetsFrom(ctx)
   if (presets === undefined) throw new Error('agent preset service is unavailable; check the dsh-code bundle patch')
   const permissionPresets = permissionPresetsFrom(ctx)
@@ -314,17 +321,22 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       mode = mounted.id
       const selection: ModelSelectionRef = {
         get current(): ModelSelection | undefined {
-          return resolveEffectiveSelection(selectionState.picked, agentCtx.agent?.session.requestHeader()?.config, defaults)
+          return resolveEffectiveSelection(selectionState.picked, agentCtx.agent?.session.requestHeader()?.config, currentDefaults())
         },
         set current(value: ModelSelection | undefined) { selectionState.picked = value },
         assembled: undefined,
       }
       installModelSelection(agentCtx, selection)
     }
+    // AgentOptions seed the loop's fallback route; effort rides the selection
+    // ref (installModelSelection), so only the provider/model pair is seeded.
+    const seedOptions = pendingSelection === undefined
+      ? { provider: currentDefaults().provider, model: currentDefaults().model }
+      : { provider: pendingSelection.provider, model: pendingSelection.model }
     const handle = next.resume
       ? await agents.resume({
         resumeSessionId: SessionId(next.sessionId),
-        agentOptions: { provider: defaults.provider, model: defaults.model },
+        agentOptions: seedOptions,
         // Quit aborts an in-flight composition so the exit wait never hangs
         // on a prepare that cannot settle; upstream rolls the creation back.
         signal: quitAbort.signal,
@@ -333,7 +345,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       : await agents.create({
         sessionId: SessionId(next.sessionId),
         meta: { cwd: nextCwd, agentPreset: mode },
-        agentOptions: { provider: defaults.provider, model: defaults.model },
+        agentOptions: seedOptions,
         signal: quitAbort.signal,
         setup,
       })
@@ -358,6 +370,9 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   let agent: Agent | undefined
   let session: Session | undefined
   let store: TranscriptStore = createTranscriptStore()
+  // Live subagent activity (child sessions of the current root): one bounded
+  // row per child, folded from the same event bus the transcript feeds on.
+  const subagents: SubagentFeedView & { apply(sessionId: string, event: SessionEvent): void; reset(): void } = createSubagentFeed()
   // File-only mentions from the start: `@` completion works on a bare launch
   // (no session yet); the prepare/activate paths replace this with the full
   // agent-scoped instance that also resolves session references.
@@ -418,7 +433,17 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   // before the first render. The handler reads the current session/store, so
   // the deferred first session of a bare launch is covered by the same feed.
   const off = ctx.on('session/event', (subject: Session, event: SessionEvent) => {
-    if (session !== undefined && subject.id === session.id) store.apply(event)
+    if (session === undefined) return
+    if (subject.id === session.id) {
+      store.apply(event)
+      return
+    }
+    // Child sessions (subagent conversations this root spawned) fold into
+    // the bounded live-activity feed, never the transcript: the root stays
+    // the only durable transcript truth while a running subagent remains
+    // visible. Lineage comes from the child header, same field the session
+    // directory uses to tag `↳` rows.
+    if (subject.header.parentSession === session.id) subagents.apply(subject.id, event)
   })
 
   const commands: CommandsView = watchCommands(ctx)
@@ -436,6 +461,28 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     request => approvalCommandPreview(store.getView().entries, request.callId, request.toolName),
   )
 
+  // Subagent model routing. The kernel seeds child agents from the parent's
+  // CREATE-TIME AgentOptions (resolveChildAgentOptions), which a mid-session
+  // /model switch never touches — delegated work would keep running on the
+  // launch-time route. This plugin-level listener mirrors installModelSelection
+  // for subagent-origin requests (scope filtering delivers the agent subject
+  // inside the payload): the explicit /subagent override wins, else the root's
+  // effective selection (explicit pick > session header > deployment default).
+  // Effort rides the selection exactly like the kernel listener applies it.
+  let subagentOverride: ModelSelection | undefined
+  ctx.on('agent/request', (payload, next) => {
+    const subject = payload.agent
+    const header = subject.session.header
+    if (header.parentSession === undefined && header.origin !== 'subagent') return next()
+    const picked = subagentOverride
+      ?? resolveEffectiveSelection(
+        active?.selection.picked ?? pendingSelection,
+        subject.session.requestHeader()?.config,
+        currentDefaults(),
+      )
+    return next().then(resolved => applyModelSelectionToConfig(resolved, picked))
+  })
+
   // ask_user_question provider: the single UI provider on the shared service,
   // one request on screen at a time. Plan reviews (exit_plan_mode) arrive
   // through this same pipe.
@@ -720,6 +767,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
         session = next.session
         store = next.store
         mentions = next.mentions
+        subagents.reset()
         pendingMode = undefined
         pendingPermission = undefined
         commands.setAgent(agent)
@@ -850,9 +898,53 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     } else {
       active.selection.picked = selection
     }
+    // Global default (web selectModel parity): every pick is persisted as the
+    // deployment default through the same agentDefaultModel service the web
+    // host writes, so the choice survives restarts and other surfaces read
+    // it. Save failures degrade to a notice — the in-session switch already
+    // took effect and must not roll back (the web contract).
+    void defaultModel.saveSelection(selection).catch((error: unknown) => {
+      bridge.notify(`model switch applies to this session but was not saved as the default: ${error instanceof Error ? error.message : String(error)}`, 'warning')
+    })
+    // Advisory immediate validation (web selectModel parity): run the same
+    // local resolveCallConfig check the request pipeline would, so a stale
+    // directory — an effort the adapter withdrew since /model loaded —
+    // surfaces as a pick-time notice instead of failing the next assembled
+    // step. Best-effort: an llm service without the resolver keeps the
+    // existing request-boundary rejection. Called as a method (`this`-bound)
+    // like resolveModelInfo in models.ts.
+    const llm = ctx.get('llm')
+    const resolveCallConfig = (llm as {
+      resolveCallConfig?: (this: unknown, config: { provider: string; model: string; reasoningEffort?: string }) => Promise<unknown>
+    } | undefined)?.resolveCallConfig
+    if (llm !== undefined && typeof resolveCallConfig === 'function') {
+      void Promise.resolve(resolveCallConfig.call(llm, {
+        provider: selection.provider,
+        model: selection.model,
+        ...selection.reasoningEffort === undefined ? {} : { reasoningEffort: selection.reasoningEffort },
+      })).catch((error: unknown) => {
+        bridge.notify(`model selection rejected: ${error instanceof Error ? error.message : String(error)} — reopen /model to pick again`, 'error')
+      })
+    }
     return `${row.provider}/${row.model}`
   }
 
+  /** The /subagent override label, '' when delegated agents follow the current model. */
+  const subagentModelLabel = (): string => subagentOverride === undefined ? '' : modelSelectionLabel(subagentOverride)
+
+  /** Apply one /subagent model pick; returns the override label. */
+  const setSubagentModel = (row: ModelRow, effortId?: string): string => {
+    subagentOverride = buildModelSelection(row, effortId)
+    renderCurrent()
+    return modelSelectionLabel(subagentOverride)
+  }
+
+  /** Drop the /subagent override: delegated agents follow the current model again. */
+  const clearSubagentModel = (): void => {
+    subagentOverride = undefined
+    renderCurrent()
+  }
+
   /**
    * Export the folded transcript to a markdown file (/export). The default
    * target sits beside the session's cwd so the file lands in the user's
@@ -904,7 +996,22 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
 
   const loadSessions = async (options: SessionDirectoryOptions, signal?: AbortSignal): Promise<readonly SessionRow[]> => {
     if (sessionQuery === undefined) throw new Error('session query is unavailable in this profile')
-    const projected = projectSessionRows(await sessionQuery.listSessions(signal), options)
+    const records = await sessionQuery.listSessions(signal)
+    // Last-activity timestamps for sorting (codex UpdatedAt default): the
+    // JSONL artifact's mtime via locate()+stat — the upstream api-proxy's own
+    // cold-probe pattern. O(1) per session; backends without a location (or
+    // vanished files) fall back to createdAt inside the projection.
+    const updated = new Map<string, number>()
+    for (const record of records) {
+      const location = persistence?.locate(record.header)
+      if (location === undefined) continue
+      try {
+        updated.set(record.header.id, (await stat(location.path)).mtimeMs)
+      } catch {
+        // Artifact gone or unreadable: the projection falls back to createdAt.
+      }
+    }
+    const projected = projectSessionRows(records, options, updated)
     // Titles are the expensive fold. Fetch only the first bounded picker page;
     // navigation/filter changes trigger a fresh, cancellable observation.
     const page = projected.slice(0, 32)
@@ -913,6 +1020,53 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     return mergeSessionTitles(projected, observations)
   }
 
+  /**
+   * Delete one session subtree (/delete, codex semantics: subagent threads go
+   * with their root). The kernel persistence seam has NO deletion API by
+   * design — logs accumulate "until removed externally" — so this is the
+   * controlled external removal: guards (live/current refusal, subtree
+   * collection, and the JSONL layout check `encodeSegment(id)/session.jsonl`)
+   * run before any filesystem touch, and only the backend-located artifacts
+   * are removed. Backends without a locatable artifact (SQLite) are refused.
+   * @param id - the root session id to delete.
+   * @returns the outcome line for the panel/notice.
+   */
+  const deleteSession = async (id: string): Promise<string> => {
+    if (sessionQuery === undefined) return 'session query is unavailable in this profile'
+    if (session !== undefined && session.id === id) return 'cannot delete the session you are using — switch or /new first'
+    const records = await sessionQuery.listSessions()
+    const target = records.find(record => record.header.id === id)
+    if (target === undefined) return `no persisted session matches "${id}"`
+    if (target.live) return 'cannot delete a live session — it is open in this or another process'
+    const doomed = collectDeletionSubtree(records, id)
+    const byId = new Map<string, (typeof records)[number]>(records.map(record => [record.header.id, record]))
+    let removed = 0
+    for (const candidate of doomed) {
+      const record = byId.get(candidate)
+      if (record === undefined || record.live) continue
+      const location = persistence?.locate(record.header)
+      if (location === undefined) {
+        return `session backend exposes no deletable artifact for ${candidate.slice(-12)} (deletion is unsupported on this backend)`
+      }
+      const dir = sessionArtifactDirectory(location.path, candidate)
+      if (dir === undefined) {
+        return `refusing to delete: unexpected artifact layout at ${location.path}`
+      }
+      try {
+        for (const name of SESSION_ARTIFACT_NAMES) {
+          await rm(join(dir, name), { force: true })
+        }
+        // Remove the now-empty session directory; a non-empty one stays (an
+        // unexpected sibling file is never ours to delete).
+        await rm(dir, { force: true, recursive: false }).catch(() => {})
+        removed += 1
+      } catch (error: unknown) {
+        return `delete failed for ${candidate.slice(-12)}: ${error instanceof Error ? error.message : String(error)}`
+      }
+    }
+    return `deleted ${removed} session${removed === 1 ? '' : 's'}`
+  }
+
   const loadSessionTranscript = async (id: string, signal?: AbortSignal): Promise<string> => {
     if (sessionQuery === undefined) throw new Error('session query is unavailable in this profile')
     const snapshot = await sessionQuery.readSession(id, signal)
@@ -966,6 +1120,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       session = next.session
       store = next.store
       mentions = next.mentions
+      subagents.reset()
       pendingMode = undefined
       pendingPermission = undefined
       commands.setAgent(agent)
@@ -1092,6 +1247,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     // process-local and create no durable state before that composition.
     const sessionCwd = session?.header.cwd ?? cwd
     const currentView = store.getView()
+    const defaults = currentDefaults()
     const model = currentView.model !== ''
       ? currentView.model
       : pendingSelection !== undefined
@@ -1110,6 +1266,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       store,
       approval,
       questions,
+      subagents,
       commands,
       skills,
       model,
@@ -1135,6 +1292,10 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       cyclePermission,
       setPermission: setPermissionAction,
       selectModel,
+      subagentModel: subagentModelLabel(),
+      setSubagentModel,
+      clearSubagentModel,
+      deleteSession,
       exportTranscript,
       renameTitle,
       loadPresets: () => presets.list(),
@@ -1145,6 +1306,12 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       createSession,
       loadSessions,
       loadSessionTranscript,
+      loadSubagents: () => {
+        const current = session
+        if (current === undefined || sessionQuery === undefined) return Promise.resolve([])
+        return loadSessions({ sessions: 'all', cwd: 'all', sort: 'newest', currentCwd: current.header.cwd ?? cwd, query: '' })
+          .then(rows => rows.filter(row => row.parent === current.id))
+      },
       switchSession,
       cancelSessionSwitch,
       loadPlugins: () => listPluginRows(ctx),