dsh-notch 0.3.1

package/src/board.ts

@@ -0,0 +1,299 @@
+import { randomUUID } from 'node:crypto'
+import type { Context } from '@deepseek-ai/cordis'
+import type { Session } from '@deepseek-ai/dsh-session'
+import type { ApprovalOutcome, ApprovalRequest } from '@deepseek-ai/dsh-user-approval'
+import type {
+  AskUserQuestionAnswer,
+  AskUserQuestionRequest,
+} from '@deepseek-ai/dsh-user-questions'
+import { foldSession, isChildSession } from './session-state.ts'
+import { loadSeen, saveSeen } from './store.ts'
+import type {
+  ApprovalOutcomeWire,
+  NotchAnswerItem,
+  NotchApproval,
+  NotchAsk,
+  NotchFocus,
+  NotchQuestion,
+  NotchRow,
+  NotchSnapshot,
+} from './types.ts'
+
+interface HeldApproval {
+  kind: 'approval'
+  id: string
+  sessionId: string
+  toolName: string
+  reason?: string
+  resolve: (outcome: ApprovalOutcome) => void
+}
+
+interface HeldAsk {
+  kind: 'ask'
+  id: string
+  sessionId: string
+  questions: NotchQuestion[]
+  resolve: (answer: AskUserQuestionAnswer) => void
+}
+
+type Held = HeldApproval | HeldAsk
+
+interface SidebarRow { id: string; title: string; completed: boolean; running: boolean }
+export class Board {
+  private sidebar: { clientId: string; at: number; rows: SidebarRow[] } | undefined
+
+  syncSidebar(input: unknown): boolean {
+    if (!input || typeof input !== 'object') return false
+    const data = input as { clientId?: unknown; focused?: unknown; rows?: unknown }
+    if (typeof data.clientId !== 'string' || !Array.isArray(data.rows) || data.rows.length > 1000) return false
+    const rows: SidebarRow[] = []
+    for (const row of data.rows) {
+      if (!row || typeof row.id !== 'string' || !row.id.startsWith('session-') || typeof row.title !== 'string' || typeof row.completed !== 'boolean' || typeof row.running !== 'boolean') return false
+      rows.push({ id: row.id, title: row.title.slice(0, 512), completed: row.completed, running: row.running })
+    }
+    // A background browser cannot overwrite the last foreground page's state.
+    if (this.sidebar && this.sidebar.clientId !== data.clientId && data.focused !== true && Date.now() - this.sidebar.at < 5000) return true
+    this.sidebar = { clientId: data.clientId, at: Date.now(), rows }
+    this.bump()
+    return true
+  }
+
+  private sidebarRows(): SidebarRow[] | undefined {
+    return this.sidebar && Date.now() - this.sidebar.at < 5000 ? this.sidebar.rows : undefined
+  }
+
+  private readonly pending = new Map<string, Held>()
+  private readonly seen = loadSeen()
+  private readonly running = new Set<string>()
+  private readonly pendingUnread = new Set<string>()
+  private readonly listeners = new Set<() => void>()
+  private focus: NotchFocus | null = null
+
+  constructor(private readonly ctx: Context) {}
+
+  onChange(fn: () => void): () => void {
+    this.listeners.add(fn)
+    return () => { this.listeners.delete(fn) }
+  }
+
+  notify(): void {
+    this.bump()
+  }
+
+  private bump(): void {
+    for (const fn of this.listeners) {
+      try { fn() } catch (error) { this.ctx.logger.warn('dsh-notch: subscriber failed: %s', String(error)) }
+    }
+  }
+
+  snapshot(origin: string): NotchSnapshot {
+    const rows: NotchRow[] = []
+    for (const session of this.ctx.sessions.list()) {
+      const row = this.rowFor(session)
+      if (row) rows.push(row)
+    }
+    for (const source of this.sidebarRows() ?? []) {
+      if (rows.some(row => row.id === source.id) || (!source.completed && !source.running)) continue
+      if (source.completed && this.seen[source.id] !== undefined) continue
+      rows.push({ id: source.id, title: source.title, child: false, busy: source.running, unread: source.completed })
+    }
+    rows.sort((a, b) => Number(Boolean(b.approval || b.ask)) - Number(Boolean(a.approval || a.ask))
+      || Number(b.busy) - Number(a.busy)
+      || Number(b.unread) - Number(a.unread)
+      || (b.lastTurn?.at ?? 0) - (a.lastTurn?.at ?? 0))
+    this.running = new Set(
+      this.ctx.sessions.list().filter((session) => this.isBusy(session)).map((session) => session.id),
+    )
+    return { ok: true, generatedAt: Date.now(), origin, rows, sidebarSyncedAt: this.sidebarRows() ? this.sidebar?.at : undefined }
+  }
+
+  markSeen(sessionId: string): void {
+    this.pendingUnread.delete(sessionId)
+    this.seen[sessionId] = Date.now()
+    saveSeen(this.seen)
+    this.bump()
+  }
+
+  markAllSeen(): void {
+    this.pendingUnread.clear()
+    const now = Date.now()
+    for (const session of this.ctx.sessions.list()) {
+      this.seen[session.id] = now
+    }
+    saveSeen(this.seen)
+    this.bump()
+  }
+
+  /**
+   * Record a "show this session in a DSH UI" wish from the native helper.
+   * Returns false for unknown sessions. The wish expires after 60s; every
+   * open DSH page consumes it idempotently, so no per-client cursor is kept.
+   */
+  requestFocus(sessionId: string): boolean {
+    const known = this.ctx.sessions.list().some((session) => session.id === sessionId)
+    if (!known && !this.sidebarRows()?.some(row => row.id === sessionId)) return false
+    this.focus = { sessionId, at: Date.now() }
+    this.bump()
+    return true
+  }
+
+  peekFocus(): NotchFocus | null {
+    if (this.focus === null) return null
+    if (Date.now() - this.focus.at > 60_000) {
+      this.focus = null
+      return null
+    }
+    return this.focus
+  }
+
+  decideApproval(id: string, outcome: ApprovalOutcomeWire): boolean {
+    const held = this.pending.get(id)
+    if (!held || held.kind !== 'approval') return false
+    this.pending.delete(id)
+    this.seen[held.sessionId] = Date.now()
+    saveSeen(this.seen)
+    held.resolve(outcome)
+    this.bump()
+    return true
+  }
+
+  answerAsk(id: string, answers: NotchAnswerItem[]): boolean {
+    const held = this.pending.get(id)
+    if (!held || held.kind !== 'ask') return false
+    this.pending.delete(id)
+    this.seen[held.sessionId] = Date.now()
+    saveSeen(this.seen)
+    held.resolve({ answers })
+    this.bump()
+    return true
+  }
+
+  holdApproval(request: ApprovalRequest, next: () => Promise<ApprovalOutcome>): Promise<ApprovalOutcome> {
+    const sessionId = String(request.agent.id)
+    const id = randomUUID()
+    const fromNotch = new Promise<ApprovalOutcome>((resolve) => {
+      const held: HeldApproval = {
+        kind: 'approval',
+        id,
+        sessionId,
+        toolName: request.toolName,
+        resolve,
+      }
+      if (request.reason) held.reason = request.reason
+      this.pending.set(id, held)
+      this.bump()
+      request.signal?.addEventListener('abort', () => {
+        if (!this.pending.delete(id)) return
+        this.bump()
+      }, { once: true })
+    })
+    return Promise.race([fromNotch, next()]).finally(() => {
+      if (this.pending.delete(id)) this.bump()
+    })
+  }
+
+  holdAsk(request: AskUserQuestionRequest, next: () => Promise<AskUserQuestionAnswer>): Promise<AskUserQuestionAnswer> {
+    const sessionId = request.agent ? String(request.agent.id) : ''
+    if (!sessionId) return next()
+    const originalSignal = request.signal
+    const downstream = new AbortController()
+    request.signal = originalSignal
+      ? AbortSignal.any([originalSignal, downstream.signal])
+      : downstream.signal
+    const id = randomUUID()
+    const questions: NotchQuestion[] = request.questions.map((item) => ({
+      id: item.id,
+      question: item.question,
+      ...(item.detail === undefined ? {} : { detail: item.detail }),
+      ...(item.header === undefined ? {} : { header: item.header }),
+      ...(item.options === undefined ? {} : { options: item.options }),
+      ...(item.multiSelect === undefined ? {} : { multiSelect: item.multiSelect }),
+      ...(item.intent === undefined ? {} : { intent: item.intent }),
+    }))
+    const fromNotch = new Promise<AskUserQuestionAnswer>((resolve) => {
+      this.pending.set(id, { kind: 'ask', id, sessionId, questions, resolve })
+      this.bump()
+      request.signal?.addEventListener('abort', () => {
+        if (!this.pending.delete(id)) return
+        this.bump()
+      }, { once: true })
+    })
+    return Promise.race([fromNotch, Promise.resolve().then(next)]).finally(() => {
+      // The losing Web answerer must end too, so its pending interaction unmounts.
+      // Cancel only this delegated wait, never the owning agent's signal.
+      downstream.abort(new Error('Question settled through another answerer'))
+      if (originalSignal === undefined) delete request.signal
+      else request.signal = originalSignal
+      if (this.pending.delete(id)) this.bump()
+    })
+  }
+
+  private isBusy(session: Session): boolean {
+    return this.ctx.agents.get(session.id)?.status === 'running'
+  }
+
+  private rowFor(session: Session): NotchRow | undefined {
+    const folded = foldSession(session)
+    const child = isChildSession(session)
+    const lastSeen = this.seen[session.id]
+    const busy = this.isBusy(session)
+    if (busy) {
+      this.pendingUnread.delete(session.id)
+    } else if (this.running.has(session.id) && folded.lastTurn && !folded.lastTurn.failed) {
+      this.pendingUnread.add(session.id)
+    }
+    const dismissed = lastSeen !== undefined && (folded.lastTurn === undefined || lastSeen >= folded.lastTurn.at)
+    const mirror = this.sidebarRows()
+    const unread = dismissed
+      ? false
+      : mirror !== undefined
+        ? mirror.some(row => row.id === session.id && row.completed)
+        : this.pendingUnread.has(session.id)
+          || (folded.lastTurn !== undefined && lastSeen !== undefined && folded.lastTurn.at > lastSeen)
+    const approval = this.heldApproval(session.id)
+    const ask = this.heldAsk(session.id)
+    if (!busy && !unread && !approval && !ask) return undefined
+    if (child && !approval && !ask && !busy) return undefined
+    const title = this.titleOf(session)
+    const row: NotchRow = {
+      id: session.id,
+      title,
+      child,
+      busy,
+      unread,
+    }
+    if (folded.lastTurn && !busy) row.lastTurn = folded.lastTurn
+    if (approval) row.approval = approval
+    if (ask) row.ask = ask
+    return row
+  }
+
+  private heldApproval(sessionId: string): NotchApproval | undefined {
+    for (const held of this.pending.values()) {
+      if (held.kind === 'approval' && held.sessionId === sessionId) {
+        return {
+          id: held.id,
+          toolName: held.toolName,
+          ...(held.reason === undefined ? {} : { reason: held.reason }),
+        }
+      }
+    }
+    return undefined
+  }
+
+  private heldAsk(sessionId: string): NotchAsk | undefined {
+    for (const held of this.pending.values()) {
+      if (held.kind === 'ask' && held.sessionId === sessionId) {
+        return { id: held.id, questions: held.questions }
+      }
+    }
+    return undefined
+  }
+
+  private titleOf(session: Session): string {
+    const service = this.ctx.get('sessionTitle') as { get(target: Session): { title: string } | undefined } | undefined
+    const title = service?.get(session)?.title?.trim()
+    if (title) return title
+    return session.id.slice(0, 8)
+  }
+}

package/src/browse-sync.ts

@@ -0,0 +1,59 @@
+/** Observe browsing without changing the history transport or retaining disposed boards. */
+const KEY = Symbol.for('dsh-notch.browse-sync.v1')
+type Controller = Record<PropertyKey, any>
+type Observer = (id: string) => void
+function sessionId(request: any): string | undefined {
+  const value = request?.address?.sessionId ?? request?.address?.childSessionId
+  return typeof value === 'string' ? value : undefined
+}
+export function installBrowseSync(controller: Controller, observe: Observer): () => void {
+  let state = controller[KEY]
+  if (!state) {
+    // Older Notch versions assigned wrappers without a disposer. Only replace
+    // those exact known wrappers, using the verified official prototype method.
+    for (const name of ['page', 'follow']) {
+      const own = Object.getOwnPropertyDescriptor(controller, name)
+      const text = typeof own?.value === 'function' ? own.value.toString().replace(/\s/g, '') : ''
+      const legacy = name === 'follow'
+        ? 'function*(req,signal){constsid=getTargetSessionId(req.address);if(sid)board.markSeen(sid);returnyield*origFollow(req,signal)}'
+        : '(req,signal)=>{constsid=getTargetSessionId(req.address);if(sid)board.markSeen(sid);returnorigPage(req,signal)}'
+      if (text === legacy) {
+        const base = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(controller), name)?.value
+        if (typeof base !== 'function' || !base.toString().replace(/\s/g, '').includes(`returnthis.history.${name}(request,signal)`)) {
+          throw new Error(`Cannot restore known legacy Notch ${name}: official prototype changed`)
+        }
+        delete controller[name]
+      }
+    }
+    state = { observers: new Set<Observer>(), methods: [] as any[] }
+    for (const name of ['page', 'follow']) {
+      const descriptor = Object.getOwnPropertyDescriptor(controller, name)
+      const original = controller[name]
+      const wrapped = function(this: unknown, ...args: any[]) {
+        const result = Reflect.apply(original, this, args)
+        const id = sessionId(args[0])
+        if (id) for (const callback of [...state.observers] as Observer[]) {
+          try { callback(id) } catch { /* Optional read marker must never break history. */ }
+        }
+        return result
+      }
+      controller[name] = wrapped
+      state.methods.push({ name, descriptor, wrapped })
+    }
+    controller[KEY] = state
+  }
+  state.observers.add(observe)
+  let disposed = false
+  return () => {
+    if (disposed) return
+    disposed = true
+    state.observers.delete(observe)
+    if (state.observers.size) return
+    for (const { name, descriptor, wrapped } of state.methods) {
+      if (controller[name] !== wrapped) continue
+      if (descriptor) Object.defineProperty(controller, name, descriptor)
+      else delete controller[name]
+    }
+    if (controller[KEY] === state) delete controller[KEY]
+  }
+}

package/src/dsh-notch.ts

@@ -0,0 +1,60 @@
+import type { Context } from '@deepseek-ai/cordis'
+import type { ApprovalOutcome, ApprovalRequest } from '@deepseek-ai/dsh-user-approval'
+import type { AskUserQuestionAnswer, AskUserQuestionRequest } from '@deepseek-ai/dsh-user-questions'
+import type {} from '@deepseek-ai/dsh-host-webserver'
+import type {} from '@deepseek-ai/dsh-session'
+import { Board } from './board.ts'
+import { attachHttp } from './http.ts'
+import { loadOrCreateToken, writeRuntime } from './store.ts'
+
+export const name = 'dsh-notch'
+export const inject = ['sessions', 'webServer', 'approval', 'userQuestions', 'agents']
+
+export function apply(ctx: Context) {
+  console.log('[my-plugins/dsh-notch] loaded')
+  const board = new Board(ctx)
+  const token = loadOrCreateToken()
+  const origin = `http://${ctx.webServer.host}:${String(ctx.webServer.port)}`
+  writeRuntime({
+    origin,
+    token,
+    pid: process.pid,
+    writtenAt: Date.now(),
+  })
+
+  ctx.effect(() => attachHttp(ctx, board, token, origin), 'dsh-notch: http')
+
+  const notify = debounce(() => board.notify(), 80)
+  ctx.effect(() => notify.dispose, 'dsh-notch: notification timer')
+  ctx.effect(() => ctx.on('session/created', notify), 'dsh-notch: created')
+  ctx.effect(() => ctx.on('session/disposed', notify), 'dsh-notch: disposed')
+  ctx.effect(() => ctx.on('session/event', (session, event) => {
+    const type = String(event.type)
+    if (type === 'turn/start' || type === 'turn/end' || type === 'session/title') {
+      notify()
+    }
+    // When a turn starts or user sends a message in DSH, mark session as read
+    if (type === 'turn/start' || (type === 'user/message' && (event.data as Record<string, unknown>)?.source === 'user')) {
+      board.markSeen(session.id)
+    }
+  }), 'dsh-notch: events')
+  ctx.effect(() => ctx.on('agent/status', notify), 'dsh-notch: agent-status')
+
+
+  // Only intercept user-questions/request (AskUserQuestion).
+  // Do NOT intercept internal tool approval/request which causes false alarms
+  // when background agent tools run sandbox checks.
+  ctx.on('user-questions/request', (
+    request: AskUserQuestionRequest,
+    next: () => Promise<AskUserQuestionAnswer>,
+  ) => board.holdAsk(request, next), { prepend: true })
+}
+
+function debounce(fn: () => void, ms: number): (() => void) & { dispose: () => void } {
+  let timer: ReturnType<typeof setTimeout> | undefined
+  const notify = () => {
+    if (timer) clearTimeout(timer)
+    timer = setTimeout(() => { timer = undefined; fn() }, ms)
+  }
+  return Object.assign(notify, { dispose: () => { if (timer) clearTimeout(timer); timer = undefined } })
+}

package/src/http.ts

@@ -0,0 +1,215 @@
+import { randomUUID } from 'node:crypto'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { Context } from '@deepseek-ai/cordis'
+import type { Board } from './board.ts'
+import type { ApprovalOutcomeWire, NotchAnswerItem } from './types.ts'
+
+const PREFIX = '/dsh-notch'
+
+export function isLoopback(req: IncomingMessage): boolean {
+  const ip = req.socket.remoteAddress ?? ''
+  return ip === '127.0.0.1' || ip === '::1' || ip === ':ffff:127.0.0.1' || ip === '::ffff:127.0.0.1'
+}
+
+export function authorized(req: IncomingMessage, token: string): boolean {
+  const header = req.headers.authorization
+  if (header === `Bearer ${token}`) return true
+  try {
+    const url = new URL(req.url ?? '/', 'http://127.0.0.1')
+    return url.searchParams.get('token') === token
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Browser-side trust for pages served by this same Host: loopback remote,
+ * never cross-site, and a matching Origin when one is present. Same rule the
+ * shipped workspace file panel uses — no secret ever lands in page JS.
+ */
+export function browserTrusted(req: IncomingMessage): boolean {
+  if (!isLoopback(req)) return false
+  if (req.headers['sec-fetch-site'] === 'cross-site') return false
+  const host = req.headers.host
+  if (host === undefined) return false
+  const origin = req.headers.origin
+  if (origin === undefined) return true
+  try {
+    return new URL(origin).host === new URL(`http://${host}`).host
+  } catch {
+    return false
+  }
+}
+
+function send(res: ServerResponse, status: number, body: unknown): void {
+  const json = JSON.stringify(body)
+  res.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+  })
+  res.end(json)
+}
+
+function readBody(req: IncomingMessage, limit = 64 * 1024): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    let size = 0
+    req.on('data', (chunk: Buffer) => {
+      size += chunk.length
+      if (size > limit) {
+        reject(new Error('body too large'))
+        req.destroy()
+        return
+      }
+      chunks.push(chunk)
+    })
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')))
+    req.on('error', reject)
+  })
+}
+
+export function attachHttp(ctx: Context, board: Board, token: string, origin: string): () => void {
+  const streams = new Map<string, ServerResponse>()
+  const push = () => {
+    const payload = `data: ${JSON.stringify(board.snapshot(origin))}\n\n`
+    for (const [id, res] of streams) {
+      try {
+        res.write(payload)
+      } catch {
+        streams.delete(id)
+      }
+    }
+  }
+  const stopListen = board.onChange(push)
+
+  const handler = async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
+    const url = new URL(req.url ?? '/', 'http://127.0.0.1')
+    const path = url.pathname
+    const method = req.method ?? 'GET'
+
+    // Browser pages served by this same Host consume focus wishes through
+    // same-origin trust (no secret in page JS); everything else keeps the
+    // notch Bearer token.
+    if (method === 'GET' && path === `${PREFIX}/pending-focus`) {
+      if (!browserTrusted(req)) {
+        send(res, 403, { ok: false, error: 'forbidden' })
+        return
+      }
+      send(res, 200, { ok: true, focus: board.peekFocus() })
+      return
+    }
+
+    if (method === 'POST' && path === `${PREFIX}/sidebar`) {
+      // JSON, explicit same origin, and browser fetch metadata prevent cross-site writes.
+      if (!browserTrusted(req) || !req.headers.origin || !req.headers['content-type']?.startsWith('application/json')) {
+        send(res, 403, { ok: false, error: 'forbidden' })
+        return
+      }
+      const ok = board.syncSidebar(JSON.parse(await readBody(req, 512 * 1024)))
+      send(res, ok ? 200 : 400, { ok })
+      return
+    }
+
+    if (!isLoopback(req) || !authorized(req, token)) {
+      send(res, 403, { ok: false, error: 'forbidden' })
+      return
+    }
+
+    if (method === 'GET' && path === `${PREFIX}/status`) {
+      send(res, 200, board.snapshot(origin))
+      return
+    }
+
+    if (method === 'GET' && path === `${PREFIX}/events`) {
+      const id = randomUUID()
+      res.writeHead(200, {
+        'content-type': 'text/event-stream',
+        'cache-control': 'no-cache',
+        connection: 'keep-alive',
+      })
+      streams.set(id, res)
+      res.write(`data: ${JSON.stringify(board.snapshot(origin))}\n\n`)
+      req.on('close', () => { streams.delete(id) })
+      return
+    }
+
+    if (method === 'POST' && path === `${PREFIX}/seen`) {
+      const body = JSON.parse(await readBody(req)) as { sessionId?: string; all?: boolean }
+      if (body.all) {
+        board.markAllSeen()
+        send(res, 200, { ok: true })
+        return
+      }
+      if (!body.sessionId) {
+        send(res, 400, { ok: false, error: 'sessionId required' })
+        return
+      }
+      board.markSeen(body.sessionId)
+      send(res, 200, { ok: true })
+      return
+    }
+
+    if (method === 'POST' && path === `${PREFIX}/approve`) {
+      const body = JSON.parse(await readBody(req)) as { id?: string; outcome?: ApprovalOutcomeWire }
+      if (!body.id || (body.outcome !== 'allowed-once' && body.outcome !== 'rejected')) {
+        send(res, 400, { ok: false, error: 'id and outcome required' })
+        return
+      }
+      if (!board.decideApproval(body.id, body.outcome)) {
+        send(res, 404, { ok: false, error: 'not pending' })
+        return
+      }
+      send(res, 200, { ok: true })
+      return
+    }
+
+    if (method === 'POST' && path === `${PREFIX}/answer`) {
+      const body = JSON.parse(await readBody(req)) as { id?: string; answers?: NotchAnswerItem[] }
+      if (!body.id || !Array.isArray(body.answers)) {
+        send(res, 400, { ok: false, error: 'id and answers required' })
+        return
+      }
+      if (!board.answerAsk(body.id, body.answers)) {
+        send(res, 404, { ok: false, error: 'not pending' })
+        return
+      }
+      send(res, 200, { ok: true })
+      return
+    }
+
+    if (method === 'POST' && path === `${PREFIX}/focus`) {
+      const body = JSON.parse(await readBody(req)) as { sessionId?: string }
+      if (!body.sessionId) {
+        send(res, 400, { ok: false, error: 'sessionId required' })
+        return
+      }
+      if (!board.requestFocus(body.sessionId)) {
+        send(res, 404, { ok: false, error: 'unknown session' })
+        return
+      }
+      send(res, 200, { ok: true })
+      return
+    }
+
+    send(res, 404, { ok: false, error: 'not found' })
+  }
+
+  const disposeRoute = ctx.webServer.register({
+    kind: 'prefix',
+    path: PREFIX,
+    handler: (req, res) => {
+      void handler(req, res).catch((error: unknown) => {
+        if (!res.headersSent) send(res, 400, { ok: false, error: String(error) })
+      })
+    },
+  })
+
+  return () => {
+    stopListen()
+    for (const res of streams.values()) {
+      try { res.end() } catch { /* already closed */ }
+    }
+    streams.clear()
+    disposeRoute()
+  }
+}

package/src/session-state.ts

@@ -0,0 +1,31 @@
+import type { Session } from '@deepseek-ai/dsh-session'
+import type { NotchLastTurn } from './types.ts'
+
+export interface FoldedSession {
+  busy: boolean
+  lastTurn?: NotchLastTurn
+}
+
+const FAILED = new Set(['error', 'blocked', 'max-tokens'])
+
+export function foldSession(session: Session): FoldedSession {
+  let busy = false
+  let lastTurn: NotchLastTurn | undefined
+  for (const event of session.snapshotEvents()) {
+    if (event.type === 'turn/start') {
+      busy = true
+      lastTurn = undefined
+      continue
+    }
+    if (event.type === 'turn/end') {
+      busy = false
+      const kind = event.data.reason.kind
+      lastTurn = { at: event.time, kind, failed: FAILED.has(kind) }
+    }
+  }
+  return { busy, lastTurn }
+}
+
+export function isChildSession(session: Session): boolean {
+  return session.header.parentSession !== undefined || session.header.origin === 'subagent'
+}