dsh-code 1.0.4 → 1.0.6

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/settings-file.ts

@@ -16,9 +16,46 @@
  * @module @deepseek-ai/dsh-code/settings-file
  */
 
+import { randomUUID } from 'node:crypto'
 import { mkdir, rename, writeFile } from 'node:fs/promises'
 import { dirname } from 'node:path'
 
+/**
+ * Run one file operation with a bounded retry: one initial try plus at
+ * most `retries` more. Creating or replacing a file can fail transiently
+ * with EPERM/EACCES while an antivirus scanner or search indexer holds
+ * it — the standard graceful-fs remedy, not a workaround for a
+ * persistent permission problem. A save that still fails leaves its
+ * uniquely named temp file behind, so repeated crashed saves accumulate
+ * distinct leftovers rather than corrupting a shared one.
+ */
+async function withTransientRetry(operation: () => Promise<void>, retries = 5): Promise<void> {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      await operation()
+      return
+    } catch (error: unknown) {
+      const code = (error as NodeJS.ErrnoException).code
+      if (attempt >= retries || (code !== 'EPERM' && code !== 'EACCES')) throw error
+      await new Promise(resolve => setTimeout(resolve, 30 * (attempt + 1)))
+    }
+  }
+}
+
+/**
+ * Write one file atomically: create the parent directory, write to a
+ * uniquely named temp file, and rename it into place. A crash midway
+ * can never leave a half-written document behind. Unique temp names
+ * keep concurrent writers (two terminals, two chains in one process)
+ * from sharing one temp path.
+ */
+export async function writeFileAtomically(path: string, text: string): Promise<void> {
+  await mkdir(dirname(path), { recursive: true })
+  const temp = `${path}.${process.pid}.${randomUUID()}.tmp`
+  await withTransientRetry(() => writeFile(temp, text, 'utf8'))
+  await withTransientRetry(() => rename(temp, path))
+}
+
 /** The serialized persistence surface; flush() is handed to the quit sequence. */
 export interface UserSettingsPersistence {
   /**
@@ -39,12 +76,7 @@ export function createUserSettingsPersistence(): UserSettingsPersistence {
   let chain: Promise<void> = Promise.resolve()
   return {
     save(path: string, text: string): Promise<void> {
-      const write = chain.then(async () => {
-        await mkdir(dirname(path), { recursive: true })
-        const temp = `${path}.tmp`
-        await writeFile(temp, text, 'utf8')
-        await rename(temp, path)
-      })
+      const write = chain.then(() => writeFileAtomically(path, text))
       // A failed write must not break the chain for later saves.
       chain = write.catch(() => {})
       return write

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