dsh-code 1.0.6 → 1.0.7

package/src/render/projection.ts

@@ -23,6 +23,7 @@ import type {} from '@deepseek-ai/dsh-goal'
 import type {} from '@deepseek-ai/dsh-llm-retry'
 import type {} from '@deepseek-ai/dsh-plan-mode'
 import type {} from '@deepseek-ai/dsh-permission-presets'
+import type {} from '@deepseek-ai/dsh-schedule'
 import type {} from '@deepseek-ai/dsh-sandbox-policy'
 import type {} from '@deepseek-ai/dsh-session-title'
 // The subagent package's durable catalog event joins the union the same way
@@ -273,6 +274,86 @@ export interface TranscriptStats {
   reasoningEffort: string
 }
 
+/** One active reminder folded from durable `schedule/change` events. */
+export interface ScheduleRow {
+  readonly id: string
+  readonly kind: 'after' | 'at' | 'every'
+  readonly prompt: string
+  /** Next due time (epoch ms); the /schedule panel derives overdue/relative labels. */
+  readonly targetAt: number
+  /** Recurrence seconds for 'every' rows, undefined otherwise. */
+  readonly everySeconds?: number
+}
+
+/**
+ * The durable `schedule/change` payload shape this fold consumes. Upstream
+ * strict-decodes the whole transition stream before appending, so unknown
+ * ids here are corrupt-input edges that degrade to a no-op.
+ */
+export interface ScheduleChangeLike {
+  readonly operation: 'create' | 'delete' | 'dispatch'
+  readonly schedule?: {
+    readonly id: string
+    readonly kind: 'after' | 'at' | 'every'
+    readonly prompt: string
+    readonly afterSeconds?: number
+    readonly everySeconds?: number
+    readonly scheduledAt: string
+  }
+  readonly id?: string
+  readonly acceptedAt?: string
+}
+
+/*
+ * Upstream record semantics (dsh-schedule types): `scheduledAt` is ALREADY
+ * the due instant — AfterScheduleRecord carries the RFC 3339 UTC target
+ * (delay included), EveryScheduleRecord carries the earliest anchor-aligned
+ * occurrence not yet dispatched. No kind ever adds its own interval on top.
+ */
+
+/** Fold one `schedule/change` into the active-reminder list (create/delete/dispatch). */
+export function applyScheduleChange(rows: readonly ScheduleRow[], data: ScheduleChangeLike): readonly ScheduleRow[] {
+  if (data.operation === 'create' && data.schedule !== undefined) {
+    const schedule = data.schedule
+    const row: ScheduleRow = {
+      id: schedule.id,
+      kind: schedule.kind,
+      prompt: schedule.prompt,
+      targetAt: Date.parse(schedule.scheduledAt),
+      ...(schedule.kind === 'every' ? { everySeconds: schedule.everySeconds ?? 0 } : {}),
+    }
+    return [...rows.filter(existing => existing.id !== schedule.id), row]
+  }
+  if (data.operation === 'delete' && data.id !== undefined) {
+    return rows.filter(existing => existing.id !== data.id)
+  }
+  if (data.operation === 'dispatch' && data.id !== undefined) {
+    // A dispatched one-shot reminder is finished. An 'every' reminder
+    // advances PAST every missed occurrence in one step: the next target is
+    // the first anchor-aligned instant strictly after acceptedAt, stepping
+    // from the previous aligned target (upstream advances the same way).
+    if (data.acceptedAt === undefined) return rows.filter(existing => existing.id !== data.id)
+    const accepted = Date.parse(data.acceptedAt)
+    return rows.map(existing => existing.id === data.id
+      ? { ...existing, targetAt: nextEveryTarget(existing.targetAt, accepted, existing.everySeconds ?? 0) }
+      : existing)
+  }
+  return rows
+}
+
+/** First anchor-aligned target after `acceptedAt`, stepping from the previous aligned target. */
+export function nextEveryTarget(previousTarget: number, acceptedAt: number, everySeconds: number): number {
+  const interval = Math.max(1, everySeconds) * 1000
+  if (acceptedAt <= previousTarget) return previousTarget + interval
+  const missed = Math.ceil((acceptedAt - previousTarget + 1) / interval)
+  return previousTarget + missed * interval
+}
+
+/** Plugin snapshot sources folded into token stats but never rendered as rows. */
+const HIDDEN_SNAPSHOT_PLUGINS = new Set(['time-context', 'tmux-context'])
+/** Plugin prompt sources rendered as full user rows (they ARE the conversation). */
+const REMINDER_PLUGINS = new Set(['schedule'])
+
 /** The complete TUI transcript view for one session. */
 export interface TranscriptView {
   /** Settled entries in log order. */
@@ -319,6 +400,8 @@ export interface TranscriptView {
   sandbox: string
   /** Current long-running goal folded from the last `goal/change`, undefined when cleared. */
   goal: GoalFold | undefined
+  /** Active reminders folded from `schedule/change` events, oldest target first at render. */
+  schedules: readonly ScheduleRow[]
   /**
    * Ordered live message ids per inbox target, mirrored from
    * `agent/inbox/spliced` exactly like the upstream Inbox projection — the
@@ -491,6 +574,7 @@ export function createTranscriptView(): TranscriptView {
     systemPrompt: '',
     sandbox: '',
     goal: undefined,
+    schedules: [],
     pending: { 'next-turn': [], 'next-step': [] },
     stats: { turns: 0, steps: 0, llmMs: 0, toolMs: 0, usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 }, lastPromptTokens: 0, contextWindow: 0, contextSegments: { system: 0, prompt: 0, assistant: 0, thinking: 0, tools: 0 }, ttftMs: 0, ttftSteps: 0, decodeMs: 0, decodeTokens: 0, reasoningEffort: '' },
     anchors: { stepStart: new Map(), toolStart: new Map(), firstChunkAt: new Map(), compactionTokens: new Map(), lastPruneTokens: 0, turnFiles: new Map(), turnSteps: new Map(), turnTools: new Map(), systemNodes: new Map() },
@@ -558,9 +642,42 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
           },
         }
       }
+      // Snapshot injections (time/tmux context) still spend model context but
+      // render nothing; the schedule reminder is a real prompt and renders in
+      // full — the model acts on it, so the transcript must show it.
+      if (message.source.kind === 'plugin' && HIDDEN_SNAPSHOT_PLUGINS.has(message.source.plugin)) {
+        return {
+          ...view,
+          pending,
+          entries,
+          stats: {
+            ...view.stats,
+            contextSegments: {
+              ...view.stats.contextSegments,
+              system: view.stats.contextSegments.system + estimateTokens(text),
+            },
+          },
+        }
+      }
+      if (message.source.kind === 'plugin' && REMINDER_PLUGINS.has(message.source.plugin)) {
+        return {
+          ...view,
+          pending,
+          entries: [...entries, { kind: 'user', text, notice: false, ...(images.length === 0 ? {} : { images }), ...(files.length === 0 ? {} : { files }) }],
+          stats: {
+            ...view.stats,
+            contextSegments: {
+              ...view.stats.contextSegments,
+              prompt: view.stats.contextSegments.prompt + estimateTokens(text),
+            },
+          },
+        }
+      }
       const notice = message.source.kind === 'plugin' && message.source.form === 'notice'
         ? message.source.summary
-        : message.source.kind
+        : message.source.kind === 'plugin'
+          ? message.source.plugin
+          : message.source.kind
       const summary = boundContextSummary(notice)
       return {
         ...view,
@@ -963,6 +1080,11 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
         entries: line === undefined ? view.entries : [...view.entries, { kind: 'turn-marker', text: line }],
       }
     }
+    case 'schedule/change':
+      // Non-conversational catalog state: the /schedule panel renders the
+      // active list, the transcript shows only the reminder prompts
+      // (handled at user/message above).
+      return { ...view, schedules: applyScheduleChange(view.schedules, event.data) }
     case 'session/title':
       // Latest-wins title snapshot, log-only; the status line prefers it.
       return { ...view, title: event.data.title }
@@ -1098,6 +1220,7 @@ export interface ReplayAccumulator {
   systemPrompt: string
   sandbox: string
   goal: GoalFold | undefined
+  schedules: readonly ScheduleRow[]
   stats: TranscriptStats
   stepStart: Map<string, number>
   toolStart: Map<string, number>
@@ -1137,6 +1260,7 @@ export function createReplayAccumulator(): ReplayAccumulator {
     systemPrompt: '',
     sandbox: '',
     goal: undefined,
+    schedules: [],
     stats: { turns: 0, steps: 0, llmMs: 0, toolMs: 0, usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 }, lastPromptTokens: 0, contextWindow: 0, contextSegments: { system: 0, prompt: 0, assistant: 0, thinking: 0, tools: 0 }, ttftMs: 0, ttftSteps: 0, decodeMs: 0, decodeTokens: 0, reasoningEffort: '' },
     stepStart: new Map(),
     toolStart: new Map(),
@@ -1270,7 +1394,7 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       const text = textOf(message.content)
       const images = imagesOf(message.content)
       const files = filesOf(message.content)
-      if (message.source.kind === 'user') {
+      if (message.source.kind === 'user' || (message.source.kind === 'plugin' && REMINDER_PLUGINS.has(message.source.plugin))) {
         appendReplayEntry(acc, { kind: 'user', text, notice: false, ...(images.length === 0 ? {} : { images }), ...(files.length === 0 ? {} : { files }) })
         acc.stats = {
           ...acc.stats,
@@ -1281,9 +1405,21 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
         }
         return true
       }
+      if (message.source.kind === 'plugin' && HIDDEN_SNAPSHOT_PLUGINS.has(message.source.plugin)) {
+        acc.stats = {
+          ...acc.stats,
+          contextSegments: {
+            ...acc.stats.contextSegments,
+            system: acc.stats.contextSegments.system + estimateTokens(text),
+          },
+        }
+        return true
+      }
       const notice = message.source.kind === 'plugin' && message.source.form === 'notice'
         ? message.source.summary
-        : message.source.kind
+        : message.source.kind === 'plugin'
+          ? message.source.plugin
+          : message.source.kind
       const summary = boundContextSummary(notice)
       appendReplayEntry(acc, { kind: 'user', text: summary, notice: true })
       acc.stats = {
@@ -1603,6 +1739,10 @@ export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent):
       if (line !== undefined) appendReplayEntry(acc, { kind: 'turn-marker', text: line })
       return true
     }
+    case 'schedule/change':
+      acc.schedules = applyScheduleChange(acc.schedules, event.data)
+      acc.ops += 1
+      return true
     case 'session/title':
       acc.title = event.data.title
       return true
@@ -1715,6 +1855,7 @@ function materializeReplayView(acc: ReplayAccumulator, copy: boolean): Transcrip
     systemPrompt: acc.systemPrompt,
     sandbox: acc.sandbox,
     goal: acc.goal,
+    schedules: acc.schedules,
     pending: { 'next-turn': [...acc.pendingTurn], 'next-step': [...acc.pendingStep] },
     stats: acc.stats,
     // Handed-out views get their own anchors snapshot: the accumulator keeps

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-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