dsh-code 0.5.0 → 0.6.0

package/src/history.ts

@@ -0,0 +1,136 @@
+/**
+ * Global input recall: persistent cross-session entries plus this process's
+ * submissions, with Codex `ChatComposerHistory` semantics — empty submissions
+ * are ignored, adjacent duplicates collapse, the recall space skips
+ * persistent entries that duplicate a local one (local wins), and Up/Down
+ * navigation is gated so interior cursor movement never hijacks the draft.
+ *
+ * @module @deepseek-ai/dsh-tui/history
+ */
+
+/** Maximum entries retained in the persistent history file. */
+export const HISTORY_MAX_ENTRIES = 500
+
+/** Encode one entry for the history file (JSON keeps multi-line drafts intact). */
+export function serializeHistoryEntry(text: string): string {
+  return JSON.stringify(text)
+}
+
+/**
+ * Parse a persisted history file (one JSON entry per line): invalid lines
+ * drop out, empty entries are ignored, adjacent duplicates collapse, and the
+ * result keeps only the newest `max` entries.
+ * @param raw - file content, empty for a missing file.
+ * @param max - entry cap.
+ * @returns persistent entries, oldest first.
+ */
+export function parseHistoryFile(raw: string, max = HISTORY_MAX_ENTRIES): readonly string[] {
+  const kept: string[] = []
+  for (const line of raw.split('\n')) {
+    if (line === '') continue
+    let text: unknown
+    try {
+      text = JSON.parse(line)
+    } catch {
+      continue
+    }
+    if (typeof text !== 'string' || text === '') continue
+    if (kept.length > 0 && kept[kept.length - 1] === text) continue
+    kept.push(text)
+  }
+  return kept.slice(-max)
+}
+
+/**
+ * Append one entry to the persistent file content: JSON line, capped to the
+ * newest `max` entries with a trailing newline.
+ * @param current - existing file content.
+ * @param text - submission to persist.
+ * @param max - entry cap.
+ * @returns the new file content.
+ */
+export function appendHistoryContent(current: string, text: string, max = HISTORY_MAX_ENTRIES): string {
+  const entries = [...parseHistoryFile(current, max), text].slice(-max)
+  return entries.map(serializeHistoryEntry).join('\n') + '\n'
+}
+
+/**
+ * Record one in-session submission: empty text is ignored and an adjacent
+ * duplicate collapses (Codex `record_local_submission` semantics).
+ * @param local - current in-session entries, oldest first.
+ * @param text - the submitted prompt.
+ * @returns the updated local list.
+ */
+export function recordLocalEntry(local: readonly string[], text: string): readonly string[] {
+  if (text === '') return local
+  if (local.length > 0 && local[local.length - 1] === text) return local
+  return [...local, text]
+}
+
+/**
+ * Build the recall space, newest first: local entries, then persistent
+ * entries whose text is not duplicated locally (the local copy wins and the
+ * persistent twin is skipped — Codex's replay-seed dedup, applied to the
+ * whole local set).
+ * @param persistent - cross-session entries, oldest first.
+ * @param local - this process's submissions, oldest first.
+ * @returns recall entries, newest first.
+ */
+export function recallEntries(persistent: readonly string[], local: readonly string[]): readonly string[] {
+  const localSet = new Set(local)
+  return [...persistent.filter(entry => !localSet.has(entry)), ...local].reverse()
+}
+
+/** Shell-style recall navigation over a fixed recall space. */
+export interface RecallState {
+  /** Recall entries, newest first (frozen at navigation start). */
+  entries: readonly string[]
+  /** Current recall index; null when not browsing. */
+  index: number | null
+  /** Draft saved when browsing started; restored on Down past the newest. */
+  savedDraft: string
+  /** The recalled text currently in the composer (the boundary gate's anchor). */
+  lastRecalled: string | null
+}
+
+/** Fresh navigation state over one recall space. */
+export function beginRecall(entries: readonly string[], draft: string): RecallState {
+  return { entries, index: null, savedDraft: draft, lastRecalled: null }
+}
+
+/** The outcome of one recall step. */
+export interface RecallStep {
+  state: RecallState
+  /** The text to place in the composer; undefined means "no movement". */
+  entry: string | undefined
+}
+
+/**
+ * Move one entry older (Up, toward index +1 in the newest-first space). The
+ * first Up saves the current draft so Down past the newest can restore it
+ * (Claude-Code shell recall — the draft is never lost); the oldest entry
+ * stays put.
+ * @param state - current navigation state.
+ * @param draft - the composer text to preserve when browsing starts.
+ */
+export function recallOlder(state: RecallState, draft: string): RecallStep {
+  if (state.index === null) {
+    const entry = state.entries[0]
+    if (entry === undefined) return { state, entry: undefined }
+    return { state: { ...state, index: 0, savedDraft: draft, lastRecalled: entry }, entry }
+  }
+  if (state.index >= state.entries.length - 1) return { state, entry: undefined }
+  const entry = state.entries[state.index + 1]
+  return { state: { ...state, index: state.index + 1, lastRecalled: entry }, entry }
+}
+
+/** Move one entry newer (Down, toward index 0); past the newest, browsing ends and the saved draft returns. */
+export function recallNewer(state: RecallState): RecallStep {
+  if (state.index === null) return { state, entry: undefined }
+  const next = state.index - 1
+  if (next < 0) {
+    return { state: { ...state, index: null, lastRecalled: null }, entry: state.savedDraft }
+  }
+  const entry = state.entries[next]
+  return { state: { ...state, index: next, lastRecalled: entry }, entry }
+}

package/src/index.ts

@@ -11,15 +11,16 @@
 
 import { randomUUID } from 'node:crypto'
 import { readFileSync } from 'node:fs'
-import { writeFile as writeFileAsync } from 'node:fs/promises'
-import { basename, join } from 'node:path'
+import { homedir } from 'node:os'
+import { mkdir, 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'
 import z from '@deepseek-ai/schemastery'
 import { installModelSelection } from '@deepseek-ai/dsh-agent'
 import type { Agent, AgentHandle, ModelSelection, ModelSelectionRef } from '@deepseek-ai/dsh-agent'
 import type {} from '@deepseek-ai/dsh-agent-default-model'
-import { createUserMessage } from '@deepseek-ai/dsh-llm'
+import { createUserMessage, MessageId } from '@deepseek-ai/dsh-llm'
 import { SessionId, type Session, type SessionEvent, type SessionHeader, type UserMessage } from '@deepseek-ai/dsh-session'
 import type { SessionPersistence } from '@deepseek-ai/dsh-session-persistence'
 // Type-only: carries the ctx.sessionTitle service merge for /title.
@@ -33,9 +34,11 @@ import { mountApprovalAnswerer, type ApprovalStore } from './approval.ts'
 import { isSlashLine, watchCommands, type CommandsView } from './commands.ts'
 import { internals, type TuiMount } from './internals.ts'
 import { loadModelDirectory, type ModelRow } from './models.ts'
-import { createMentions, type MentionsApi } from './mentions.ts'
+import { createMentions, type MentionCandidate, type MentionsApi } from './mentions.ts'
 import { mountQuestionProvider, type QuestionStore } from './questions.ts'
-import { createTranscriptStore } from './store.ts'
+import { createTranscriptStore, type TranscriptStore } from './store.ts'
+import { parseStatuslineItems } from './render/status.ts'
+import { appendHistoryContent, HISTORY_MAX_ENTRIES, parseHistoryFile } from './history.ts'
 import { watchSkills, type SkillsView } from './skills.ts'
 import { toolArgumentsPreview } from './render/tool-preview.ts'
 import { buildExportMarkdown } from './render/export.ts'
@@ -185,11 +188,15 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   if (agents === undefined || defaultModel === undefined || sessions === undefined) return
 
   const cwd = process.cwd()
-  const target = await resolveTarget(startup, persistence, cwd)
   const defaults = defaultModel.currentSelection()
   const presets = agentPresetsFrom(ctx)
   if (presets === undefined) throw new Error('agent preset service is unavailable; check the dsh-code bundle patch')
 
+  // 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
+  // (--resume/--continue/--session/--mode) keep the eager create/resume path.
+  const lazy = startup.kind === 'fresh' && startup.mode === undefined
+
   interface ActiveSession {
     handle: AgentHandle
     agent: Agent
@@ -257,30 +264,42 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     }
   }
 
-  let active = await prepare(target)
-  let agent = active.agent
-  let session = active.session
-  let store = active.store
-  let mentions = active.mentions
+  let active: ActiveSession | undefined
+  let agent: Agent | undefined
+  let session: Session | undefined
+  let store: TranscriptStore = createTranscriptStore()
+  let mentions: MentionsApi | undefined
+
+  if (!lazy) {
+    const target = await resolveTarget(startup, persistence, cwd)
+    const prepared = await prepare(target)
+    active = prepared
+    agent = prepared.agent
+    session = prepared.session
+    store = prepared.store
+    mentions = prepared.mentions
+  }
 
   // Seed the transcript from the full session log: constructor seeds never
-  // fire on `session/event`, so a resumed session paints its history once,
-  // here, before the first render.
+  // fire on `session/event`, so a resumed session paints its history once
+  // 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 (subject.id === session.id) store.apply(event)
+    if (session !== undefined && subject.id === session.id) store.apply(event)
   })
 
   const commands: CommandsView = watchCommands(ctx)
-  commands.setAgent(agent)
+  if (agent !== undefined) commands.setAgent(agent)
 
   const skills: SkillsView = watchSkills(ctx)
-  skills.setAgent(agent)
+  if (agent !== undefined) skills.setAgent(agent)
 
   // Approval answerer: renders the ask as a y/n bar; only this TUI's agent is
-  // claimed, every other ask falls through to the fail-closed waterfall.
+  // claimed, every other ask falls through to the fail-closed waterfall. The
+  // owner predicate is empty until the first session exists.
   const approval: ApprovalStore = mountApprovalAnswerer(
     ctx,
-    candidate => candidate.id === agent.id,
+    candidate => agent !== undefined && candidate.id === agent.id,
     request => approvalCommandPreview(store.getView().entries, request.callId, request.toolName),
   )
 
@@ -293,6 +312,71 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   // process side (unknown commands, switch confirmations, cancels).
   const bridge: AppBridge = { notify: () => {} }
 
+  // /statusline persistence: one user-level JSON file under the DSH home.
+  // Missing file means defaults; a corrupt file degrades to defaults with a
+  // surfaced warning (the customization is user-authored, never silent).
+  const statuslinePath = join(homedir(), '.dsh', 'dsh-code', 'statusline.json')
+  let statuslineWarning: string | undefined
+  let statuslineItems: readonly string[] = []
+  try {
+    statuslineItems = parseStatuslineItems(JSON.parse(readFileSync(statuslinePath, 'utf8')).items)
+  } catch (error) {
+    statuslineItems = parseStatuslineItems(undefined)
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+      statuslineWarning = error instanceof Error ? error.message : String(error)
+    }
+  }
+  const saveStatusline = (items: readonly string[]): void => {
+    statuslineItems = [...items]
+    // The config directory may not exist on a first save; create it before
+    // the write so a fresh install persists customizations.
+    void mkdir(dirname(statuslinePath), { recursive: true })
+      .then(() => writeFileAsync(statuslinePath, JSON.stringify({ items }, null, 2) + '\n', 'utf8'))
+      .catch((writeError: unknown) => {
+        bridge.notify('statusline save failed: ' + (writeError instanceof Error ? writeError.message : String(writeError)), 'error')
+      })
+  }
+
+  // Global input recall (Codex composer-history contract): one JSONL file
+  // under the DSH home. A missing file means an empty history; unreadable or
+  // corrupt content degrades to the valid lines it could parse, silently —
+  // recall is a convenience surface, never a gate.
+  const historyPath = join(homedir(), '.dsh', 'dsh-code', 'history.jsonl')
+  let inputHistory: readonly string[] = []
+  try {
+    inputHistory = parseHistoryFile(readFileSync(historyPath, 'utf8'))
+  } catch {
+    inputHistory = []
+  }
+  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'))
+      .catch((writeError: unknown) => {
+        bridge.notify('history save failed: ' + (writeError instanceof Error ? writeError.message : String(writeError)), 'error')
+      })
+  }
+
+  /** Cancel one queued inbox message (Delete on the empty composer); the durable splice retires its pending row. */
+  const cancelQueued = (messageId: string): void => {
+    if (agent === undefined) return
+    try {
+      if (agent.inbox.remove(MessageId(messageId))) {
+        bridge.notify('queued message cancelled')
+      }
+    } catch (error: unknown) {
+      bridge.notify('queue cancel failed: ' + (error instanceof Error ? error.message : String(error)), 'error')
+    }
+  }
+
   // The mount handle lives in a box: quit closes over it, while the mount
   // itself is created after quit (the App element needs quit as a prop).
   const mountRef: { current?: TuiMount } = {}
@@ -303,13 +387,21 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     switchQueue.cancel()
     off()
     mountRef.current?.unmount()
-    void sessions.flush(session)
+    // 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
+    }
+    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(() => active.handle.dispose())
+      .then(() => currentActive.handle.dispose())
       .catch((disposeError: unknown) => {
         internals.stderr.write(`dsh: agent disposal failed: ${disposeError instanceof Error ? disposeError.message : String(disposeError)}\n`)
       })
@@ -318,6 +410,8 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
 
   /** 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
@@ -332,13 +426,13 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       return
     }
     const controller = new AbortController()
-    void Promise.resolve().then(() => registry.execute(agent, line, controller.signal)).then((execution) => {
+    void Promise.resolve().then(() => registry.execute(currentAgent, line, controller.signal)).then((execution) => {
       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
         // pre-step injection — the web composer's same fall-through.
         try {
-          agent.followup(createUserMessage({
+          currentAgent.followup(createUserMessage({
             content: [{ type: 'text', text: line }],
             source: { kind: 'user' },
           }))
@@ -351,10 +445,10 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     })
   }
 
-  /** 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
+  /** Deliver one trimmed line to the live session, expanding mentions first. */
+  const deliverLine = (line: string, mode: 'followup' | 'steer'): void => {
+    const currentAgent = agent!
+    const currentMentions = mentions!
     // The command registry is a closed namespace: slash lines run out of
     // band and never reach the model through this path (steering keeps the
     // registry out of the inbox, so slash lines steer as literal text).
@@ -362,9 +456,9 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       runSlash(line)
       return
     }
-    let parsed: ReturnType<typeof mentions.parse>
+    let parsed: ReturnType<MentionsApi['parse']>
     try {
-      parsed = mentions.parse(line)
+      parsed = currentMentions.parse(line)
     } catch (error: unknown) {
       bridge.notify(`invalid session reference: ${error instanceof Error ? error.message : String(error)}`, 'error')
       return
@@ -374,16 +468,17 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       // the readable message (upstream README wiring: inject before the
       // followup/steer that wakes the driver).
       try {
-        if (context !== undefined) agent.inject(context)
+        if (context !== undefined) currentAgent.inject(context)
         const message = createUserMessage({
           content: [{ type: 'text', text: readable }],
           source: { kind: 'user' },
         })
         if (mode === 'steer') {
-          agent.steer(message)
-          bridge.notify('steering queued — the next step sees it')
+          // The queued message is visible as a pending transcript row (the
+          // web queue-mirror contract); no notice noise on the happy path.
+          currentAgent.steer(message)
         } else {
-          agent.followup(message)
+          currentAgent.followup(message)
         }
       } catch (error: unknown) {
         bridge.notify(`${mode === 'steer' ? 'steering' : 'message'} failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
@@ -394,7 +489,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       return
     }
     const controller = new AbortController()
-    void mentions.prepare(parsed, controller.signal).then((prepared) => {
+    void currentMentions.prepare(parsed, controller.signal).then((prepared) => {
       deliver(prepared.text, prepared.additionalContext)
     }, (error: unknown) => {
       if (controller.signal.aborted) return
@@ -402,6 +497,56 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     })
   }
 
+  // Deferred first-session creation for a bare launch: the session is composed
+  // only when the user submits real input (or /new), and every line that
+  // arrives during creation is delivered in order afterwards. A creation
+  // 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
+  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
+      }
+      active = next
+      agent = next.agent
+      session = next.session
+      store = next.store
+      mentions = next.mentions
+      commands.setAgent(agent)
+      skills.setAgent(agent)
+      renderCurrent()
+      const queued = pendingInputs.splice(0)
+      for (const item of queued) deliverLine(item.text, item.mode)
+    })().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 (session === undefined) {
+      pendingInputs.push({ text: line, mode })
+      ensureSession()
+      return
+    }
+    deliverLine(line, mode)
+  }
+
   /** Dispatch one submitted line: slash commands to the registry, other text to the agent. */
   const dispatch = (text: string): void => {
     send(text, 'followup')
@@ -418,7 +563,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
 
   /** Interrupt the running turn (Esc); true when a turn was actually cancelled. */
   const interrupt = (): boolean => {
-    if (agent.status !== 'running') return false
+    if (agent === undefined || agent.status !== 'running') return false
     try {
       agent.cancel({ kind: 'user' })
       bridge.notify('turn cancelled — Ctrl+C or /quit to exit')
@@ -435,6 +580,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
    * custom knob state wraps to the first declared preset.
    */
   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[]
@@ -460,6 +606,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
 
   /** Apply one /model selection: takes effect from the next assembled step. */
   const selectModel = (row: ModelRow): string => {
+    if (active === undefined) throw new Error('no session yet — submit a message to start')
     active.selection.picked = { provider: row.provider, model: row.model }
     return `${row.provider}/${row.model}`
   }
@@ -470,6 +617,10 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
    * workspace; an absolute or cwd-relative argument overrides it.
    */
   const exportTranscript = async (argument: string): Promise<void> => {
+    if (session === undefined) {
+      bridge.notify('no session yet — submit a message to start', 'warning')
+      return
+    }
     const wanted = argument.trim()
     const sessionCwd = session.header.cwd ?? cwd
     const defaultName = `dsh-session-${session.id.slice(-8)}.md`
@@ -495,6 +646,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   const renameTitle = (argument: string): string => {
     const title = argument.trim()
     if (title === '') return 'usage: /title <text>'
+    if (session === undefined) return 'no session yet — submit a message to start'
     const service = ctx.get('sessionTitle')
     if (service === undefined) return 'session titles are unavailable in this profile'
     try {
@@ -524,10 +676,15 @@ 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 preset = await switchPreset(presets, agent, id)
-    active.mode = preset.id
-    commands.setAgent(agent)
-    skills.setAgent(agent)
+    const currentAgent = agent
+    const currentActive = active
+    if (currentAgent === undefined || currentActive === undefined) {
+      throw new Error('no session yet — submit a message to start')
+    }
+    const preset = await switchPreset(presets, currentAgent, id)
+    currentActive.mode = preset.id
+    commands.setAgent(currentAgent)
+    skills.setAgent(currentAgent)
     renderCurrent()
     return preset.id
   }
@@ -549,16 +706,22 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       renderCurrent()
     } catch (error: unknown) {
       active = previous
-      agent = previous.agent
-      session = previous.session
-      store = previous.store
-      mentions = previous.mentions
-      commands.setAgent(agent)
-      skills.setAgent(agent)
+      agent = previous?.agent
+      session = previous?.session
+      store = previous === undefined ? createTranscriptStore() : previous.store
+      mentions = 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)
@@ -582,11 +745,20 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   )
 
   const requestSwitch = (request: PendingSwitch): void => {
+    if (session === undefined) {
+      // No session yet (a bare launch using /resume before any input): activate
+      // the target directly — there is no running turn to wait on and nothing
+      // to flush.
+      void activate(request.target).catch((error: unknown) => {
+        bridge.notify(`session switch failed: ${error instanceof Error ? error.message : String(error)}`, 'error')
+      })
+      return
+    }
     if (request.target.sessionId === session.id) {
       bridge.notify('that session is already active', 'warning')
       return
     }
-    const outcome = switchQueue.request(agent, request)
+    const outcome = switchQueue.request(agent!, request)
     if (outcome === 'queued') {
       bridge.notify(`will switch to ${request.label} when the current turn finishes · /resume cancel to abort`)
     }
@@ -603,7 +775,7 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
     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')
     }
-    if (agents.get(SessionId(matches[0]!.header.id)) !== undefined && matches[0]!.header.id !== session.id) {
+    if (session !== undefined && agents.get(SessionId(matches[0]!.header.id)) !== undefined && matches[0]!.header.id !== session.id) {
       throw new Error('that session is already live in another owner')
     }
     return matches[0]!.header.id
@@ -616,6 +788,11 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   }
 
   const createSession = (mode?: string): void => {
+    // /new before any input is the first-session creation itself, not a switch.
+    if (session === undefined) {
+      ensureSession(mode)
+      return
+    }
     const nextCwd = session.header.cwd ?? cwd
     const id = `session-${randomUUID()}`
     requestSwitch({ target: { sessionId: id, resume: false, mode, cwd: nextCwd }, label: id.slice(-12) })
@@ -634,10 +811,14 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   }
 
   const appElement = (): ReturnType<typeof createElement> => {
-    const sessionCwd = session.header.cwd ?? cwd
+    // 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.
+    const sessionCwd = session?.header.cwd ?? cwd
     const model = store.getView().model !== '' ? store.getView().model : `${defaults.provider}/${defaults.model}`
     return createElement(App, {
-      key: session.id,
+      key: session?.id ?? 'pending',
       store,
       approval,
       questions,
@@ -647,15 +828,17 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       cwd: basename(sessionCwd),
       workspaceRoot: sessionCwd,
       branch: gitBranch(sessionCwd),
-      sessionId: session.id.slice(-8),
-      resumed: active.resumed,
-      mode: active.mode,
+      sessionId: session === undefined ? '' : session.id.slice(-8),
+      resumed: active?.resumed ?? false,
+      mode: active?.mode ?? '',
       dispatch,
       steer,
       interrupt,
       quit,
       loadModels: () => loadModelDirectory(ctx),
-      loadMentions: mentions.candidates,
+      loadMentions: mentions === undefined
+        ? () => Promise.resolve<readonly MentionCandidate[]>([])
+        : mentions.candidates,
       cyclePermission,
       selectModel,
       exportTranscript,
@@ -668,6 +851,11 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
       switchSession,
       cancelSessionSwitch,
       loadPlugins: () => listPluginRows(ctx),
+      statusline: statuslineItems,
+      saveStatusline,
+      history: inputHistory,
+      recordHistory,
+      cancelQueued,
       onBridgeReady: (instance: AppBridge) => { bridge.notify = instance.notify },
     })
   }
@@ -677,6 +865,14 @@ async function run(ctx: Context, startup: TuiStartup, io: TuiIo): Promise<void>
   }
 
   mountRef.current = io.mount(appElement())
+
+  // A corrupt statusline config must not vanish silently: surface it once
+  // the notice channel is live, after the first frame settles.
+  if (statuslineWarning !== undefined) {
+    setTimeout(() => {
+      bridge.notify('statusline config unreadable, using defaults: ' + statuslineWarning, 'warning')
+    }, 50)
+  }
 }
 
 /**