dsh-code 1.0.3 → 1.0.5

package/src/render/projection.ts

@@ -8,7 +8,8 @@
  */
 
 import { boundContextSummary, type ContentBlock, type ImageBlock, type MessageId } from '@deepseek-ai/dsh-llm'
-import type { SessionEvent, TodoItem } from '@deepseek-ai/dsh-session'
+import type { SessionEvent } from '@deepseek-ai/dsh-session'
+import type { TodoItem } from '@deepseek-ai/dsh-tool-todo'
 import { graphemeWidth, splitGraphemes } from './width.ts'
 // Type-only imports merge the plugin-owned SessionEventMap variants
 // (agent/inbox/spliced, command/*, compaction/*, goal/change, llm/retry*,
@@ -159,6 +160,8 @@ export interface RetryEntry {
   kind: 'retry'
   /** Correlation id shared with the matching `llm/retry-started`. */
   retryId: string
+  /** Retry policy mode from the event: `always` has no attempt cap. */
+  mode: 'normal' | 'always'
   /** Attempt ordinal and its cap. */
   attempt: number
   max: number
@@ -166,7 +169,11 @@ export interface RetryEntry {
   code: string
   /** Backoff wait before the next attempt, in ms. */
   delayMs: number
-  /** `running` while the backoff waits, `done` once the attempt started. */
+  /**
+   * `running` while the backoff waits, `done` once the attempt started — or
+   * when the turn ended first (the turn-end sweep finalizes orphans so they
+   * never pin the settled boundary).
+   */
   state: 'running' | 'done'
 }
 
@@ -328,6 +335,25 @@ function textOf(content: readonly ContentBlock[]): string {
   return content.filter(block => block.type === 'text').map(block => block.text).join('')
 }
 
+/**
+ * Snapshot-isolate one anchors block (Maps and their nested Sets): a view
+ * already handed to the renderer must never observe a later fold through a
+ * shared container. The collections are small and turn-bounded, so cloning
+ * per event is cheap next to the entries copy the reducer already makes.
+ */
+function cloneViewAnchors(anchors: TranscriptView['anchors']): TranscriptView['anchors'] {
+  return {
+    stepStart: new Map(anchors.stepStart),
+    toolStart: new Map(anchors.toolStart),
+    firstChunkAt: new Map(anchors.firstChunkAt),
+    compactionTokens: new Map(anchors.compactionTokens),
+    lastPruneTokens: anchors.lastPruneTokens,
+    turnFiles: new Map([...anchors.turnFiles].map(([turn, files]) => [turn, new Set(files)])),
+    turnSteps: new Map(anchors.turnSteps),
+    turnTools: new Map([...anchors.turnTools].map(([turn, tools]) => [turn, new Set(tools)])),
+  }
+}
+
 /** Durable image references in their model-visible order. */
 function imagesOf(content: readonly ContentBlock[]): readonly ImageBlock['attachment'][] {
   return content.filter((block): block is ImageBlock => block.type === 'image').map(block => block.attachment)
@@ -410,6 +436,10 @@ function pendingText(content: readonly ContentBlock[]): string {
  * @returns the view after the event; the input view is never mutated.
  */
 export function projectEvent(view: TranscriptView, event: SessionEvent): TranscriptView {
+  // Fold against a private anchors block so the documented contract holds —
+  // "the input view is never mutated" — even for the in-place anchor sweeps
+  // below; without this, every handed-out view shared live Maps.
+  view = { ...view, anchors: cloneViewAnchors(view.anchors) }
   switch (event.type) {
     case 'user/message': {
       // A queued row retires when its durable user message lands (the agent
@@ -467,10 +497,16 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       const { target, start, removedCount = 0, inserted } = event.data
       const ids = view.pending[target]
       const removed = ids.slice(start, start + removedCount)
+      // In-place upstream semantics: the kernel's authoritative fold is
+      // `inbox.splice(start, removedCount, ...inserted)` — inserted ids land
+      // AT the splice position (prepend/replace shapes), never at the tail.
+      // A tail append diverged the id order, so later coordinate-based events
+      // (next-turn head claims, positioned remove/replace) tombstoned the
+      // wrong pending row.
       const nextIds = [
         ...ids.slice(0, start),
-        ...ids.slice(start + removedCount),
         ...inserted.map(message => message.id),
+        ...ids.slice(start + removedCount),
       ]
       let entries = view.entries
       if (removed.length > 0) {
@@ -714,8 +750,26 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
         for (const callId of turnToolSet) view.anchors.toolStart.delete(callId)
         view.anchors.turnTools.delete(event.data.turn)
       }
+      // Orphaned retry/command rows can never be resolved after the turn
+      // ends: an aborted retry backoff returns upstream without its
+      // `llm/retry-started`, and crash repair synthesizes only tool/step/
+      // turn closers. Left `running` they pin the settled boundary forever,
+      // so the turn end finalizes them exactly like the anchor sweep above.
+      let orphans = false
+      const swept = view.entries.map((entry) => {
+        if (entry.kind === 'retry' && entry.state === 'running') {
+          orphans = true
+          return { ...entry, state: 'done' as const }
+        }
+        if (entry.kind === 'command' && entry.state === 'running') {
+          orphans = true
+          return { ...entry, state: 'error' as const, summary: 'interrupted before the turn ended' }
+        }
+        return entry
+      })
+      const entries = orphans ? swept : view.entries
       if (appended.length === 0) {
-        return { ...view, busy: false, busySince: 0, streaming: '', streamingReasoning: '' }
+        return { ...view, busy: false, busySince: 0, streaming: '', streamingReasoning: '', entries }
       }
       return {
         ...view,
@@ -723,7 +777,7 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
         busySince: 0,
         streaming: '',
         streamingReasoning: '',
-        entries: [...view.entries, ...appended],
+        entries: [...entries, ...appended],
       }
     }
     case 'llm/retry': {
@@ -735,6 +789,7 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
         entries: [...view.entries, {
           kind: 'retry',
           retryId: data.retryId,
+          mode: data.mode,
           attempt: data.retry,
           max: 'maxRetries' in data ? data.maxRetries : data.retry,
           code: data.failure.code,
@@ -995,6 +1050,31 @@ function indexList(map: Map<string, number[]>, id: string): number[] {
   return list
 }
 
+/**
+ * Finalize replay rows the ended turn left `running`, mirroring the reducer's
+ * turn-end orphan sweep: an orphaned retry settles `done`, an orphaned command
+ * settles `error` with an interruption note. Only the id-indexed rows are
+ * visited, so the sweep stays O(retries+commands of the log), never a scan.
+ */
+function finalizeReplayOrphans(acc: ReplayAccumulator): void {
+  for (const list of acc.retryIndex.values()) {
+    for (const index of list) {
+      const entry = acc.entries[index]
+      if (entry !== undefined && entry.kind === 'retry' && entry.state === 'running') {
+        acc.entries[index] = { ...entry, state: 'done' }
+      }
+    }
+  }
+  for (const list of acc.commandIndex.values()) {
+    for (const index of list) {
+      const entry = acc.entries[index]
+      if (entry !== undefined && entry.kind === 'command' && entry.state === 'running') {
+        acc.entries[index] = { ...entry, state: 'error', summary: 'interrupted before the turn ended' }
+      }
+    }
+  }
+}
+
 /**
  * Apply an id-keyed update to every row that registered the id, mirroring the
  * copy-on-write reducer's full-array map semantics (all matching rows update,
@@ -1103,11 +1183,15 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
           }
         }
       }
+      // Mirror the reducer's in-place order: inserted ids join at the splice
+      // position (upstream `splice(start, removedCount, ...inserted)`), never
+      // at the tail — the id list must stay coordinate-compatible with every
+      // later inbox event.
+      ids.splice(start, 0, ...inserted.map(message => message.id))
       for (const message of inserted) {
         const images = imagesOf(message.content)
         appendReplayEntry(acc, { kind: 'pending', messageId: message.id, target, text: pendingText(message.content), ...(images.length === 0 ? {} : { images }) })
         indexList(acc.pendingIndex, message.id).push(acc.entries.length - 1)
-        ids.push(message.id)
         acc.ops += 1
       }
       return true
@@ -1298,6 +1382,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
         for (const callId of turnToolSet) acc.toolStart.delete(callId)
         acc.turnTools.delete(event.data.turn)
       }
+      finalizeReplayOrphans(acc)
       acc.busy = false
       acc.busySince = 0
       for (const entry of appended) appendReplayEntry(acc, entry)
@@ -1310,6 +1395,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       appendReplayEntry(acc, {
         kind: 'retry',
         retryId: data.retryId,
+        mode: data.mode,
         attempt: data.retry,
         max: 'maxRetries' in data ? data.maxRetries : data.retry,
         code: data.failure.code,
@@ -1474,15 +1560,17 @@ function materializeReplayView(acc: ReplayAccumulator, copy: boolean): Transcrip
     goal: acc.goal,
     pending: { 'next-turn': [...acc.pendingTurn], 'next-step': [...acc.pendingStep] },
     stats: acc.stats,
+    // Handed-out views get their own anchors snapshot: the accumulator keeps
+    // folding its live containers, and no consumer may observe that.
     anchors: {
-      stepStart: acc.stepStart,
-      toolStart: acc.toolStart,
-      firstChunkAt: acc.firstChunkAt,
-      compactionTokens: acc.compactionTokens,
+      stepStart: new Map(acc.stepStart),
+      toolStart: new Map(acc.toolStart),
+      firstChunkAt: new Map(acc.firstChunkAt),
+      compactionTokens: new Map(acc.compactionTokens),
       lastPruneTokens: acc.lastPruneTokens,
-      turnFiles: acc.turnFiles,
-      turnSteps: acc.turnSteps,
-      turnTools: acc.turnTools,
+      turnFiles: new Map([...acc.turnFiles].map(([turn, files]) => [turn, new Set(files)])),
+      turnSteps: new Map(acc.turnSteps),
+      turnTools: new Map([...acc.turnTools].map(([turn, tools]) => [turn, new Set(tools)])),
     },
   }
 }

package/src/render/status.ts

@@ -126,37 +126,31 @@ export const STATUS_ITEM_SEPARATOR = ' · '
 export const STATUS_CYCLE_HINT = ' (shift+tab to cycle)'
 
 /**
- * Interior columns of the segmented context bar (content-type segments plus
- * the free tail whose right edge carries the usage readout). The layout
- * starts every bar at this width so the drop ladder can pre-measure the
- * group, then shrinks the bar inside a tighter budget before dropping it
- * (see CONTEXT_MIN_WIDTH) rather than asking the layout for more room.
+ * Interior columns of the context bar. The layout starts every bar at this
+ * width so the drop ladder can pre-measure the group, then degrades the
+ * readout and shrinks the bar inside a tighter budget before dropping the
+ * group (see CONTEXT_MIN_WIDTH) rather than asking the layout for more room.
  */
 export const CONTEXT_BAR_WIDTH = 24
 /** Occupancy at which the usage readout flips from brand blue to amber. */
 const CONTEXT_WARN_PERCENT = 90
-/** Free-tail floor in columns: wide enough for the bare percent readout, so
- * the warning stays visible even at 100%+ occupancy. */
-const CONTEXT_MIN_FREE = 5
 /**
- * Narrowest bar width the drop ladder tries before giving up on the context
- * group: the bar shrinks inside its own budget first (a few columns still
- * show the bare percent readout) and only then drops as a whole.
+ * Narrowest bar width the drop ladder keeps before dropping the whole
+ * context group: the bar shrinks to this floor first (the absolute readout
+ * survives), and only past it does the readout degrade and the group go.
  */
 const CONTEXT_MIN_WIDTH = 5
 
 /**
- * Render context occupancy as ONE stepless bar: a solid DeepSeek-blue fill
- * run, a dim dotted free track, and the usage readout riding the track's
- * right edge (`12.3K/1.0M 25%`, shrinking to the bare percent as the track
- * narrows). No per-content-type segmentation. Column split is deterministic:
- * the free share is `Math.round(free/window*width)` clamped to at least
- * CONTEXT_MIN_FREE columns and at most the full width; the fill takes every
- * remaining column, so a given occupancy always renders the identical bar.
- * The readout flips to amber once occupancy reaches the warning threshold.
- * @param usedTokens - reported used tokens (drives the readout and percent).
+ * Render context occupancy as ONE stepless proportional bar: a solid
+ * DeepSeek-blue fill run tracking the occupancy and a dim dotted free
+ * track for the rest. Nothing else lives inside the bar — the usage
+ * readout rides outside it (see contextGroupSpans) — so the geometry
+ * always reads as the true remaining share. A given occupancy always
+ * renders the identical bar.
+ * @param usedTokens - reported used tokens.
  * @param contextWindow - route capacity.
- * @param width - total bar interior columns.
+ * @param width - total bar columns.
  * @returns tone-split spans for the footer to paint.
  */
 export function contextBar(
@@ -166,27 +160,42 @@ export function contextBar(
 ): readonly StatusSpan[] {
   if (width <= 0 || contextWindow <= 0) return []
   const used = Math.max(0, usedTokens)
-  const percent = Math.round(used / contextWindow * 100)
-  const warning = percent >= CONTEXT_WARN_PERCENT
-  const readoutTone: StatusTone = warning ? 'warn' : 'value'
-
-  const freeShare = Math.round(Math.max(0, contextWindow - used) / contextWindow * width)
-  const freeColumns = Math.min(width, Math.max(freeShare, CONTEXT_MIN_FREE))
-  const usedColumns = Math.max(0, width - freeColumns)
+  const fill = Math.min(width, Math.max(0, Math.round(used / contextWindow * width)))
+  const spans: StatusSpan[] = []
+  if (fill > 0) spans.push({ text: '█'.repeat(fill), tone: 'ctxFill' })
+  const free = width - fill
+  if (free > 0) spans.push({ text: '░'.repeat(free), tone: 'label' })
+  return spans
+}
 
-  const total = `${formatTokens(used)}/${formatTokens(contextWindow)}`
-  const percentText = `${percent}%`
-  const readout = freeColumns >= visibleColumns(`${total} ${percentText}`)
-    ? `${total} ${percentText}`
-    : freeColumns >= visibleColumns(percentText)
-      ? percentText
-      : ''
+/** How much usage detail the context group's readout carries. */
+export type ContextReadoutMode = 'full' | 'percent' | 'none'
 
-  const spans: StatusSpan[] = []
-  if (usedColumns > 0) spans.push({ text: '█'.repeat(usedColumns), tone: 'ctxFill' })
-  const pad = freeColumns - visibleColumns(readout)
-  if (pad > 0) spans.push({ text: '░'.repeat(pad), tone: 'label' })
-  if (readout !== '') spans.push({ text: readout, tone: readoutTone })
+/**
+ * Compose the context group: the proportional bar plus the usage readout
+ * OUTSIDE the bar, so the dotted track keeps its proportional meaning no
+ * matter how wide the readout is. `full` reads `12.3K/1.0M 25%`; `percent`
+ * drops the absolute pair; `none` is the bare bar. The readout turns amber
+ * once occupancy reaches the warning threshold.
+ */
+export function contextGroupSpans(
+  usedTokens: number,
+  contextWindow: number,
+  barWidth: number,
+  readout: ContextReadoutMode,
+): readonly StatusSpan[] {
+  const spans: StatusSpan[] = [{ text: 'context ', tone: 'label' }]
+  spans.push(...contextBar(usedTokens, contextWindow, barWidth))
+  if (readout === 'none' || barWidth <= 0 || contextWindow <= 0) return spans
+  const used = Math.max(0, usedTokens)
+  const percent = Math.round(used / contextWindow * 100)
+  const text = readout === 'full'
+    ? `${formatTokens(used)}/${formatTokens(contextWindow)} ${percent}%`
+    : `${percent}%`
+  spans.push(
+    { text: ' ', tone: 'label' },
+    { text, tone: percent >= CONTEXT_WARN_PERCENT ? 'warn' : 'value' },
+  )
   return spans
 }
 
@@ -459,17 +468,13 @@ function buildCandidates(
       id: 'cache',
     })
   }
-  // Context occupancy as a segmented bar: per-content-type runs colored by
-  // their own blue shade with a right-aligned usage readout. The used total
-  // is the most recent reported prompt size against the advertised route
-  // capacity (the same figures the old bracket bar showed).
+  // Context occupancy as a purely proportional bar with the usage readout
+  // riding outside it: the used total is the most recent reported prompt
+  // size against the advertised route capacity.
   if (stats.contextWindow > 0 && stats.lastPromptTokens > 0 && enabled.has('context')) {
     left.push({
       group: {
-        spans: [
-          { text: 'context ', tone: 'label' },
-          ...contextBar(stats.lastPromptTokens, stats.contextWindow, contextWidth),
-        ],
+        spans: contextGroupSpans(stats.lastPromptTokens, stats.contextWindow, contextWidth, 'full'),
       },
       rank: RANK_CONTEXT,
       id: 'context',
@@ -569,19 +574,18 @@ export function layoutStatusBar(
   const leftKept = [...orderedLeft]
   const rightKept = [...orderedRight]
 
-  // Context shrink state: the bar starts at its full budget and is rebuilt at
-  // ever narrower widths before the drop ladder is allowed to discard it.
+  // Context degradation state: the readout drops its absolute pair first,
+  // then the bar shrinks inside its own budget, and only then is the whole
+  // group removed — the proportional meter outlives the auxiliary numbers.
   // Rebuilding replaces the group's spans in place so width() re-measures it.
+  let contextReadout: ContextReadoutMode = 'full'
   let contextWidth = maxContextWidth
   const rebuildContext = (): void => {
     const index = leftKept.findIndex(entry => entry.id === 'context')
     if (index < 0) return
     leftKept[index] = {
       group: {
-        spans: [
-          { text: 'context ', tone: 'label' },
-          ...contextBar(stats.lastPromptTokens, stats.contextWindow, contextWidth),
-        ],
+        spans: contextGroupSpans(stats.lastPromptTokens, stats.contextWindow, contextWidth, contextReadout),
       },
       rank: RANK_CONTEXT,
       id: 'context',
@@ -599,23 +603,24 @@ export function layoutStatusBar(
   }
 
   while (width() > budget) {
-    // Context is the lowest-priority visual group. Shrink or remove it before
-    // sacrificing the permission badge or its Shift+Tab affordance.
-    // Shrink the context bar instead of dropping it: reserve everything else
-    // and hand the deficit to the bar, clamped to CONTEXT_MIN_WIDTH. The
-    // fixed label ('context ') and the bar's own readout keep shrinking to
-    // the bare percent, so a tight terminal keeps context visible longer.
-    if (leftKept.some(entry => entry.id === 'context') && contextWidth > CONTEXT_MIN_WIDTH) {
-      const overflow = width() - budget
-      contextWidth = Math.max(CONTEXT_MIN_WIDTH, contextWidth - overflow)
-      rebuildContext()
-      continue
-    }
-    const contextIndex = leftKept.findIndex(entry => entry.id === 'context')
-    if (contextIndex >= 0) {
-      // Once the meter reaches its minimum useful width, remove the whole
-      // group before touching the permission badge or its keyboard hint.
-      leftKept.splice(contextIndex, 1)
+    // Context is the lowest-priority visual group: the bar shrinks inside
+    // its own budget first (the absolute readout survives), then the
+    // readout degrades to the bare percent, and only then does the whole
+    // group go — before the permission badge or its Shift+Tab affordance
+    // is touched.
+    if (leftKept.some(entry => entry.id === 'context')) {
+      if (contextWidth > CONTEXT_MIN_WIDTH) {
+        const overflow = width() - budget
+        contextWidth = Math.max(CONTEXT_MIN_WIDTH, contextWidth - overflow)
+        rebuildContext()
+        continue
+      }
+      if (contextReadout === 'full') {
+        contextReadout = 'percent'
+        rebuildContext()
+        continue
+      }
+      leftKept.splice(leftKept.findIndex(entry => entry.id === 'context'), 1)
       continue
     }
     if (hint && rightKept.length > 0 && leftKept.length > 0) {

package/src/render/text.ts

@@ -145,8 +145,14 @@ export function displayTail(text: string, columns: number, rows: number): Displa
     used += width
     lastCluster = cluster
   }
-  if (current !== '' || (wrapped.length > 0 && text.endsWith('\n'))) flush()
-
+  // A trailing newline means one deliberate empty caret row, but that row
+  // must never evict real content or fake a truncation marker: flush the
+  // content first, decide truncation on content alone, then append the blank
+  // row only when the whole tail still fits the budget.
+  const trailingBlank = current === '' && wrapped.length > 0 && text.endsWith('\n')
+  if (current !== '') flush()
   const truncated = wrapped.length > rowLimit
-  return { text: (truncated ? wrapped.slice(-rowLimit) : wrapped).join('\n'), truncated }
+  const kept = truncated ? wrapped.slice(-rowLimit) : wrapped
+  const keptRows = trailingBlank && kept.length < rowLimit ? [...kept, ''] : kept
+  return { text: keptRows.join('\n'), truncated }
 }

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

@@ -61,35 +61,48 @@ function toRows(skills: readonly SkillSummary[]): readonly SkillRow[] {
  * @param ctx - context carrying the `skills` service (optional).
  * @returns the view the completion menu subscribes to.
  */
-export function watchSkills(ctx: Context): SkillsWatch {
+export function watchSkills(ctx: Context, fallbackCwd?: string): SkillsWatch {
   const skills = ctx.get('skills')
   let agent: Agent | undefined
   let rows: readonly SkillRow[] = []
   let error: string | undefined
+  // The agent whose workspace the current rows were last successfully read
+  // from: a failure for an agent that never loaded must clear the rows, not
+  // keep another workspace's catalog answerable in this session.
+  let loadedFor: Agent | undefined
   const listeners = new Set<() => void>()
 
   const reload = (): void => {
     const target = agent
     if (skills === undefined || target === undefined) return
     Promise.resolve().then(() => skills.list({
-      cwd: target.session.header.cwd,
+      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
       const next = toRows(summaries)
-      const unchanged = next.length === rows.length && next.every((row, index) => row.name === rows[index]?.name)
+      // Description and invocation-flag edits must surface too: a name-only
+      // comparison silently dropped those change notifications.
+      const unchanged = next.length === rows.length && next.every((row, index) =>
+        row.name === rows[index]?.name
+        && row.description === rows[index]?.description
+        && row.modelInvocable === rows[index]?.modelInvocable)
       rows = next
+      loadedFor = target
       const recovered = error !== undefined
       error = undefined
       if (unchanged && !recovered) return
       for (const listener of listeners) listener()
     }).catch((cause: unknown) => {
       if (agent !== target) return
-      // Discovery failure keeps the last good rows; the next skills/change
-      // notification is the retry surface (mirrors the web directory).
-      rows = [...rows]
+      // Discovery failure keeps the last good rows for the SAME agent (the
+      // next skills/change notification is the retry surface, mirroring the
+      // web directory); an agent that never loaded starts from empty rows —
+      // stale rows from a previous workspace must not keep completing here.
+      if (loadedFor !== target) rows = []
+      else rows = [...rows]
       error = cause instanceof Error ? cause.message : String(cause)
       for (const listener of listeners) listener()
     })