dsh-code 0.7.0 → 0.9.0

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,23 +33,45 @@ 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,
+  saveProviderCredential,
+  subscribeProviderSettings,
+  unsetProviderCredential,
+} from './provider-settings.ts'
 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 { appendHistoryContent, HISTORY_MAX_ENTRIES, parseHistoryFile } from './history.ts'
+import { HISTORY_MAX_ENTRIES, parseHistoryFile, serializeHistoryList } from './history.ts'
 import { watchSkills, type SkillsView } from './skills.ts'
 import { toolArgumentsPreview } from './render/tool-preview.ts'
 import { buildExportMarkdown } from './render/export.ts'
 import type { TuiStartup } from './startup.ts'
 import { SessionSwitchQueue } from './session-switch.ts'
-import { agentPresetsFrom, resolvePreset, switchPreset } from './presets.ts'
+import { agentPresetsFrom, resolvePreset, selectPreset } from './presets.ts'
+import {
+  applyPendingPermission,
+  cyclePermission as cyclePermissionPreset,
+  effectivePermission,
+  listPermissionRows,
+  permissionPresetsFrom,
+  selectPermission,
+} from './permissions.ts'
 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,
@@ -112,6 +134,64 @@ interface Target {
   cwd?: string
 }
 
+/**
+ * Reduce a session id to a filename-safe /export default-name suffix. Session
+ * ids are normally minted `session-<uuid>`, but `--session` accepts arbitrary
+ * user text: path separators must never leak into the default export filename
+ * (which would escape the session cwd).
+ * @param id - the session id.
+ * @returns at most the last 8 filename-safe characters.
+ */
+export function exportSessionIdSuffix(id: string): string {
+  return id.replace(/[^a-zA-Z0-9._-]/gu, '_').slice(-8)
+}
+
+/** One ordered step of the terminal quit cleanup. */
+export interface QuitCleanupStep {
+  /** Step label used in diagnostics and tests. */
+  readonly name: string
+  /** The step's async work; a rejection is contained by the sequence. */
+  readonly run: () => Promise<void>
+}
+
+/**
+ * Run the ordered quit cleanup, then request exit. Every step rejection is
+ * contained (reported through `onError`) so a failed flush or dispose never
+ * skips the remaining cleanup; the exit request is always reached exactly
+ * once.
+ * @param steps - the cleanup steps in dependency order (settle the visible
+ * session, await the final in-flight composition, await durable recall).
+ * @param exit - the terminal exit request (code 0).
+ * @param onError - optional failure sink; called once per failing step and
+ * itself contained, so a throwing sink cannot abort the sequence.
+ * @returns the names of the steps that started, in order (for tests).
+ */
+export async function runQuitSequence(
+  steps: readonly QuitCleanupStep[],
+  exit: (code: number) => void,
+  onError?: (name: string, error: unknown) => void,
+): Promise<readonly string[]> {
+  const started: string[] = []
+  for (const step of steps) {
+    started.push(step.name)
+    try {
+      await step.run()
+    } catch (error) {
+      try {
+        onError?.(step.name, error)
+      } catch {
+        // The failure sink must never abort the cleanup sequence.
+      }
+    }
+  }
+  try {
+    exit(0)
+  } catch {
+    // The exit request itself must not become an unhandled rejection.
+  }
+  return started
+}
+
 /**
  * Resolve the invocation's target session against the persisted headers.
  * @param startup - the parsed startup flags.
@@ -120,29 +200,37 @@ interface Target {
  * @returns the target identity.
  * @throws with a user-facing message when the flags name nothing resolvable.
  */
-async function resolveTarget(startup: TuiStartup, persistence: SessionPersistence | undefined, cwd: string): Promise<Target> {
+export async function resolveTarget(startup: TuiStartup, persistence: SessionPersistence | undefined, cwd: string): Promise<Target> {
   if (startup.kind === 'fresh') return { sessionId: `session-${randomUUID()}`, resume: false, mode: startup.mode }
-  if (startup.kind === 'named') return { sessionId: startup.sessionId, resume: false, mode: startup.mode }
+  if (startup.kind === 'named') {
+    // The id must not exist yet: reject before any Agent composition when the
+    // backend can tell us (a live collision is still caught by the session
+    // store at create time).
+    if (persistence !== undefined) {
+      const headers: readonly SessionHeader[] = await persistence.list()
+      if (headers.some(header => header.id === startup.sessionId)) {
+        throw new Error(`session "${startup.sessionId}" already exists; use --resume to continue it`)
+      }
+    }
+    return { sessionId: startup.sessionId, resume: false, mode: startup.mode }
+  }
   if (persistence === undefined) {
     throw new Error('cannot resolve the requested session: session persistence is not configured')
   }
   const headers: readonly SessionHeader[] = await persistence.list()
   if (startup.kind === 'resume') {
-    const wanted = startup.sessionId
-    const exact = headers.filter(header => header.id === wanted)
-    const matches = exact.length > 0 ? exact : headers.filter(header => header.id.startsWith(wanted))
-    if (matches.length === 0) throw new Error(`no persisted session matches "${wanted}"`)
-    if (matches.length > 1) {
-      throw new Error(`session prefix "${wanted}" is ambiguous (${matches.length} matches): use more of the id`)
-    }
-    return { sessionId: matches[0]!.id, resume: true }
-  }
-  // --continue: the newest persisted session whose header pins this cwd.
-  const local = headers
-    .filter(header => header.cwd === cwd)
-    .sort((left, right) => right.createdAt - left.createdAt)
-  if (local.length === 0) throw new Error(`no persisted session for this directory (${cwd}); start one without --continue`)
-  return { sessionId: local[0]!.id, resume: true }
+    const matched = matchSessionId(headers, startup.sessionId)
+    // Subagent conversations are read-only everywhere else; the CLI must not
+    // be a back door into appending root turns to a child's durable log.
+    if (isSubagentSession(matched)) {
+      throw new Error('subagent conversations are read-only; resume a root session')
+    }
+    return { sessionId: matched.id, resume: true }
+  }
+  // --continue: the newest persisted ROOT session whose header pins this cwd.
+  const newest = newestRootForCwd(headers, cwd)
+  if (newest === undefined) throw new Error(`no persisted session for this directory (${cwd}); start one without --continue`)
+  return { sessionId: newest.id, resume: true }
 }
 
 /**
@@ -190,9 +278,13 @@ 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)
 
   // A bare fresh launch stays transient: no Agent or session is composed, and
   // nothing is persisted, until the user's first real input. Explicit flags
@@ -219,7 +311,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     const selectionState: { picked?: ModelSelection } = pendingSelection === undefined
       ? {}
       : { picked: pendingSelection }
-    let mode = next.mode
+    let mode = next.resume ? next.mode : next.mode ?? pendingMode
     if (!next.resume) mode = (await presets.resolve(mode)).id
     const setup = async (agentCtx: Context): Promise<void> => {
       const sessionPreset = next.resume
@@ -229,26 +321,38 @@ 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,
         setup,
       })
       : 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,
       })
     const session = handle.agent.session
+    if (!next.resume && permissionPresets !== undefined) {
+      applyPendingPermission(permissionPresets, session, pendingPermission)
+    }
     const sessionCwd = session.header.cwd ?? nextCwd
     return {
       handle,
@@ -266,12 +370,53 @@ 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.
   let mentions: MentionsApi = createMentions(ctx, undefined, cwd)
   /** Explicit model pick made before any session exists (a bare launch). */
   let pendingSelection: ModelSelection | undefined
+  /** Agent preset selected before the first session exists. */
+  let pendingMode: string | undefined
+  /** Ordered pre-session preset resolutions; first composition awaits them. */
+  let pendingModeWork: Promise<void> = Promise.resolve()
+  /** Permission preset selected before the first session exists. */
+  let pendingPermission: string | undefined
+  /**
+   * Monotonic session epoch: bumped on every successful activation, on every
+   * first-session creation, and on quit. Async callbacks (mention prepares,
+   * command executions) capture it at call time and drop their result when it
+   * changed, so a stale callback can never deliver to an agent that is no
+   * longer on screen.
+   */
+  let epoch = 0
+  /** Aborted on quit: an in-flight agent composition (create/resume) races this signal. */
+  const quitAbort = new AbortController()
+  /** In-flight mention-prepare / command-execute controllers, aborted on any session transition. */
+  const pendingControllers = new Set<AbortController>()
+  const abortPendingControllers = (): void => {
+    for (const controller of [...pendingControllers]) {
+      pendingControllers.delete(controller)
+      controller.abort()
+    }
+  }
+  /** The in-flight session-composition turn (create/resume/activate), if any. */
+  let composing: Promise<void> | undefined
+  /**
+   * Run one session composition exclusively: concurrent compositions wait
+   * their turn, so a bare-launch first-session creation and a /resume
+   * activation can never compose agents in parallel (the loser would leak its
+   * agent or mis-deliver). Errors propagate to the caller; the shared slot
+   * always continues.
+   */
+  const compose = (work: () => Promise<void>): Promise<void> => {
+    const turn = (composing ?? Promise.resolve()).catch(() => {}).then(work)
+    composing = turn.catch(() => {})
+    return turn
+  }
 
   if (!lazy) {
     const target = await resolveTarget(startup, persistence, cwd)
@@ -288,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)
@@ -306,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.
@@ -378,18 +555,17 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   } catch {
     inputHistory = []
   }
+  /** Serialized history writes: each submission rewrites the latest in-memory snapshot. */
+  let historyWriteChain: Promise<void> = Promise.resolve()
   const recordHistory = (text: string): void => {
     if (text === '') return
     inputHistory = [...inputHistory, text].slice(-HISTORY_MAX_ENTRIES)
-    // A missing file on the first save is not an error: start from empty.
-    let current = ''
-    try {
-      current = readFileSync(historyPath, 'utf8')
-    } catch {
-      current = ''
-    }
-    void mkdir(dirname(historyPath), { recursive: true })
-      .then(() => writeFileAsync(historyPath, appendHistoryContent(current, text), 'utf8'))
+    // Write the whole current list, serialized per submission: the file is
+    // never read back on the submit path, so rapid same-process submissions
+    // cannot lose entries to a read-modify-write race.
+    historyWriteChain = historyWriteChain
+      .then(() => mkdir(dirname(historyPath), { recursive: true }))
+      .then(() => writeFileAsync(historyPath, serializeHistoryList(inputHistory), 'utf8'))
       .catch((writeError: unknown) => {
         bridge.notify('history save failed: ' + (writeError instanceof Error ? writeError.message : String(writeError)), 'error')
       })
@@ -415,37 +591,43 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     if (quitting) return
     quitting = true
     switchQueue.cancel()
+    // Stale prepares/commands die with the session they were for. Aborting
+    // the composition signal lets a never-settling prepare reject, so the
+    // exit wait below cannot hang (upstream rolls the creation back).
+    abortPendingControllers()
+    quitAbort.abort()
+    epoch += 1
     off()
     mountRef.current?.unmount()
-    // A bare launch that exits before the first input has no session: exit
-    // cleanly without flushing or disposing anything.
     const currentSession = session
     const currentActive = active
-    if (currentSession === undefined || currentActive === undefined) {
-      io.exit(0)
-      return
+    const report = (name: string, error: unknown): void => {
+      internals.stderr.write(`dsh: quit ${name} failed: ${error instanceof Error ? error.message : String(error)}\n`)
     }
-    void sessions.flush(currentSession)
-      .catch((flushError: unknown) => {
-        // The session log already carries every durable event; a failed flush
-        // must not trap the user in a dead terminal, so report and still exit.
-        internals.stderr.write(`dsh: session flush failed: ${flushError instanceof Error ? flushError.message : String(flushError)}\n`)
-      })
-      .then(() => currentActive.handle.dispose())
-      .catch((disposeError: unknown) => {
-        internals.stderr.write(`dsh: agent disposal failed: ${disposeError instanceof Error ? disposeError.message : String(disposeError)}\n`)
-      })
-      .then(() => { io.exit(0) })
+    // One ordered cleanup: settle the visible session (if any — a bare launch
+    // that never composed one resolves immediately), then wait for the final
+    // in-flight composition (its work swallows errors and the quitting guard
+    // disposes any half-prepared agent), then flush the durable recall, then
+    // request exit. `composing` and `historyWriteChain` are read at step run
+    // time, so a turn that was still being queued when quit ran is included.
+    // A failing step must never skip the remaining cleanup.
+    const steps: QuitCleanupStep[] = [
+      ...(currentSession === undefined || currentActive === undefined
+        ? []
+        : [
+          { name: 'flush', run: async () => { await sessions.flush(currentSession) } },
+          { name: 'dispose', run: () => currentActive.handle.dispose() },
+        ]),
+      { name: 'composing', run: () => composing ?? Promise.resolve() },
+      { name: 'history', run: () => historyWriteChain },
+    ]
+    void runQuitSequence(steps, io.exit, report)
   }
 
   /** Run one slash line through the command registry (closed namespace). */
   const runSlash = (line: string): void => {
     const currentAgent = agent
     if (currentAgent === undefined) return
-    if (line.startsWith('/mode ')) {
-      void switchModeAction(line.slice(6).trim())
-      return
-    }
     if (line.startsWith('/resume ')) {
       requestResume(line.slice(8).trim())
       return
@@ -456,7 +638,16 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       return
     }
     const controller = new AbortController()
+    const atEpoch = epoch
+    pendingControllers.add(controller)
+    const finish = (): void => {
+      pendingControllers.delete(controller)
+    }
     void Promise.resolve().then(() => registry.execute(currentAgent, line, controller.signal)).then((execution) => {
+      finish()
+      // A switch/quit landed while the command ran: its fall-through must not
+      // reach an agent that is no longer on screen.
+      if (epoch !== atEpoch || agent !== currentAgent) return
       if (execution === undefined) {
         // No command owns this line: send it verbatim so a user-invocable
         // skill gesture (`/skill-name`) reaches the host's tool-skill
@@ -471,6 +662,8 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
         }
       }
     }, (error: unknown) => {
+      finish()
+      if (epoch !== atEpoch || agent !== currentAgent) return
       bridge.notify(`command failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
     })
   }
@@ -493,7 +686,11 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       bridge.notify(`invalid session reference: ${error instanceof Error ? error.message : String(error)}`, 'error')
       return
     }
+    const atEpoch = epoch
     const deliver = (readable: string, context?: UserMessage): void => {
+      // A switch/quit landed while the snapshot was being prepared: never
+      // deliver to an agent that is no longer on screen.
+      if (epoch !== atEpoch || agent !== currentAgent) return
       // Session snapshots ride the inbox as model-facing context ahead of
       // the readable message (upstream README wiring: inject before the
       // followup/steer that wakes the driver).
@@ -519,10 +716,13 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       return
     }
     const controller = new AbortController()
+    pendingControllers.add(controller)
     void currentMentions.prepare(parsed, controller.signal).then((prepared) => {
+      pendingControllers.delete(controller)
       deliver(prepared.text, prepared.additionalContext)
     }, (error: unknown) => {
-      if (controller.signal.aborted) return
+      pendingControllers.delete(controller)
+      if (controller.signal.aborted || epoch !== atEpoch) return
       bridge.notify(`session reference failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
     })
   }
@@ -533,47 +733,84 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   // failure reports and clears the queue, leaving the transient state ready
   // for the next attempt.
   const pendingInputs: Array<{ text: string; mode: 'followup' | 'steer' }> = []
-  let creating: Promise<void> | undefined
+  // A creation is queued/running: further submissions must not mint more
+  // fresh sessions (their lines queue into pendingInputs instead).
+  let creating = false
   const ensureSession = (mode?: string): void => {
-    if (creating !== undefined) return
-    const attempt = (async () => {
-      const next = await prepare({
-        sessionId: `session-${randomUUID()}`,
-        resume: false,
-        ...(mode === undefined ? {} : { mode }),
-      })
-      if (quitting) {
-        void next.handle.dispose().catch(() => {})
-        return
+    if (creating) return
+    creating = true
+    void compose(async () => {
+      try {
+        // A direct `/mode <preset>` resolves asynchronously. Preserve submit
+        // order so the first composition cannot race ahead with the old mode.
+        await pendingModeWork
+        // Another composition (e.g. a /resume activated while this creation
+        // waited its turn) may have published a session already: deliver the
+        // queued lines there instead of minting a competing fresh session
+        // (which would orphan the live one without a dispose).
+        if (session !== undefined) {
+          const queued = pendingInputs.splice(0)
+          for (const item of queued) deliverLine(item.text, item.mode)
+          return
+        }
+        const next = await prepare({
+          sessionId: `session-${randomUUID()}`,
+          resume: false,
+          ...(mode === undefined ? {} : { mode }),
+        })
+        if (quitting) {
+          void next.handle.dispose().catch(() => {})
+          return
+        }
+        active = next
+        agent = next.agent
+        session = next.session
+        store = next.store
+        mentions = next.mentions
+        subagents.reset()
+        pendingMode = undefined
+        pendingPermission = undefined
+        commands.setAgent(agent)
+        skills.setAgent(agent)
+        // The App mounts with a placeholder key until the first input; the
+        // key-change remount below must start from a clean screen or the ghost
+        // static header stays visible above the new one (same source-backed
+        // clear the session-switch path performs).
+        process.stdout.write('\x1b[r\x1b[0m\x1b[H\x1b[2J\x1b[3J\x1b[H')
+        renderCurrent()
+        abortPendingControllers()
+        epoch += 1
+        const queued = pendingInputs.splice(0)
+        for (const item of queued) deliverLine(item.text, item.mode)
+      } finally {
+        creating = false
       }
-      active = next
-      agent = next.agent
-      session = next.session
-      store = next.store
-      mentions = next.mentions
-      commands.setAgent(agent)
-      skills.setAgent(agent)
-      // The App mounts with a placeholder key until the first input; the
-      // key-change remount below must start from a clean screen or the ghost
-      // static header stays visible above the new one (same source-backed
-      // clear the session-switch path performs).
-      process.stdout.write('\x1b[r\x1b[0m\x1b[H\x1b[2J\x1b[3J\x1b[H')
-      renderCurrent()
-      const queued = pendingInputs.splice(0)
-      for (const item of queued) deliverLine(item.text, item.mode)
-    })().catch((error: unknown) => {
+    }).catch((error: unknown) => {
       pendingInputs.length = 0
       bridge.notify(`session creation failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
-    }).finally(() => {
-      creating = undefined
     })
-    creating = attempt
   }
 
   /** Deliver one readable line to the agent, expanding session mentions first. */
   const send = (text: string, mode: 'followup' | 'steer'): void => {
     const line = text.trim()
     if (line === '') return
+    if (line.startsWith('/mode ')) {
+      void switchModeAction(line.slice(6).trim()).then(
+        selected => bridge.notify(`mode → ${selected}`),
+        error => bridge.notify(`mode switch failed: ${error instanceof Error ? error.message : String(error)}`, 'error'),
+      )
+      return
+    }
+    if (line.startsWith('/permission ')) {
+      try {
+        const selected = setPermissionAction(line.slice(12).trim())
+        bridge.notify(`permission → ${selected}`)
+      } catch (error: unknown) {
+        bridge.notify(`permission change failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+      }
+      return
+    }
     if (session === undefined) {
       pendingInputs.push({ text: line, mode })
       ensureSession()
@@ -609,29 +846,36 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     }
   }
 
+  /** Select one permission preset before the first session or on the active one. */
+  const setPermissionAction = (id: string): string => {
+    if (permissionPresets === undefined || permissionPresets.names.length === 0) {
+      throw new Error('permission presets are not mounted in this composition')
+    }
+    if (id === '') throw new Error('usage: /permission <preset>')
+    const selected = selectPermission(permissionPresets, session, id)
+    if (session === undefined) {
+      pendingPermission = selected
+      renderCurrent()
+    }
+    return selected
+  }
+
   /**
-   * Cycle to the next permission preset (Shift+Tab, the Claude-Code
-   * permission-mode convention mapped onto dsh presets). A session in a
-   * custom knob state wraps to the first declared preset.
+   * Cycle to the next permission preset (Shift+Tab). Before the first session,
+   * the choice remains process-local and is materialized when Harness creates
+   * that session; afterwards the canonical service writes durable events.
    */
   const cyclePermission = (): string => {
-    if (session === undefined) throw new Error('no session yet — submit a message to start')
-    const service = ctx.get('permissionPresets') as
-      | {
-        names: readonly string[]
-        current(events: readonly SessionEvent[]): string
-        set(target: Session, preset: string): void
-      }
-      | undefined
-    if (service === undefined || service.names.length === 0) {
+    if (permissionPresets === undefined || permissionPresets.names.length === 0) {
       bridge.notify('permission presets are not mounted in this composition', 'warning')
       return ''
     }
-    const at = service.names.indexOf(service.current(session.events))
-    const next = service.names[(at + 1) % service.names.length] ?? ''
-    if (next === '') return ''
     try {
-      service.set(session, next)
+      const next = cyclePermissionPreset(permissionPresets, session, pendingPermission)
+      if (session === undefined && next !== '') {
+        pendingPermission = next
+        renderCurrent()
+      }
       return next
     } catch (error: unknown) {
       bridge.notify(`permission change failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
@@ -654,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
@@ -669,7 +957,10 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     }
     const wanted = argument.trim()
     const sessionCwd = session.header.cwd ?? cwd
-    const defaultName = `dsh-session-${session.id.slice(-8)}.md`
+    // The default name derives from the session id, which `--session` lets the
+    // user spell freely: reduce it to filename-safe characters first so the
+    // default target can never escape the session cwd.
+    const defaultName = `dsh-session-${exportSessionIdSuffix(session.id)}.md`
     const target = wanted === ''
       ? join(sessionCwd, defaultName)
       : /^[a-zA-Z]:[\\/]/u.test(wanted) || wanted.startsWith('/')
@@ -705,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)
@@ -714,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)
@@ -723,12 +1076,24 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   const switchModeAction = async (id: string): Promise<string> => {
     if (id === '') throw new Error('usage: /mode <preset>')
     const currentAgent = agent
-    const currentActive = active
-    if (currentAgent === undefined || currentActive === undefined) {
-      throw new Error('no session yet — submit a message to start')
+    if (currentAgent === undefined) {
+      const choice = pendingModeWork.then(async () => {
+        const preset = await selectPreset(presets, undefined, id)
+        // A resume may have won while this roster read was in flight; never
+        // leak the old pending choice into a later /new session.
+        if (agent === undefined) {
+          pendingMode = preset.id
+          renderCurrent()
+        }
+        return preset.id
+      })
+      pendingModeWork = choice.then(() => {}, () => {})
+      return choice
     }
-    const preset = await switchPreset(presets, currentAgent, id)
-    currentActive.mode = preset.id
+
+    const preset = await selectPreset(presets, currentAgent, id)
+    if (active === undefined) throw new Error('active Agent has no session state')
+    active.mode = preset.id
     commands.setAgent(currentAgent)
     skills.setAgent(currentAgent)
     renderCurrent()
@@ -737,52 +1102,70 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
 
   interface PendingSwitch { readonly target: Target; readonly label: string }
 
-  const activate = async (nextTarget: Target): Promise<void> => {
-    const previous = active
-    const next = await prepare(nextTarget)
-    active = next
-    agent = next.agent
-    session = next.session
-    store = next.store
-    mentions = next.mentions
-    commands.setAgent(agent)
-    skills.setAgent(agent)
-    try {
-      process.stdout.write('\x1b[r\x1b[0m\x1b[H\x1b[2J\x1b[3J\x1b[H')
-      renderCurrent()
-    } catch (error: unknown) {
-      active = previous
-      agent = previous?.agent
-      session = previous?.session
-      store = previous === undefined ? createTranscriptStore() : previous.store
-      mentions = previous === undefined ? createMentions(ctx, undefined, cwd) : previous.mentions
-      if (agent !== undefined) commands.setAgent(agent)
-      if (agent !== undefined) skills.setAgent(agent)
-      await next.handle.dispose()
-      renderCurrent()
-      throw error
-    }
-    // No previous session (a bare launch switched straight into a resume):
-    // nothing to flush or dispose, so just confirm the activation.
-    if (previous === undefined) {
-      bridge.notify(`${next.resumed ? 'resumed' : 'created'} ${next.session.id.slice(-12)} · mode ${next.mode}`)
-      return
-    }
-    let cleanupWarning: string | undefined
-    try {
-      await sessions.flush(previous.session)
-    } catch (error: unknown) {
-      cleanupWarning = `previous session flush failed: ${error instanceof Error ? error.message : String(error)}`
-    }
-    try {
-      await previous.handle.dispose()
-    } catch (error: unknown) {
-      cleanupWarning = `${cleanupWarning === undefined ? '' : `${cleanupWarning}; `}previous agent release failed: ${error instanceof Error ? error.message : String(error)}`
-    }
-    bridge.notify(cleanupWarning === undefined
-      ? `${next.resumed ? 'resumed' : 'created'} ${next.session.id.slice(-12)} · mode ${next.mode}`
-      : `switched to ${next.session.id.slice(-12)}, but ${cleanupWarning}`,
-    cleanupWarning === undefined ? 'info' : 'warning')
+  const activate = (nextTarget: Target): Promise<void> => {
+    if (quitting) return Promise.resolve()
+    // Serialized with every other composition (bare-launch creation, queued
+    // switches): at most one agent is composed at a time.
+    return compose(async () => {
+      const previous = active
+      const next = await prepare(nextTarget)
+      // Quit landed while the next session was being composed: dispose the
+      // half-ready agent and leave the current session untouched.
+      if (quitting) {
+        await next.handle.dispose().catch(() => {})
+        return
+      }
+      active = next
+      agent = next.agent
+      session = next.session
+      store = next.store
+      mentions = next.mentions
+      subagents.reset()
+      pendingMode = undefined
+      pendingPermission = undefined
+      commands.setAgent(agent)
+      skills.setAgent(agent)
+      try {
+        process.stdout.write('\x1b[r\x1b[0m\x1b[H\x1b[2J\x1b[3J\x1b[H')
+        renderCurrent()
+      } catch (error: unknown) {
+        active = previous
+        agent = previous?.agent
+        session = previous?.session
+        store = previous === undefined ? createTranscriptStore() : previous.store
+        mentions = previous === undefined ? createMentions(ctx, undefined, cwd) : previous.mentions
+        if (agent !== undefined) commands.setAgent(agent)
+        if (agent !== undefined) skills.setAgent(agent)
+        await next.handle.dispose()
+        if (!quitting) renderCurrent()
+        throw error
+      }
+      // From here the new session is live: in-flight prepares/commands for
+      // the previous agent are stale and must be aborted and ignored.
+      abortPendingControllers()
+      epoch += 1
+      // No previous session (a bare launch switched straight into a resume):
+      // nothing to flush or dispose, so just confirm the activation.
+      if (previous === undefined) {
+        bridge.notify(`${next.resumed ? 'resumed' : 'created'} ${next.session.id.slice(-12)} · mode ${next.mode}`)
+        return
+      }
+      let cleanupWarning: string | undefined
+      try {
+        await sessions.flush(previous.session)
+      } catch (error: unknown) {
+        cleanupWarning = `previous session flush failed: ${error instanceof Error ? error.message : String(error)}`
+      }
+      try {
+        await previous.handle.dispose()
+      } catch (error: unknown) {
+        cleanupWarning = `${cleanupWarning === undefined ? '' : `${cleanupWarning}; `}previous agent release failed: ${error instanceof Error ? error.message : String(error)}`
+      }
+      bridge.notify(cleanupWarning === undefined
+        ? `${next.resumed ? 'resumed' : 'created'} ${next.session.id.slice(-12)} · mode ${next.mode}`
+        : `switched to ${next.session.id.slice(-12)}, but ${cleanupWarning}`,
+      cleanupWarning === undefined ? 'info' : 'warning')
+    })
   }
 
   const switchQueue = new SessionSwitchQueue<PendingSwitch>(
@@ -818,13 +1201,15 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     const matches = exact.length > 0 ? exact : records.filter(record => record.header.id.startsWith(wanted))
     if (matches.length === 0) throw new Error(`no session matches "${wanted}"`)
     if (matches.length > 1) throw new Error(`session prefix "${wanted}" is ambiguous (${matches.length} matches)`)
-    if (matches[0]!.header.parentSession !== undefined || matches[0]!.header.origin === 'subagent') {
-      throw new Error('subagent conversations are read-only in /resume; resume a root session')
+    const matched = matches[0]!
+    // Same lineage gate as the CLI --resume path and the picker.
+    if (isSubagentSession(matched.header)) {
+      throw new Error('subagent conversations are read-only; resume a root session')
     }
-    if (session !== undefined && agents.get(SessionId(matches[0]!.header.id)) !== undefined && matches[0]!.header.id !== session.id) {
+    if (session !== undefined && agents.get(SessionId(matched.header.id)) !== undefined && matched.header.id !== session.id) {
       throw new Error('that session is already live in another owner')
     }
-    return matches[0]!.header.id
+    return matched.header.id
   }
 
   const requestResume = (wanted: string): void => {
@@ -857,13 +1242,14 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   }
 
   const appElement = (): ReturnType<typeof createElement> => {
-    // A bare launch mounts with placeholder facts until the first input
-    // composes a real session: empty session id/mode, the deployment default
-    // model, and the working directory's basename. `status.ts` drops empty
-    // mode/sessionId, so the bar renders only the identity it actually has.
+    // A bare launch mounts with pending/default model, mode, and permission
+    // facts until the first input composes the real session. These choices stay
+    // process-local and create no durable state before that composition.
     const sessionCwd = session?.header.cwd ?? cwd
-    const model = store.getView().model !== ''
-      ? store.getView().model
+    const currentView = store.getView()
+    const defaults = currentDefaults()
+    const model = currentView.model !== ''
+      ? currentView.model
       : pendingSelection !== undefined
         ? `${pendingSelection.provider}/${pendingSelection.model}`
         : `${defaults.provider}/${defaults.model}`
@@ -872,11 +1258,15 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       session?.requestHeader()?.config,
       defaults,
     ).reasoningEffort
+    const permission = permissionPresets === undefined
+      ? currentView.permission
+      : effectivePermission(permissionPresets, session, pendingPermission)
     return createElement(App, {
       key: session?.id ?? 'pending',
       store,
       approval,
       questions,
+      subagents,
       commands,
       skills,
       model,
@@ -886,22 +1276,42 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       branch: gitBranch(sessionCwd),
       sessionId: session === undefined ? '' : session.id.slice(-8),
       resumed: active?.resumed ?? false,
-      mode: active?.mode ?? '',
+      mode: active?.mode ?? pendingMode ?? presets.defaultId,
+      permission,
       dispatch,
       steer,
       interrupt,
       quit,
       loadModels: () => loadModelDirectory(ctx),
+      loadModelProviders: () => loadProviderSettings(ctx),
+      subscribeModelProviders: listener => subscribeProviderSettings(ctx, listener),
+      saveModelProviderCredential: (target, key) => saveProviderCredential(ctx, target, key),
+      unsetModelProviderCredential: target => unsetProviderCredential(ctx, target),
+      removeModelProvider: target => removeProviderSettings(ctx, target),
       loadMentions: (query: string, signal?: AbortSignal) => mentions.candidates(query, signal),
       cyclePermission,
+      setPermission: setPermissionAction,
       selectModel,
+      subagentModel: subagentModelLabel(),
+      setSubagentModel,
+      clearSubagentModel,
+      deleteSession,
       exportTranscript,
       renameTitle,
       loadPresets: () => presets.list(),
       switchMode: switchModeAction,
+      loadPermissions: () => permissionPresets === undefined
+        ? Promise.reject(new Error('permission presets are not mounted in this composition'))
+        : Promise.resolve(listPermissionRows(permissionPresets)),
       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),