dsh-code 1.0.5 → 1.0.7

package/src/render/status.ts

@@ -77,6 +77,7 @@ export type StatusTone =
   | 'meta'
   | 'accent'
   | 'success'
+  | 'plan'
   | 'warn'
   | 'error'
   // Context-bar fill: one DeepSeek blue for the whole occupied run (the free
@@ -419,9 +420,7 @@ function buildCandidates(
   const right: { span: StatusSpan; rank: number; id: string }[] = []
   const row2: { group: StatusGroup; rank: number; id: string }[] = []
 
-  if (facts.plan && enabled.has('plan')) {
-    row2.push({ group: { spans: [{ text: '⧉ plan', tone: 'accent' }] }, rank: RANK2_PLAN, id: 'plan' })
-  }
+
 
   if (stats.turns > 0 || stats.steps > 0) {
     if (enabled.has('turns')) {
@@ -522,10 +521,25 @@ function buildCandidates(
   }
   const permission = safe(facts.permission)
   let badge = -1
+  // The plan STATION names itself in the permission badge: with the most
+  // restrictive preset active, plan mode reads as the green fourth cycle
+  // station 'plan' (that preset IS the station's permission layer). Plan on
+  // any other preset (a typed /plan mid-session) stays orthogonal: the badge
+  // keeps naming the preset and row 2 carries the green plan marker.
+  const planStation = facts.plan && permissionTone(permission) === 'success'
   if (permission !== '' && enabled.has('permission')) {
-    right.push({ span: { text: permission, tone: permissionTone(permission) }, rank: RANK_BADGE, id: 'permission' })
+    right.push({
+      span: planStation
+        ? { text: 'plan on', tone: 'plan' }
+        : { text: permission, tone: permissionTone(permission) },
+      rank: RANK_BADGE,
+      id: 'permission',
+    })
     badge = right.length - 1
   }
+  if (facts.plan && enabled.has('plan')) {
+    row2.push({ group: { spans: [{ text: '⧉ plan', tone: 'accent' }] }, rank: RANK2_PLAN, id: 'plan' })
+  }
   return { left, right, badge, row2 }
 }
 

package/src/session-directory.ts

@@ -2,7 +2,7 @@
 
 import { basename, dirname, resolve } from 'node:path'
 import { realpathSync } from 'node:fs'
-import type { SessionEvent, SessionHeader } from '@deepseek-ai/dsh-session'
+import { SESSION_FORMAT_VERSION, type SessionEvent, type SessionHeader } from '@deepseek-ai/dsh-session'
 
 export interface SessionRecord {
   readonly header: SessionHeader
@@ -170,9 +170,8 @@ export function mergeSessionTitles(
 
 /**
  * Encode a session id the way the JSONL backend does for its on-disk layout
- * (`encodeSegment`: safe units literal, everything else `~XXXX`). Used ONLY to
- * validate that a `locate()` path really is this session's directory before
- * any deletion touches the filesystem — a local copy of the pure upstream
+ * (`encodeSegment`: safe units literal, everything else `~XXXX`). Used to
+ * validate and derive session directories — a local copy of the pure upstream
  * contract, kept in sync with `session-persistence-jsonl/src/format.ts`.
  */
 export function encodeSessionSegment(raw: string): string {
@@ -192,22 +191,101 @@ export function encodeSessionSegment(raw: string): string {
   return out
 }
 
-/** The session-log artifact names the JSONL backend may create. */
-export const SESSION_ARTIFACT_NAMES: readonly string[] = ['session.jsonl', 'session.jsonl.zstd']
+/**
+ * Encode a project cwd the way the JSONL backend groups sessions on disk
+ * (`projectKey`: separators collapse to one `-`, everything else mirrors
+ * `encodeSegment`, bounded to 251 chars). A local copy of the pure upstream
+ * contract, kept in sync with `session-persistence-jsonl/src/format.ts`.
+ */
+export function encodeProjectKey(cwd: string): string {
+  if (cwd.length === 0) throw new Error('cannot encode an empty project path')
+  let readable = ''
+  let separatorRun = false
+  for (let i = 0; i < cwd.length; i += 1) {
+    const code = cwd.charCodeAt(i)
+    const ch = String.fromCharCode(code)
+    if (ch === '/' || ch === '\\' || ch === ':') {
+      if (!separatorRun) readable += '-'
+      separatorRun = true
+    } else if (ch !== '~' && /^[A-Za-z0-9._-]$/.test(ch)) {
+      readable += ch
+      separatorRun = false
+    } else {
+      readable += `~${code.toString(16).toUpperCase().padStart(4, '0')}`
+      separatorRun = false
+    }
+  }
+  const slug = readable.replace(/^-+/, '') || 'root'
+  return `--${slug.slice(0, 251)}--`
+}
+
+/** The project-level directory name the JSONL backend uses for a missing cwd. */
+const NO_CWD_DIRECTORY = '_no-cwd'
+
+/**
+ * Derive one session's artifact directory under the JSONL backend root,
+ * mirroring the upstream `<root>/<projectKey(cwd)>/<encodeSegment(id)>/`
+ * layout (0.1.5 `sessionDir`/`projectDir`).
+ * @param root - the JSONL backend's configured session root.
+ * @param cwd - the session's pinned working directory, when the header has one.
+ * @param id - the session id.
+ * @returns the absolute session directory path.
+ */
+export function sessionDirectoryFor(root: string, cwd: string | undefined, id: string): string {
+  const project = cwd === undefined || cwd === '' ? NO_CWD_DIRECTORY : encodeProjectKey(cwd)
+  return resolve(root, project, encodeSessionSegment(id))
+}
 
 /**
- * Guard one `locate()` artifact path before deletion (codex's scoped-path
- * check, adapted to the JSONL layout): the file must be a `session.jsonl`
- * artifact sitting in the directory named exactly `encodeSegment(id)`.
- * @param artifact - the path the persistence backend located.
- * @param id - the session id the artifact claims to belong to.
- * @returns the owning session directory, or undefined when the layout is unexpected.
+ * The canonical session-log artifact filenames the JSONL backend may create:
+ * format v0 writes the bare `session.jsonl` name; v1+ write
+ * `session.vN.jsonl`, each generation optionally zstd-compressed. Multiple
+ * immutable generations may coexist in one session directory (0.1.5). The
+ * range follows the installed session package's `SESSION_FORMAT_VERSION`, so
+ * a future generation joins the enumeration with the dependency bump.
  */
-export function sessionArtifactDirectory(artifact: string, id: string): string | undefined {
-  if (basename(artifact) !== 'session.jsonl' && basename(artifact) !== 'session.jsonl.zstd') return undefined
-  const dir = dirname(artifact)
+export function sessionArtifactNames(): readonly string[] {
+  const names: string[] = ['session.jsonl', 'session.jsonl.zstd']
+  for (let version = 1; version <= SESSION_FORMAT_VERSION; version += 1) {
+    names.push(`session.v${version}.jsonl`, `session.v${version}.jsonl.zstd`)
+  }
+  return names
+}
+
+/** Canonical generation-log filenames as a lookup set (bare v0 or `vN`-suffixed, ± zstd). */
+const SESSION_ARTIFACT_NAME_SET: ReadonlySet<string> = new Set(sessionArtifactNames())
+
+/** True for one canonical session-log artifact filename the backend may own. */
+export function isSessionArtifactName(name: string): boolean {
+  return SESSION_ARTIFACT_NAME_SET.has(name)
+}
+
+/**
+ * Guard a derived session directory before deletion (codex's scoped-path
+ * check, adapted to the JSONL layout): the directory's base name must be
+ * exactly `encodeSegment(id)` beneath its project grouping.
+ * @param dir - the derived session artifact directory.
+ * @param id - the session id the directory claims to belong to.
+ * @returns the guarded directory, or undefined when the layout is unexpected.
+ */
+export function sessionArtifactDirectory(dir: string, id: string): string | undefined {
   if (basename(dir) !== encodeSessionSegment(id)) return undefined
-  return dir
+  if (basename(dirname(dir)) === NO_CWD_DIRECTORY) return dir
+  return /^--.*--$|^~/.test(basename(dirname(dir))) ? dir : undefined
+}
+
+/**
+ * The JSONL backend's configured session root, when the mounted backend
+ * exposes one. The upstream service contract dropped `locate()` in 0.1.5
+ * (artifact paths are backend-private; only refusal diagnostics carry them),
+ * so the TUI derives artifact paths from the backend's public plugin config.
+ * Backends without a JSONL-style config (or a foreign shape) yield undefined
+ * and callers degrade: mtime sorting falls back to createdAt and /delete
+ * refuses, exactly as before.
+ */
+export function jsonlSessionRoot(persistence: unknown): string | undefined {
+  const root = (persistence as { config?: { root?: unknown } } | undefined)?.config?.root
+  return typeof root === 'string' && root !== '' ? root : undefined
 }
 
 /**

package/src/session-query.ts

@@ -0,0 +1,235 @@
+/**
+ * Skip-tolerant session-query engine for this terminal.
+ *
+ * The upstream SqliteSessionQueryEngine reconciliation observes EVERY
+ * persisted session before each search, and ONE unreadable source (for
+ * example a pre-release session artifact the frozen format codecs reject)
+ * fails the whole pass with SESSION_QUERY_PERSISTENCE_FAILED — every
+ * cross-session search dies because of a single old file nobody opened
+ * otherwise. This subclass overrides only the observation loop so an
+ * unreadable source is skipped with a warning and the rest of the corpus
+ * indexes normally; skipped sessions are retried on later reconciliations
+ * and rejoin automatically once a host that can read them is installed.
+ *
+ * Vendored surface note: `_observeStable` and its module-local helpers are
+ * private upstream; this file re-declares the observation loop against the
+ * pinned @deepseek-ai line (see package.json peers) and must be re-checked
+ * whenever that line moves. The engine class and the tool boundary also
+ * share ONE physical parent-package instance through this bundle, which
+ * restores instanceof-based typed error messages on the search path.
+ */
+
+import { createHash } from 'node:crypto'
+import SqliteSessionQueryEngine, { type Config } from '@deepseek-ai/dsh-session-query-sqlite'
+import {
+  assertSessionHeadersCompatible,
+  buildSessionEventSearchDocuments,
+  readColdSessionLog,
+  SessionQueryError,
+} from '@deepseek-ai/dsh-session-query'
+import type { SessionEvent, SessionHeader, SessionId, SessionLogOffset } from '@deepseek-ai/dsh-session'
+import type { SessionPersistenceRevision, SessionPersistenceSnapshot } from '@deepseek-ai/dsh-session-persistence'
+
+/** One observed session: detached header plus its derived search documents. */
+interface ObservedSession {
+  header: SessionHeader
+  inheritedEventCount: SessionLogOffset
+  documents: readonly ReturnType<typeof buildSessionEventSearchDocuments>[number][]
+  fingerprint: string
+}
+
+/** One persisted snapshot as the reconciliation sees it (loaded once readable). */
+interface ObservedPersistedSession {
+  header: SessionHeader
+  revision: SessionPersistenceRevision
+  loaded?: ObservedSession
+  /** Diagnosis for a cold read that failed; the session stays unindexed. */
+  unreadable?: string
+}
+
+/** The engine-internal state the observation loop touches. */
+export interface EngineSurface {
+  readonly ctx: {
+    sessions: {
+      list(): readonly { header: SessionHeader; inheritedEventCount: SessionLogOffset; snapshotEvents(): readonly SessionEvent[]; id: SessionId }[]
+      get(id: SessionId): unknown
+    }
+    logger?: { warn(format: string, ...args: readonly unknown[]): void }
+  }
+  readonly _persistenceBinding: {
+    readonly identity: symbol
+    readonly service?: {
+      list(options?: { readonly signal?: AbortSignal }): Promise<readonly SessionPersistenceSnapshot[]>
+    }
+  }
+  _lastPersistenceIdentity: symbol | undefined
+}
+
+type ColdRead = (persistence: NonNullable<EngineSurface['_persistenceBinding']['service']>, id: SessionId, signal: AbortSignal | undefined) => Promise<{ header: SessionHeader; inheritedEventCount: SessionLogOffset; events: readonly SessionEvent[] }>
+
+const STABLE_OBSERVATION_ATTEMPTS = 2
+
+function assertNotAborted(signal: AbortSignal | undefined): void {
+  if (signal?.aborted) {
+    throw new SessionQueryError('session-search aborted', 'SESSION_QUERY_ABORTED')
+  }
+}
+
+function isAbort(error: unknown): boolean {
+  return error instanceof SessionQueryError && error.code === 'SESSION_QUERY_ABORTED'
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : 'unknown error'
+}
+
+function observeSession(header: SessionHeader, inheritedEventCount: SessionLogOffset, events: readonly SessionEvent[]): ObservedSession {
+  const detachedHeader = structuredClone(header)
+  const detachedEvents = events.map(event => structuredClone(event))
+  return {
+    header: detachedHeader,
+    inheritedEventCount,
+    documents: buildSessionEventSearchDocuments(detachedHeader.id, detachedEvents),
+    fingerprint: createHash('sha256')
+      .update(JSON.stringify({ header: detachedHeader, inheritedEventCount, events: detachedEvents }))
+      .digest('base64url'),
+  }
+}
+
+function sameHeader(a: SessionHeader, b: SessionHeader): boolean {
+  return a.id === b.id
+    && a.createdAt === b.createdAt
+    && a.cwd === b.cwd
+    && a.parentSession === b.parentSession
+    && a.isSeeded === b.isSeeded
+    && (a.delegationDepth ?? 0) === (b.delegationDepth ?? 0)
+    && a.agentPreset === b.agentPreset
+}
+
+function materializePersistenceSnapshots(snapshots: readonly SessionPersistenceSnapshot[]): Map<SessionId, ObservedPersistedSession> {
+  if (!Array.isArray(snapshots)) throw new Error('persistence snapshots must be an array')
+  const result = new Map<SessionId, ObservedPersistedSession>()
+  for (const snapshot of snapshots) {
+    if (typeof snapshot.revision !== 'string') {
+      throw new Error('persistence snapshot revision must be a string')
+    }
+    const header = structuredClone(snapshot.header)
+    if (result.has(header.id)) {
+      throw new Error(`persistence listed duplicate session "${header.id}"`)
+    }
+    result.set(header.id, { header, revision: snapshot.revision })
+  }
+  return result
+}
+
+function samePersistenceSnapshots(before: ReadonlyMap<SessionId, ObservedPersistedSession>, after: ReadonlyMap<SessionId, ObservedPersistedSession>): boolean {
+  if (before.size !== after.size) return false
+  for (const [id, first] of before) {
+    const second = after.get(id)
+    if (second === undefined || first.revision !== second.revision || !sameHeader(first.header, second.header)) return false
+  }
+  return true
+}
+
+/**
+ * The skip-tolerant observation pass: structurally the upstream loop, with
+ * the per-source cold read wrapped so one unreadable session degrades to a
+ * warning instead of failing every search. Exported for unit tests with an
+ * injectable cold reader.
+ */
+export async function observeStableWithSkip(
+  engine: EngineSurface,
+  indexed: ReadonlyMap<SessionId, { revision: SessionPersistenceRevision }>,
+  signal: AbortSignal | undefined,
+  readCold: ColdRead = readColdSessionLog as unknown as ColdRead,
+): Promise<{ persistenceBinding: EngineSurface['_persistenceBinding']; persisted: Map<SessionId, ObservedPersistedSession>; live: Map<SessionId, ObservedSession> }> {
+  for (let attempt = 0; attempt < STABLE_OBSERVATION_ATTEMPTS; attempt += 1) {
+    assertNotAborted(signal)
+    const persistenceBinding = engine._persistenceBinding
+    const persistence = persistenceBinding.service
+    const initiallyLive = new Set(engine.ctx.sessions.list().map(session => session.id))
+    let persisted = new Map<SessionId, ObservedPersistedSession>()
+    if (persistence !== undefined) {
+      try {
+        const canReuseIndexed = engine._lastPersistenceIdentity === undefined
+          || engine._lastPersistenceIdentity === persistenceBinding.identity
+        const listOptions = signal === undefined ? undefined : { signal }
+        const before = await persistence.list(listOptions)
+        assertNotAborted(signal)
+        persisted = materializePersistenceSnapshots(before)
+        for (const entry of persisted.values()) {
+          if (canReuseIndexed && indexed.get(entry.header.id)?.revision === entry.revision) continue
+          if (initiallyLive.has(entry.header.id) || engine.ctx.sessions.get(entry.header.id) !== undefined) continue
+          assertNotAborted(signal)
+          // The skip: a session whose cold log fails to migrate or decode
+          // stays OUT of the index with one warning; the remaining corpus
+          // indexes normally. `loaded` stays undefined exactly like a
+          // not-yet-read entry, so the stable-snapshot comparison and the
+          // live-preferred merge below are unaffected.
+          try {
+            const loaded = await readCold(persistence, entry.header.id, signal)
+            assertNotAborted(signal)
+            assertSessionHeadersCompatible(entry.header, loaded.header)
+            entry.loaded = observeSession(loaded.header, loaded.inheritedEventCount, loaded.events)
+          } catch (error: unknown) {
+            if (isAbort(error) || signal?.aborted) throw error
+            if (engine._persistenceBinding !== persistenceBinding) break
+            entry.unreadable = errorMessage(error)
+            engine.ctx.logger?.warn(
+              'session-search skipped unreadable session %s: %s',
+              entry.header.id,
+              entry.unreadable,
+            )
+          }
+        }
+        assertNotAborted(signal)
+        const afterSnapshots = await persistence.list(listOptions)
+        assertNotAborted(signal)
+        const after = materializePersistenceSnapshots(afterSnapshots)
+        if (!samePersistenceSnapshots(persisted, after)) continue
+        if (engine._persistenceBinding !== persistenceBinding) continue
+      } catch (error: unknown) {
+        if (isAbort(error) || signal?.aborted) {
+          throw new SessionQueryError('session-search aborted', 'SESSION_QUERY_ABORTED', { cause: error })
+        }
+        if (engine._persistenceBinding !== persistenceBinding) continue
+        if (error instanceof SessionQueryError) throw error
+        throw new SessionQueryError(
+          `session-search persistence observation failed: ${errorMessage(error)}`,
+          'SESSION_QUERY_PERSISTENCE_FAILED',
+          { cause: error },
+        )
+      }
+    }
+    const live = new Map<SessionId, ObservedSession>()
+    for (const session of engine.ctx.sessions.list()) {
+      const observed = observeSession(session.header, session.inheritedEventCount, session.snapshotEvents())
+      const durable = persisted.get(session.id)
+      if (durable !== undefined && durable.loaded === undefined) {
+        // A live owner always wins over a skipped durable copy.
+        live.set(session.id, observed)
+        continue
+      }
+      if (durable !== undefined) assertSessionHeadersCompatible(observed.header, durable.header as SessionHeader)
+      live.set(session.id, observed)
+    }
+    const sameLive = initiallyLive.size === live.size && [...initiallyLive].every(id => live.has(id))
+    if (!sameLive) continue
+    return { persistenceBinding, persisted, live }
+  }
+  throw new SessionQueryError('session-search persistence observation did not stabilize after one retry', 'SESSION_QUERY_PERSISTENCE_FAILED')
+}
+
+// The opaque-base cast keeps the private `_observeStable` override legal in
+// TypeScript while inheriting every runtime static (inject, Config, Service
+// metadata) from the real engine class.
+const EngineBase = SqliteSessionQueryEngine as unknown as abstract new (ctx: never, config: Config) => EngineSurface & object
+
+/** The engine this bundle mounts in place of the base `session-query-sqlite` row. */
+export class SkipTolerantSessionQueryEngine extends EngineBase {
+  async _observeStable(indexed: ReadonlyMap<SessionId, { revision: SessionPersistenceRevision }>, signal: AbortSignal | undefined): Promise<unknown> {
+    return await observeStableWithSkip(this as unknown as EngineSurface, indexed, signal)
+  }
+}
+
+export default SkipTolerantSessionQueryEngine as unknown as typeof SqliteSessionQueryEngine

package/src/skills.ts

@@ -74,11 +74,17 @@ export function watchSkills(ctx: Context, fallbackCwd?: string): SkillsWatch {
 
   const reload = (): void => {
     const target = agent
-    if (skills === undefined || target === undefined) return
-    Promise.resolve().then(() => skills.list({
-      cwd: target.session.header.cwd ?? fallbackCwd,
-      scope: target,
-    })).then((summaries: readonly SkillSummary[]) => {
+    if (skills === undefined) return
+    Promise.resolve().then(() => skills.list(target === undefined
+      // No session exists yet (a bare launch keeps the agent unset until the
+      // first message): read the global skill layer for the working directory.
+      // The upstream contract makes `scope` optional — omitted reads the
+      // global layer alone — so the menu offers skills before a session does.
+      ? { cwd: fallbackCwd }
+      : {
+        cwd: target.session.header.cwd ?? fallbackCwd,
+        scope: target,
+      })).then((summaries: readonly SkillSummary[]) => {
       // A retarget landed while this catalog was loading: the rows belong to
       // another agent's workspace and must never overwrite the current view.
       if (agent !== target) return
@@ -97,19 +103,27 @@ export function watchSkills(ctx: Context, fallbackCwd?: string): SkillsWatch {
       for (const listener of listeners) listener()
     }).catch((cause: unknown) => {
       if (agent !== target) return
-      // Discovery failure keeps the last good rows for the SAME agent (the
+      // Discovery failure keeps the last good rows for the SAME target (the
       // next skills/change notification is the retry surface, mirroring the
-      // web directory); an agent that never loaded starts from empty rows —
+      // web directory); a target that never loaded starts from empty rows —
       // stale rows from a previous workspace must not keep completing here.
+      // The rows array keeps its identity unless the failure text itself
+      // changed: a repeated identical error on the 0.1.5 event storm must not
+      // churn fresh identities into React's update chain.
+      const nextError = cause instanceof Error ? cause.message : String(cause)
       if (loadedFor !== target) rows = []
-      else rows = [...rows]
-      error = cause instanceof Error ? cause.message : String(cause)
+      const errorChanged = nextError !== error
+      error = nextError
+      if (!errorChanged) return
       for (const listener of listeners) listener()
     })
   }
 
   if (skills !== undefined) {
     ctx.on('skills/change', reload)
+    // Read the global layer immediately: a bare launch has no agent yet, and
+    // waiting for the first skills/change would leave the menu empty.
+    reload()
   }
 
   const view: SkillsWatch = {

package/src/store.ts

@@ -30,8 +30,16 @@
  * @module @deepseek-ai/dsh-tui/store
  */
 
+import type { AssistantStreamFrame } from '@deepseek-ai/dsh-agent'
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
-import { createReplayAccumulator, replayProjectEvent, snapshotReplayView, type TranscriptView } from './render/projection.ts'
+import {
+  applyAssistantStreamChunk,
+  clearAssistantStream,
+  createReplayAccumulator,
+  replayProjectEvent,
+  snapshotReplayView,
+  type TranscriptView,
+} from './render/projection.ts'
 
 /** Render frame budget: the notification cadence's upper bound. */
 const NOTIFY_FRAME_MS = 16
@@ -44,6 +52,8 @@ export interface TranscriptStore {
   subscribe(listener: () => void): () => void
   /** Fold one session event; ignored events change nothing and notify nobody. */
   apply(event: SessionEvent): void
+  /** Fold one live assistant-stream frame; frames without visible deltas stay silent. */
+  applyStreamFrame(frame: AssistantStreamFrame): void
   /** Drop the folded view entirely (/clear): the next event starts a fresh one. */
   reset(): void
 }
@@ -66,6 +76,11 @@ export function createTranscriptStore(replay?: readonly SessionEvent[]): Transcr
   const listeners = new Set<() => void>()
   let scheduled = false
   let lastNotifyAt = 0
+  // Live attempt → `turn:step` key: chunk frames name only their attempt, so
+  // the start frame's turn/step anchor is remembered until the end frame
+  // retires the attempt. A replacement attempt (new start frame) overwrites
+  // the entry; committed settlements already cleared the tails it replaces.
+  const attemptKeys = new Map<string, string>()
   const notify = (): void => {
     if (scheduled) return
     scheduled = true
@@ -101,8 +116,31 @@ export function createTranscriptStore(replay?: readonly SessionEvent[]): Transcr
       dirty = true
       notify()
     },
+    applyStreamFrame(frame: AssistantStreamFrame): void {
+      if (frame.type === 'start') {
+        attemptKeys.set(frame.attemptId, `${frame.turn}:${frame.step}`)
+        return
+      }
+      if (frame.type === 'chunk') {
+        const key = attemptKeys.get(frame.attemptId)
+        if (key === undefined) return
+        if (!applyAssistantStreamChunk(acc, key, frame.time, frame.chunk)) return
+        dirty = true
+        notify()
+        return
+      }
+      // End frame: committed settlements arrive as durable events before
+      // their end frame and already cleared the tails; an abandoned attempt
+      // has no settlement, so its partial tail is dropped here.
+      attemptKeys.delete(frame.attemptId)
+      if (frame.outcome.kind === 'abandoned' && clearAssistantStream(acc)) {
+        dirty = true
+        notify()
+      }
+    },
     reset(): void {
       acc = createReplayAccumulator()
+      attemptKeys.clear()
       dirty = true
       notify()
     },

package/src/subagents.ts

@@ -22,6 +22,9 @@
  */
 
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
+// Type-only import merges the subagent package's SessionEventMap variant
+// ('subagent/catalog') into the union this fold switches on.
+import type {} from '@deepseek-ai/dsh-subagent'
 
 /** Hard row cap: overflow evicts the oldest settled row; a fully busy feed waits. */
 export const MAX_SUBAGENT_ROWS = 8
@@ -107,8 +110,27 @@ export function foldSubagentRow(previous: SubagentRow | undefined, sessionId: st
       return { ...base, state: 'running', activity: 'working…', updatedAt: event.time }
     case 'user/message':
       return { ...base, state: 'running', activity: 'prompted', updatedAt: event.time }
-    case 'assistant/chunk':
+    case 'assistant/attempt':
+      // Durable logs are settlement-only since session-log v2; an attempt
+      // landing without a surface message means the model is retrying or
+      // recovered from a stream error, so the child stays running.
       return { ...base, state: 'running', activity: 'thinking…', updatedAt: event.time }
+    case 'subagent/catalog': {
+      // Parent-owned durable discovery fact (0.1.5): the catalog names the
+      // child's mode (one-shot vs continuable) and its authored label — the
+      // most semantic label the row can carry. It is a discovery fact, not a
+      // lifecycle signal: a fresh row starts idle, but a late delivery never
+      // regresses a row that already ran or finished. An unchanged fact keeps
+      // the row's identity (the no-op discipline of the default branch), so
+      // repeated deliveries never churn the snapshot array.
+      const mode = event.data.mode === 'continuable' ? 'continuable' : 'one-shot'
+      const label = event.data.label !== undefined && event.data.label.trim() !== '' ? bound(event.data.label) : undefined
+      const nextLabel = label === undefined ? base.label : label
+      const activity = label === undefined ? `catalog · ${mode}` : `catalog · ${mode} · ${label}`
+      const state = previous === undefined ? 'idle' : base.state
+      if (nextLabel === base.label && state === base.state && activity === base.activity) return base
+      return { ...base, state, label: nextLabel, activity, updatedAt: event.time }
+    }
     case 'assistant/message':
       return { ...base, state: 'idle', activity: messagePreview(data['message'] === undefined ? undefined : (data['message'] as { content?: unknown }).content), updatedAt: event.time }
     case 'tool/call': {
@@ -169,11 +191,12 @@ export function createSubagentFeed(): SubagentFeedView & {
       }
       // A child this feed has not shown yet: the honest total grows even
       // when every row is busy; admission then prefers evicting the OLDEST
-      // settled row so a new running agent never waits on one that finished.
+      // settled row (idle or done — both are non-running) so a new running
+      // agent never waits on one that already settled.
       const counted = !seen.has(sessionId)
       if (counted) seen.add(sessionId)
       if (rows.length >= MAX_SUBAGENT_ROWS) {
-        const evict = rows.findIndex(row => row.state === 'done')
+        const evict = rows.findIndex(row => row.state !== 'running')
         if (evict === -1) {
           if (counted) notify()
           return