dsh-code 1.2.0 → 1.4.0

package/src/runner/session-target.ts

@@ -0,0 +1,81 @@
+/** Session identity resolution for one terminal runner invocation.
+ *
+ * Turns parsed startup flags into the session this process will run, and maps
+ * a session id onto a filename-safe export default. Resolution reads persisted
+ * headers, so it is the runner's only pre-composition persistence IO; the
+ * remaining helpers are pure.
+ *
+ * @module @deepseek-ai/dsh-code/session-target
+ */
+
+import { randomUUID } from 'node:crypto'
+import type { SessionId, SessionEvent, SessionHeader } from '@deepseek-ai/dsh-session'
+import type { SessionPersistence } from '@deepseek-ai/dsh-session-persistence'
+import { isSubagentSession, matchSessionId, newestRootForCwd } from '../session/session-directory.ts'
+import type { TuiStartup } from '../startup.ts'
+
+/** The session identity this invocation will run, plus whether it is resumed. */
+export interface Target {
+  sessionId: string
+  resume: boolean
+  mode?: string
+  cwd?: string
+  seed?: readonly SessionEvent[]
+  parentSession?: SessionId
+  /** Marks the session as a subagent conversation in the durable header. */
+  origin?: 'subagent'
+  seedLength?: number
+}
+
+/**
+ * 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)
+}
+
+/**
+ * Resolve the invocation's target session against the persisted headers.
+ * @param startup - the parsed startup flags.
+ * @param persistence - the persistence service; required for resume/latest.
+ * @param cwd - the working directory `--continue` filters by.
+ * @returns the target identity.
+ * @throws with a user-facing message when the flags name nothing resolvable.
+ */
+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') {
+    // 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()).map(snapshot => snapshot.header)
+      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()).map(snapshot => snapshot.header)
+  if (startup.kind === 'resume') {
+    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 }
+}

package/src/runner/startup-config.ts

@@ -0,0 +1,54 @@
+/**
+ * Resolve the runner's startup flags from the loose plugin config.
+ *
+ * The Cordis config schema is deliberately loose (`kind` is an unvalidated
+ * string, narrowed here), so this is the single place that maps a config row
+ * onto the `TuiStartup` the runner consumes — pure, and unit-testable without
+ * a plugin context.
+ *
+ * @module @deepseek-ai/dsh-code/runner/startup-config
+ */
+
+import { parseThemeName } from '../theme.ts'
+import type { TuiStartup } from '../startup.ts'
+
+/** The config row shape this resolver narrows; satisfied by the plugin schema. */
+export interface StartupConfigRow {
+  /** How this invocation obtains its session identity. */
+  readonly kind: string
+  readonly sessionId?: string
+  readonly mode?: string
+  readonly theme?: string
+  readonly prompt?: string
+  readonly images?: readonly string[]
+}
+
+/**
+ * Narrow one config row to a startup.
+ *
+ * `resume`/`named` without a session id degrade to a fresh launch, an invalid
+ * theme string narrows to the dark default (and is therefore still present),
+ * and `mode` only survives on the kinds that can pre-compose a session.
+ * @param config - the validated plugin config.
+ * @returns the startup the runner will resolve a target from.
+ */
+export function resolveStartupConfig(config: { readonly startup: StartupConfigRow }): TuiStartup {
+  const row = config.startup
+  // The CLI validated --theme at parse time; the loose config schema falls
+  // back to dark for anything unexpected.
+  const theme = row.theme === undefined ? undefined : parseThemeName(row.theme)
+  const input = {
+    ...(theme === undefined ? {} : { theme }),
+    ...(row.prompt === undefined ? {} : { prompt: row.prompt }),
+    ...(row.images === undefined ? {} : { images: [...row.images] }),
+  }
+  if (row.kind === 'resume' && row.sessionId !== undefined) {
+    return { kind: 'resume', sessionId: row.sessionId, ...input }
+  }
+  if (row.kind === 'latest') return { kind: 'latest', ...input }
+  const mode = row.mode === undefined ? {} : { mode: row.mode }
+  if (row.kind === 'named' && row.sessionId !== undefined) {
+    return { kind: 'named', sessionId: row.sessionId, ...mode, ...input }
+  }
+  return { kind: 'fresh', ...mode, ...input }
+}

package/src/runner/submissions.ts

@@ -0,0 +1,157 @@
+/** Submission vocabulary and the startup input gate for the terminal runner.
+ *
+ * Pure over the handles they are given: the queue mutations and the session
+ * guard are decisions the runner applies, and the gate only orders deliveries,
+ * so every branch is testable without composing an Agent.
+ *
+ * @module @deepseek-ai/dsh-code/submissions
+ */
+
+import { createUserMessage, MessageId, type ContentBlock } from '@deepseek-ai/dsh-llm'
+import type { Agent, AgentStatus, Inbox } from '@deepseek-ai/dsh-agent'
+import type { UserMessage } from '@deepseek-ai/dsh-session'
+import type { QueueMutation } from '../ui/ui-contract.ts'
+
+/** One composer submission waiting behind the startup delivery. */
+export interface QueuedSubmission {
+  readonly text: string
+  /** `steer` inserts into the running turn; `followup` waits for the next one. */
+  readonly mode: 'followup' | 'steer'
+  readonly images: readonly ContentBlock[]
+}
+
+/** What one requested queue mutation did; the runner maps it to one notice. */
+export type QueueMutationOutcome =
+  | 'removed'
+  | 'edited'
+  | 'steered'
+  | 'unavailable'
+  | 'empty'
+  | 'steerUnavailable'
+
+/**
+ * Replace one queued message's text while keeping its attachments. A queue
+ * edit rewrites what the user typed, not what they attached: image and file
+ * blocks ride through in delivery order (text first, then attachments, the
+ * shape {@link deliverLine} submits). Dropping them here would silently strip
+ * an attachment the user already confirmed, so this is the edit's single
+ * definition and the panel's read-only marker only mirrors it.
+ */
+export function queueEditContent(content: readonly ContentBlock[], text: string): ContentBlock[] {
+  const attachments = content.filter(block => block.type !== 'text')
+  return [{ type: 'text', text }, ...attachments]
+}
+
+/**
+ * Apply one terminal queue mutation to the live inbox. The decision and the
+ * inbox change are pure over the supplied handles so every branch is testable
+ * without an agent; steering itself is injected because it wakes the driver
+ * rather than mutating the inbox. The durable inbox splices remain the UI's
+ * single source of truth — this helper never reports a state the inbox did not
+ * actually reach.
+ * @param inbox - the live agent inbox (pending lists plus its mutators).
+ * @param status - the agent's lifecycle status; steering needs `running`.
+ * @param messageId - identity of the queued message to mutate.
+ * @param action - the requested mutation.
+ * @param steer - submits the removed message as next-step steering.
+ * @returns the outcome the caller reports.
+ */
+export function applyQueueMutation(
+  inbox: Pick<Inbox, 'nextTurn' | 'append' | 'remove' | 'replace'>,
+  status: AgentStatus,
+  messageId: string,
+  action: QueueMutation,
+  steer: (message: UserMessage) => void,
+): QueueMutationOutcome {
+  const id = MessageId(messageId)
+  const message = inbox.nextTurn.find(candidate => candidate.id === id)
+  if (message === undefined) return 'unavailable'
+  switch (action.kind) {
+    case 'remove':
+      return inbox.remove(id) ? 'removed' : 'unavailable'
+    case 'edit':
+      if (action.text.trim() === '') return 'empty'
+      inbox.replace(id, createUserMessage({
+        content: queueEditContent(message.content, action.text),
+        source: message.source,
+      }))
+      return 'edited'
+    case 'steer':
+      if (status !== 'running') return 'steerUnavailable'
+      // Steer promotes the message out of next-turn, so a failing submit must
+      // put it back: the row the user was looking at never just disappears.
+      if (!inbox.remove(id)) return 'unavailable'
+      try {
+        steer(message)
+      } catch (error: unknown) {
+        inbox.append('next-turn', message)
+        throw error
+      }
+      return 'steered'
+  }
+}
+
+/**
+ * Cancel the active turn while keeping the next-turn queue, then wake the
+ * driver again so the preserved messages actually run. `cancel` clears
+ * pending work by default and never wakes the driver on its own, so the queue
+ * is captured first and re-submitted afterwards: a waking submission latches
+ * the wake while the aborted activity converges to idle, which is what turns
+ * "preserved" into "sent next" instead of "parked forever". Next-step
+ * steering is deliberately dropped — it belonged to the cancelled turn.
+ * @param agent - the live agent handle.
+ * @returns how many queued messages were preserved across the abort.
+ */
+export function cancelPreservingQueue(agent: Pick<Agent, 'inbox' | 'cancel' | 'followup'>): number {
+  const queued = [...agent.inbox.nextTurn]
+  agent.cancel({ kind: 'user' })
+  for (const message of queued) agent.followup(message)
+  return queued.length
+}
+
+/**
+ * Whether a tagged submission still belongs to the active session. Attachment
+ * prepares resolve on the microtask timeline, while a queued session switch
+ * remounts the app asynchronously — the composing instance's unmount cleanup
+ * runs too late to abort, so the delivery itself carries the composing
+ * session's full id and the runner drops it here when the world moved on.
+ * An untagged (synchronous) or pending-session ('') submission always passes.
+ */
+export function submissionBelongsToSession(origin: string | undefined, activeSessionId: string | undefined): boolean {
+  return origin === undefined || origin === '' || origin === activeSessionId
+}
+
+/**
+ * Order-preserving gate for composer input while the startup prompt/images
+ * are still preparing. Anything submitted before the startup delivery settles
+ * queues and flushes afterwards in submit order, so the initial request can
+ * never be overtaken by typing that raced a slow image preparation. The flush
+ * also runs when the startup delivery fails: user input is never stranded.
+ */
+export class StartupInputGate {
+  private readonly queued: QueuedSubmission[] = []
+  private pending = false
+  constructor(private readonly deliver: (submission: QueuedSubmission) => void) {}
+
+  /** Submit one line: delivered now while idle, queued behind the startup delivery otherwise. */
+  submit(submission: QueuedSubmission): void {
+    if (this.pending) this.queued.push(submission)
+    else this.deliver(submission)
+  }
+
+  /**
+   * Run the startup delivery — the callback receives the direct-delivery sink
+   * for the startup prompt itself — then flush everything that queued behind
+   * it, in order, even when the callback rejects.
+   */
+  async run(startup: (deliver: (submission: QueuedSubmission) => void) => Promise<void>): Promise<void> {
+    this.pending = true
+    try {
+      await startup(submission => this.deliver(submission))
+    } finally {
+      this.pending = false
+      const queued = this.queued.splice(0)
+      for (const submission of queued) this.deliver(submission)
+    }
+  }
+}

package/src/session/attach.ts

@@ -0,0 +1,87 @@
+/**
+ * One live attachment to a subagent conversation: a transcript store seeded
+ * from the child's durable log and then fed by the process-local event and
+ * stream buses in real time. The parent's own store is never touched.
+ *
+ * @module @deepseek-ai/dsh-code/session/attach
+ */
+
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+import { createTranscriptStore, type TranscriptStore } from './store.ts'
+
+/** The bus surfaces one attachment reads; the runner wires these to ctx. */
+export interface SubagentAttachmentServices {
+  /** Seed: the child's full durable event log, oldest first. */
+  load(id: string, signal?: AbortSignal): Promise<readonly SessionEvent[]>
+  /** Durable events for exactly this child session, live. */
+  subscribeEvents(id: string, onEvent: (event: SessionEvent) => void): () => void
+  /** Token stream frames for exactly this child agent, live. */
+  subscribeStream(id: string, onFrame: (frame: Parameters<TranscriptStore['applyStreamFrame']>[0]) => void): () => void
+}
+
+/** A live child view handed to the App while attached. */
+export interface SubagentAttachment {
+  readonly id: string
+  readonly label: string
+  readonly store: TranscriptStore
+  /** Whether the durable seed has landed (frames are held back until then). */
+  seeded(): boolean
+  /** Drop the bus subscriptions; the store freezes at its last state. */
+  dispose(): void
+}
+
+/** An inert empty store keeps the App's external-store hook unconditional. */
+export const EMPTY_ATTACH_STORE: TranscriptStore = createTranscriptStore()
+
+/**
+ * Attach to one subagent conversation.
+ *
+ * Ordering contract: durable events carry a per-session sequence, so the seed
+ * sets a watermark and live events at or below it are dropped as duplicates;
+ * stream frames are held until the seed lands so a frame whose settlement
+ * already arrived cannot resurrect a stale tail.
+ */
+export function createSubagentAttachment(services: SubagentAttachmentServices, id: string, label: string): SubagentAttachment {
+  const store = createTranscriptStore()
+  const controller = new AbortController()
+  let watermark = -1
+  let seeded = false
+  const pending: SessionEvent[] = []
+  const applyDurable = (event: SessionEvent): void => {
+    const seq = Number(event.seq ?? -1)
+    if (seq >= 0 && seq <= watermark) return
+    if (seq >= 0) watermark = seq
+    store.apply(event)
+  }
+  const offEvents = services.subscribeEvents(id, event => {
+    if (!seeded) pending.push(event)
+    else applyDurable(event)
+  })
+  const offFrames = services.subscribeStream(id, frame => {
+    if (seeded) store.applyStreamFrame(frame)
+  })
+  services.load(id, controller.signal).then(events => {
+    if (controller.signal.aborted) return
+    for (const event of events) applyDurable(event)
+    seeded = true
+    for (const event of pending) applyDurable(event)
+    pending.length = 0
+  }, () => {
+    // The live buses still feed the view; a failed seed leaves the watermark
+    // unset so nothing durable is skipped, and the store shows what arrives.
+    seeded = true
+    for (const event of pending) applyDurable(event)
+    pending.length = 0
+  })
+  return {
+    id,
+    label,
+    store,
+    seeded: () => seeded,
+    dispose: () => {
+      controller.abort()
+      offEvents()
+      offFrames()
+    },
+  }
+}

package/src/{fork.ts → session/fork.ts}

@@ -13,13 +13,17 @@ export function selectForkSeed(events: readonly SessionEvent[], atSeq?: number):
     throw new Error('fork event sequence must be a non-negative integer')
   }
   const lastSeq = events.at(-1)?.seq ?? -1
-  const anchored = atSeq === undefined
-    ? undefined
-    : events.find(event => event.type === 'turn/end' && event.seq >= atSeq)
-  const boundary = anchored
-    ?? (atSeq === undefined || atSeq > lastSeq
-      ? events.findLast(event => event.type === 'turn/end')
-      : undefined)
+  let boundary: SessionEvent | undefined
+  if (atSeq === undefined || atSeq > lastSeq) {
+    boundary = events.findLast(event => event.type === 'turn/end')
+  } else {
+    // The last turn/start at or before the anchor. A seq in the gap after a
+    // turn/end (title, compaction) must not walk FORWARD to the next turn.
+    const start = events.findLast(event => event.type === 'turn/start' && event.seq <= atSeq)
+    boundary = start === undefined
+      ? undefined
+      : events.find(event => event.type === 'turn/end' && event.seq >= start.seq)
+  }
   if (boundary === undefined) {
     throw new Error(atSeq !== undefined && atSeq <= lastSeq
       ? `the turn containing event ${atSeq} has not completed`

package/src/{history.ts → session/history.ts}

@@ -122,6 +122,20 @@ export function beginRecall(entries: readonly string[], draft: string): RecallSt
   return { entries, index: null, savedDraft: draft, lastRecalled: null }
 }
 
+/**
+ * Join a panel-recalled entry onto the draft already in the composer: the
+ * draft is extended, never replaced, so picking a history row cannot discard
+ * work in progress. An empty draft takes the entry as-is; otherwise the entry
+ * starts on its own line unless the draft already ends one.
+ * @param draft - the composer text before the recall.
+ * @param entry - the sanitized text of the accepted row.
+ * @returns the text to place in the composer.
+ */
+export function appendRecall(draft: string, entry: string): string {
+  if (draft === '') return entry
+  return draft.endsWith('\n') ? draft + entry : `${draft}\n${entry}`
+}
+
 /** The outcome of one recall step. */
 export interface RecallStep {
   state: RecallState

package/src/{session-directory.ts → session/session-directory.ts}

@@ -2,8 +2,8 @@
 
 import { basename, dirname, resolve } from 'node:path'
 import { realpathSync } from 'node:fs'
-import { SESSION_FORMAT_VERSION, type SessionEvent, type SessionHeader } from '@deepseek-ai/dsh-session'
-import { t } from './i18n.ts'
+import { SESSION_FORMAT_VERSION, SessionId, type SessionEvent, type SessionHeader } from '@deepseek-ai/dsh-session'
+import { t } from '../i18n.ts'
 
 export interface SessionRecord {
   readonly header: SessionHeader
@@ -11,6 +11,52 @@ export interface SessionRecord {
   readonly persisted: boolean
 }
 
+/** Minimal write handle retained while a planned deletion touches artifacts. */
+export interface SessionDeletionLease {
+  close(): Promise<void>
+}
+
+/** Public persistence operation used to acquire the backend's write lease. */
+export interface SessionDeletionPersistence {
+  open(id: SessionId, access: 'write'): Promise<SessionDeletionLease>
+}
+
+/**
+ * Acquire every subtree member's cross-process write lease before deleting
+ * any artifact. A partial acquisition is rolled back, so callers either hold
+ * the whole deletion boundary or touch nothing.
+ */
+export async function acquireSessionDeletionLeases(
+  persistence: SessionDeletionPersistence,
+  ids: readonly string[],
+): Promise<readonly SessionDeletionLease[]> {
+  const leases: SessionDeletionLease[] = []
+  try {
+    for (const id of ids) leases.push(await persistence.open(SessionId(id), 'write'))
+    return leases
+  } catch (error: unknown) {
+    try {
+      await releaseSessionDeletionLeases(leases)
+    } catch (releaseError: unknown) {
+      throw new AggregateError([error, releaseError], 'session deletion lease acquisition and rollback failed')
+    }
+    throw error
+  }
+}
+
+/** Release deletion leases in reverse acquisition order. */
+export async function releaseSessionDeletionLeases(leases: readonly SessionDeletionLease[]): Promise<void> {
+  const failures: unknown[] = []
+  for (const lease of [...leases].reverse()) {
+    try {
+      await lease.close()
+    } catch (error: unknown) {
+      failures.push(error)
+    }
+  }
+  if (failures.length > 0) throw new AggregateError(failures, 'failed to release session deletion leases')
+}
+
 export interface TitleObservationResult {
   readonly sessionId: string
   readonly status: 'fulfilled' | 'rejected'
@@ -105,6 +151,26 @@ export function matchSessionId(headers: readonly SessionHeader[], wanted: string
   return matches[0]
 }
 
+/**
+ * Unique picker-row match by exact id, unique prefix, or unique suffix.
+ * The resume list shows `id.slice(-12)`, so `/delete` arguments are often
+ * that tail rather than a leading prefix.
+ */
+export function matchSessionRow(rows: readonly SessionRow[], wanted: string): SessionRow {
+  const needle = wanted.trim()
+  if (needle === '') throw new Error('no persisted session matches ""')
+  const exact = rows.filter(row => row.id === needle)
+  if (exact[0] !== undefined && exact.length === 1) return exact[0]
+  const prefixed = rows.filter(row => row.id.startsWith(needle))
+  if (prefixed[0] !== undefined && prefixed.length === 1) return prefixed[0]
+  const suffixed = rows.filter(row => row.id.endsWith(needle))
+  if (suffixed[0] !== undefined && suffixed.length === 1) return suffixed[0]
+  if (prefixed.length > 1 || suffixed.length > 1) {
+    throw new Error(`session prefix "${needle}" is ambiguous (${Math.max(prefixed.length, suffixed.length)} matches): use more of the id`)
+  }
+  throw new Error(`no persisted session matches "${needle}"`)
+}
+
 /** The newest persisted ROOT session pinned to this cwd, or undefined. */
 export function newestRootForCwd(headers: readonly SessionHeader[], cwd: string): SessionHeader | undefined {
   const local = headers
@@ -151,12 +217,19 @@ export function projectSessionRows(
         preset: record.header.agentPreset ?? 'standard',
       }
     })
-    .filter(row => needle === '' || `${row.id} ${row.cwd} ${row.workspace} ${row.preset}`.toLowerCase().includes(needle))
+    .filter(row => sessionRowMatchesQuery(row, needle))
     .sort((left, right) => options.sort === 'newest'
       ? right.updatedAt - left.updatedAt || right.createdAt - left.createdAt
       : left.updatedAt - right.updatedAt || left.createdAt - right.createdAt)
 }
 
+/** True when the picker query hits id, path, preset, or the displayed title. */
+export function sessionRowMatchesQuery(row: Pick<SessionRow, 'id' | 'cwd' | 'workspace' | 'preset' | 'title'>, query: string): boolean {
+  const needle = query.trim().toLowerCase()
+  if (needle === '') return true
+  return `${row.id} ${row.cwd} ${row.workspace} ${row.preset} ${row.title ?? ''}`.toLowerCase().includes(needle)
+}
+
 /** Merge page-local title observations without disturbing directory order. */
 export function mergeSessionTitles(
   rows: readonly SessionRow[],
@@ -300,7 +373,13 @@ export function jsonlSessionRoot(persistence: unknown): string | undefined {
  */
 export function collectDeletionSubtree(records: readonly SessionRecord[], id: string): string[] {
   const parentOf = new Map<string, string | undefined>()
-  for (const record of records) parentOf.set(record.header.id, record.header.parentSession)
+  for (const record of records) {
+    // Only delegated subagents ride their parent's deletion. A fork is an
+    // independent conversation that merely shares lineage: deleting its
+    // origin must never take the branch's own log with it.
+    if (!isSubagentSession(record.header)) continue
+    parentOf.set(record.header.id, record.header.parentSession)
+  }
   const doomed = new Set<string>([id])
   // Iterate to a fixed point: children may be listed before their parents.
   for (let pass = 0; pass < 2; pass += 1) {

package/src/{session-switch.ts → session/session-switch.ts}

@@ -13,6 +13,7 @@ interface Request<T> {
 export class SessionSwitchQueue<T> {
   private pending: Request<T> | undefined
   private pumping = false
+  private running = false
 
   constructor(
     private readonly execute: (value: T) => Promise<void>,
@@ -34,6 +35,16 @@ export class SessionSwitchQueue<T> {
     return true
   }
 
+  /**
+   * Whether a queued change is being activated right now. Between the idle
+   * wait and the handoff the old session is still installed, so a submission
+   * made in that window would start a turn the handoff then discards; callers
+   * use this to refuse one instead of losing it.
+   */
+  get activating(): boolean {
+    return this.running
+  }
+
   private async pump(): Promise<void> {
     this.pumping = true
     try {
@@ -43,10 +54,13 @@ export class SessionSwitchQueue<T> {
         // Another request replaced this one while the turn was converging.
         if (this.pending !== observed) continue
         this.pending = undefined
+        this.running = true
         try {
           await this.execute(observed.value)
         } catch (error: unknown) {
           this.failed(error)
+        } finally {
+          this.running = false
         }
       }
     } finally {

package/src/{store.ts → session/store.ts}

@@ -39,7 +39,7 @@ import {
   replayProjectEvent,
   snapshotReplayView,
   type TranscriptView,
-} from './render/projection.ts'
+} from '../render/projection.ts'
 
 /** Render frame budget: the notification cadence's upper bound. */
 const NOTIFY_FRAME_MS = 16
@@ -139,8 +139,26 @@ export function createTranscriptStore(replay?: readonly SessionEvent[]): Transcr
       }
     },
     reset(): void {
+      // /clear wipes settled history but must not drop the live attempt map:
+      // chunk frames after reset still name the same attemptId, and clearing
+      // the map froze the stream until settlement dumped the whole reply.
+      const live = {
+        streaming: acc.streaming,
+        streamingReasoning: acc.streamingReasoning,
+        busy: acc.busy,
+        busySince: acc.busySince,
+        model: acc.model,
+        firstChunkAt: acc.firstChunkAt,
+        stepStart: acc.stepStart,
+      }
       acc = createReplayAccumulator()
-      attemptKeys.clear()
+      acc.streaming = live.streaming
+      acc.streamingReasoning = live.streamingReasoning
+      acc.busy = live.busy
+      acc.busySince = live.busySince
+      acc.model = live.model
+      acc.firstChunkAt = live.firstChunkAt
+      acc.stepStart = live.stepStart
       dirty = true
       notify()
     },

package/src/{subagents.ts → session/subagents.ts}

@@ -18,7 +18,7 @@
  * microtask notify chained SyncLane rerenders past React's nested update
  * limit; a bare macrotask merge repaints a whole turn's bursts at once).
  *
- * @module @deepseek-ai/dsh-code/subagents
+ * @module @deepseek-ai/dsh-code/session/subagents
  */
 
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
@@ -227,3 +227,14 @@ export function createSubagentFeed(): SubagentFeedView & {
     },
   }
 }
+
+/**
+ * Root-log catalog facts a resumed session must replay into the subagent
+ * feed: constructor seeds never fire on the live bus, so without this the
+ * children of a resumed session vanish behind a restart. The empty-child
+ * placeholder row (childId '') is a placeholder, not a child, and stays out.
+ */
+export function subagentCatalogSeed(events: readonly SessionEvent[]): readonly SessionEvent<'subagent/catalog'>[] {
+  return events.filter((event): event is SessionEvent<'subagent/catalog'> =>
+    event.type === 'subagent/catalog' && event.data.childId !== '')
+}