@cuongtran001/kanna 1.63.2 → 1.63.3

package/src/server/claude-pty/pid-registry.test.ts

@@ -1,178 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test"
-import { mkdtemp, readFile, rm, writeFile, mkdir, stat } from "node:fs/promises"
-import os from "node:os"
-import path from "node:path"
-import { ClaudePtyRegistry, killProcessTree } from "./pid-registry.adapter"
-
-let tempDir = ""
-let registryPath = ""
-
-beforeEach(async () => {
-  tempDir = await mkdtemp(path.join(os.tmpdir(), "kanna-claude-pty-registry-"))
-  registryPath = path.join(tempDir, "claude-pty.json")
-})
-
-afterEach(async () => {
-  if (tempDir) {
-    await rm(tempDir, { recursive: true, force: true })
-  }
-})
-
-describe("ClaudePtyRegistry", () => {
-  test("register persists entries with sessionId, pid, cwd, runtimeDir", async () => {
-    const registry = new ClaudePtyRegistry(registryPath)
-    await registry.register({ chatId: "c1", sessionId: "s1", pid: 12345, cwd: "/tmp/a", runtimeDir: "/tmp/r1" })
-    await registry.register({ chatId: "c2", sessionId: "s2", pid: 23456, cwd: "/tmp/b", runtimeDir: "/tmp/r2" })
-
-    const raw = JSON.parse(await readFile(registryPath, "utf8")) as {
-      entries: Array<{ chatId: string; sessionId: string; pid: number; runtimeDir: string }>
-    }
-    expect(raw.entries).toHaveLength(2)
-    expect(raw.entries[0]).toMatchObject({ chatId: "c1", sessionId: "s1", pid: 12345, cwd: "/tmp/a", runtimeDir: "/tmp/r1" })
-    expect(raw.entries[1]).toMatchObject({ chatId: "c2", sessionId: "s2", pid: 23456, cwd: "/tmp/b", runtimeDir: "/tmp/r2" })
-  })
-
-  test("re-registering the same pid replaces the prior entry", async () => {
-    const registry = new ClaudePtyRegistry(registryPath)
-    await registry.register({ chatId: "c1", sessionId: "s1", pid: 100, cwd: "/tmp/old", runtimeDir: "/tmp/r-old" })
-    await registry.register({ chatId: "c1", sessionId: "s1", pid: 100, cwd: "/tmp/new", runtimeDir: "/tmp/r-new" })
-
-    const raw = JSON.parse(await readFile(registryPath, "utf8")) as { entries: Array<{ pid: number; runtimeDir: string }> }
-    expect(raw.entries).toHaveLength(1)
-    expect(raw.entries[0]?.pid).toBe(100)
-    expect(raw.entries[0]?.runtimeDir).toBe("/tmp/r-new")
-  })
-
-  test("re-spawn of the same sessionId with a new pid keeps BOTH entries (identity is pid, not sessionId)", async () => {
-    const registry = new ClaudePtyRegistry(registryPath)
-    await registry.register({ chatId: "c1", sessionId: "s1", pid: 38830, cwd: "/tmp/a", runtimeDir: "/tmp/r-old" })
-    await registry.register({ chatId: "c1", sessionId: "s1", pid: 41506, cwd: "/tmp/a", runtimeDir: "/tmp/r-new" })
-
-    const raw = JSON.parse(await readFile(registryPath, "utf8")) as { entries: Array<{ pid: number }> }
-    expect(raw.entries.map((e) => e.pid).sort((a, b) => a - b)).toEqual([38830, 41506])
-  })
-
-  test("unregister(pid) removes only the matching pid", async () => {
-    const registry = new ClaudePtyRegistry(registryPath)
-    await registry.register({ chatId: "c1", sessionId: "s1", pid: 1, cwd: "/tmp/a", runtimeDir: "/tmp/r1" })
-    await registry.register({ chatId: "c2", sessionId: "s2", pid: 2, cwd: "/tmp/b", runtimeDir: "/tmp/r2" })
-    await registry.unregister(1)
-
-    const raw = JSON.parse(await readFile(registryPath, "utf8")) as { entries: Array<{ pid: number }> }
-    expect(raw.entries).toHaveLength(1)
-    expect(raw.entries[0]?.pid).toBe(2)
-  })
-
-  test("unregister(stale pid) does NOT remove the live re-spawn entry sharing the sessionId", async () => {
-    const registry = new ClaudePtyRegistry(registryPath)
-    await registry.register({ chatId: "c1", sessionId: "s1", pid: 38830, cwd: "/tmp/a", runtimeDir: "/tmp/r-old" })
-    await registry.register({ chatId: "c1", sessionId: "s1", pid: 41506, cwd: "/tmp/a", runtimeDir: "/tmp/r-new" })
-    await registry.unregister(38830)
-
-    const raw = JSON.parse(await readFile(registryPath, "utf8")) as { entries: Array<{ pid: number }> }
-    expect(raw.entries.map((e) => e.pid)).toEqual([41506])
-  })
-
-  test("reapStale kills live process groups, removes runtimeDirs, and clears the file", async () => {
-    const child = Bun.spawn(
-      ["python3", "-c", "import os, sys, time; os.setsid(); sys.stdout.write('ready\\n'); sys.stdout.flush(); time.sleep(60)"],
-      { stdout: "pipe", stderr: "ignore", stdin: "ignore" },
-    )
-    const reader = child.stdout.getReader()
-    const decoded = new TextDecoder().decode((await reader.read()).value ?? new Uint8Array())
-    expect(decoded).toContain("ready")
-    reader.releaseLock()
-    const childPid = child.pid
-
-    const runtimeDir = path.join(tempDir, "spawn-runtime")
-    await mkdir(runtimeDir, { recursive: true })
-    await writeFile(path.join(runtimeDir, "mcp-config.json"), "{}", "utf8")
-
-    await writeFile(
-      registryPath,
-      JSON.stringify({
-        entries: [
-          { chatId: "c1", sessionId: "s1", pid: childPid, cwd: "/tmp/a", runtimeDir, createdAt: Date.now() },
-          { chatId: "c2", sessionId: "s2", pid: 999_999_999, cwd: "/tmp/b", runtimeDir: "/tmp/nonexistent", createdAt: Date.now() },
-        ],
-      }),
-      "utf8",
-    )
-
-    const registry = new ClaudePtyRegistry(registryPath)
-    const reaped = await registry.reapStale()
-
-    expect(reaped.map((entry) => entry.sessionId).sort()).toEqual(["s1", "s2"])
-
-    const exited = await Promise.race([
-      child.exited,
-      new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), 3_000)),
-    ])
-    expect(exited).not.toBe("timeout")
-    expect(child.signalCode).toBe("SIGKILL")
-    void childPid
-
-    await expect(stat(runtimeDir)).rejects.toThrow()
-
-    const raw = JSON.parse(await readFile(registryPath, "utf8")) as { entries: unknown[] }
-    expect(raw.entries).toEqual([])
-  }, 30_000)
-
-  test("killProcessTree reaps a NON-leader process and its descendants", async () => {
-    const parent = Bun.spawn(
-      [
-        "python3",
-        "-c",
-        "import subprocess, sys, time; c = subprocess.Popen(['sleep', '120']); "
-          + "sys.stdout.write(str(c.pid) + '\\n'); sys.stdout.flush(); time.sleep(120)",
-      ],
-      { stdout: "pipe", stderr: "ignore", stdin: "ignore" },
-    )
-    const reader = parent.stdout.getReader()
-    const childLine = new TextDecoder().decode((await reader.read()).value ?? new Uint8Array()).trim()
-    reader.releaseLock()
-    const childPid = Number.parseInt(childLine, 10)
-    expect(Number.isFinite(childPid)).toBe(true)
-    const parentPid = parent.pid
-
-    await killProcessTree(parentPid)
-
-    const exited = await Promise.race([
-      parent.exited,
-      new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), 5_000)),
-    ])
-    expect(exited).not.toBe("timeout")
-
-    await new Promise((r) => setTimeout(r, 200))
-    let childAlive = true
-    try { process.kill(childPid, 0) } catch { childAlive = false }
-    expect(childAlive).toBe(false)
-  }, 30_000)
-
-  test("killProcessTree ignores an invalid pid without throwing", async () => {
-    await killProcessTree(0)
-    await killProcessTree(-1)
-    await killProcessTree(Number.NaN)
-  })
-
-  test("reapStale tolerates a missing registry file", async () => {
-    const registry = new ClaudePtyRegistry(registryPath)
-    const reaped = await registry.reapStale()
-    expect(reaped).toEqual([])
-  })
-
-  test("reapStale tolerates a malformed registry file", async () => {
-    await writeFile(registryPath, "not json", "utf8")
-    const registry = new ClaudePtyRegistry(registryPath)
-    const reaped = await registry.reapStale()
-    expect(reaped).toEqual([])
-  })
-
-  test("register creates the parent directory if missing", async () => {
-    const nestedPath = path.join(tempDir, "nested", "deep", "claude-pty.json")
-    const registry = new ClaudePtyRegistry(nestedPath)
-    await registry.register({ chatId: "c1", sessionId: "s1", pid: 1, cwd: "/tmp/a", runtimeDir: "/tmp/r1" })
-    const raw = JSON.parse(await readFile(nestedPath, "utf8")) as { entries: unknown[] }
-    expect(raw.entries).toHaveLength(1)
-  })
-})

package/src/server/claude-pty/preflight/binary-fingerprint.adapter.ts

@@ -1,20 +0,0 @@
-import { createHash } from "node:crypto"
-import { open } from "node:fs/promises"
-
-export async function computeBinarySha256(filePath: string): Promise<string> {
-  const fd = await open(filePath, "r")
-  try {
-    const hash = createHash("sha256")
-    const buf = Buffer.alloc(64 * 1024)
-    let pos = 0
-    while (true) {
-      const { bytesRead } = await fd.read(buf, 0, buf.length, pos)
-      if (bytesRead === 0) break
-      hash.update(buf.subarray(0, bytesRead))
-      pos += bytesRead
-    }
-    return hash.digest("hex")
-  } finally {
-    await fd.close()
-  }
-}

package/src/server/claude-pty/preflight/binary-fingerprint.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { computeBinarySha256 } from "./binary-fingerprint.adapter"
-import { mkdtemp, rm, writeFile } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import path from "node:path"
-
-describe("computeBinarySha256", () => {
-  test("returns 64-char hex sha256 of file contents", async () => {
-    const dir = await mkdtemp(path.join(tmpdir(), "kanna-binsha-"))
-    try {
-      const f = path.join(dir, "fake-claude")
-      await writeFile(f, "hello", "utf8")
-      const sha = await computeBinarySha256(f)
-      expect(sha).toMatch(/^[0-9a-f]{64}$/)
-    } finally { await rm(dir, { recursive: true, force: true }) }
-  })
-
-  test("identical content → identical sha", async () => {
-    const dir = await mkdtemp(path.join(tmpdir(), "kanna-binsha-"))
-    try {
-      const a = path.join(dir, "a")
-      const b = path.join(dir, "b")
-      await writeFile(a, "x", "utf8")
-      await writeFile(b, "x", "utf8")
-      expect(await computeBinarySha256(a)).toBe(await computeBinarySha256(b))
-    } finally { await rm(dir, { recursive: true, force: true }) }
-  })
-
-  test("throws when file does not exist", async () => {
-    await expect(computeBinarySha256("/nonexistent/path")).rejects.toThrow()
-  })
-})

package/src/server/claude-pty/pty-instance-registry.test.ts

@@ -1,208 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-  createPtyInstanceRegistry,
-  type PtyInstanceDelta,
-  type PtyInstanceState,
-} from "./pty-instance-registry"
-
-function baseline(overrides: Partial<PtyInstanceState> = {}): Omit<PtyInstanceState, "chatId"> {
-  return {
-    sessionId: null,
-    pid: null,
-    cwd: "/tmp",
-    model: "claude-opus-4-7",
-    accountLabel: null,
-    oauthMasked: null,
-    phase: "spawning",
-    startedAt: 1_000,
-    lastEventAt: 1_000,
-    turnCount: 0,
-    tokensIn: 0,
-    tokensOut: 0,
-    planMode: null,
-    smokeTest: null,
-    outputRingTail: null,
-    exitedAt: null,
-    exitCode: null,
-    rssBytes: null,
-    rssPeakBytes: null,
-    cpuPercent: null,
-    cpuPeakPercent: null,
-    ...overrides,
-  }
-}
-
-describe("PtyInstanceRegistry", () => {
-  test("upsert with new chatId fires added", () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 0 })
-    const events: PtyInstanceDelta[] = []
-    registry.subscribe((d) => events.push(d))
-    registry.upsert("c1", baseline())
-    expect(events).toHaveLength(1)
-    expect(events[0]).toMatchObject({ type: "added", instance: { chatId: "c1" } })
-  })
-
-  test("upsert with existing chatId fires updated and merges patch", () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 0 })
-    registry.upsert("c1", baseline())
-    const events: PtyInstanceDelta[] = []
-    registry.subscribe((d) => events.push(d))
-    registry.upsert("c1", { phase: "ready", pid: 42 })
-    expect(events).toHaveLength(1)
-    expect(events[0]).toMatchObject({
-      type: "updated",
-      instance: { chatId: "c1", phase: "ready", pid: 42, cwd: "/tmp" },
-    })
-  })
-
-  test("markExitedIfCurrent applies the patch when the live pid matches", () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 0 })
-    registry.upsert("c1", baseline({ pid: 41506, phase: "ready" }))
-    const events: PtyInstanceDelta[] = []
-    registry.subscribe((d) => events.push(d))
-    registry.markExitedIfCurrent("c1", 41506, { phase: "exited", exitedAt: 5_000 })
-    expect(events).toHaveLength(1)
-    expect(events[0]).toMatchObject({
-      type: "updated",
-      instance: { chatId: "c1", phase: "exited", exitedAt: 5_000 },
-    })
-  })
-
-  test("markExitedIfCurrent is a no-op when a newer pid owns the chat entry", () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 0 })
-    registry.upsert("c1", baseline({ pid: 41506, phase: "ready" }))
-    const events: PtyInstanceDelta[] = []
-    registry.subscribe((d) => events.push(d))
-    registry.markExitedIfCurrent("c1", 38830, { phase: "exited", exitedAt: 5_000 })
-    expect(events).toHaveLength(0)
-    expect(registry.snapshot()[0]).toMatchObject({ chatId: "c1", phase: "ready", pid: 41506 })
-  })
-
-  test("markExitedIfCurrent is a no-op when the chat has no entry", () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 0 })
-    const events: PtyInstanceDelta[] = []
-    registry.subscribe((d) => events.push(d))
-    registry.markExitedIfCurrent("missing", 1, { phase: "exited" })
-    expect(events).toHaveLength(0)
-  })
-
-  test("remove fires removed event and drops state", () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 0 })
-    registry.upsert("c1", baseline())
-    const events: PtyInstanceDelta[] = []
-    registry.subscribe((d) => events.push(d))
-    registry.remove("c1")
-    expect(events).toEqual([{ type: "removed", chatId: "c1" }])
-    expect(registry.snapshot()).toEqual([])
-  })
-
-  test("remove for unknown chatId is a no-op", () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 0 })
-    const events: PtyInstanceDelta[] = []
-    registry.subscribe((d) => events.push(d))
-    registry.remove("nope")
-    expect(events).toEqual([])
-  })
-
-  test("snapshot returns clones, not references", () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 0 })
-    registry.upsert("c1", baseline())
-    const a = registry.snapshot()
-    const b = registry.snapshot()
-    expect(a[0]).not.toBe(b[0])
-    a[0]!.phase = "exited"
-    expect(registry.snapshot()[0]!.phase).toBe("spawning")
-  })
-
-  test("unsubscribe stops further events", () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 0 })
-    const events: PtyInstanceDelta[] = []
-    const off = registry.subscribe((d) => events.push(d))
-    off()
-    registry.upsert("c1", baseline())
-    expect(events).toEqual([])
-  })
-
-  test("coalesce: rapid updates within window emit one trailing delta", async () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 30 })
-    registry.upsert("c1", baseline())
-    const events: PtyInstanceDelta[] = []
-    registry.subscribe((d) => events.push(d))
-    registry.upsert("c1", { tokensIn: 1 })
-    registry.upsert("c1", { tokensIn: 2 })
-    registry.upsert("c1", { tokensIn: 3 })
-    expect(events).toEqual([])
-    await new Promise((r) => setTimeout(r, 50))
-    expect(events).toHaveLength(1)
-    expect(events[0]).toMatchObject({ type: "updated", instance: { tokensIn: 3 } })
-  })
-
-  test("coalesce: added events are not delayed", () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 30 })
-    const events: PtyInstanceDelta[] = []
-    registry.subscribe((d) => events.push(d))
-    registry.upsert("c1", baseline())
-    expect(events).toHaveLength(1)
-    expect(events[0]!.type).toBe("added")
-  })
-
-  test("coalesce: removed flushes pending update for same chatId", async () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 30 })
-    registry.upsert("c1", baseline())
-    const events: PtyInstanceDelta[] = []
-    registry.subscribe((d) => events.push(d))
-    registry.upsert("c1", { phase: "streaming" })
-    registry.remove("c1")
-    await new Promise((r) => setTimeout(r, 50))
-    expect(events.map((e) => e.type)).toEqual(["removed"])
-  })
-
-  test("exitedTtlMs: entry auto-removed after TTL when phase becomes exited", async () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 0, exitedTtlMs: 30 })
-    registry.upsert("c1", baseline({ phase: "ready" }))
-    const events: PtyInstanceDelta[] = []
-    registry.subscribe((d) => events.push(d))
-    registry.upsert("c1", { phase: "exited", exitedAt: 2_000 })
-    expect(events.map((e) => e.type)).toEqual(["updated"])
-    expect(registry.snapshot()).toHaveLength(1)
-    await new Promise((r) => setTimeout(r, 60))
-    expect(events.map((e) => e.type)).toEqual(["updated", "removed"])
-    expect(registry.snapshot()).toEqual([])
-  })
-
-  test("exitedTtlMs: prune cancelled if phase moves away from exited before TTL", async () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 0, exitedTtlMs: 30 })
-    registry.upsert("c1", baseline({ phase: "exited", exitedAt: 1_000 }))
-    registry.upsert("c1", { phase: "ready", exitedAt: null })
-    await new Promise((r) => setTimeout(r, 60))
-    expect(registry.snapshot()).toHaveLength(1)
-    expect(registry.snapshot()[0]!.phase).toBe("ready")
-  })
-
-  test("exitedTtlMs: 0 disables auto-prune", async () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 0, exitedTtlMs: 0 })
-    registry.upsert("c1", baseline({ phase: "exited", exitedAt: 1_000 }))
-    await new Promise((r) => setTimeout(r, 30))
-    expect(registry.snapshot()).toHaveLength(1)
-  })
-
-  test("exitedTtlMs: manual remove cancels pending prune", async () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 0, exitedTtlMs: 30 })
-    registry.upsert("c1", baseline({ phase: "exited", exitedAt: 1_000 }))
-    const events: PtyInstanceDelta[] = []
-    registry.subscribe((d) => events.push(d))
-    registry.remove("c1")
-    await new Promise((r) => setTimeout(r, 60))
-    expect(events.map((e) => e.type)).toEqual(["removed"])
-  })
-
-  test("subscribe replay seeds listener with current state", () => {
-    const registry = createPtyInstanceRegistry({ coalesceMs: 0 })
-    registry.upsert("c1", baseline())
-    registry.upsert("c2", baseline({ phase: "ready" }))
-    const events: PtyInstanceDelta[] = []
-    registry.subscribe((d) => events.push(d), { replay: true })
-    expect(events).toHaveLength(2)
-    expect(events.every((e) => e.type === "added")).toBe(true)
-  })
-})

package/src/server/claude-pty/pty-instance-registry.ts

@@ -1,172 +0,0 @@
-import type { PtyInstanceDelta, PtyInstanceState } from "../../shared/pty-instance"
-
-export type { PtyInstanceDelta, PtyInstanceState }
-
-export type PtyInstanceListener = (delta: PtyInstanceDelta) => void
-
-export interface PtyInstanceSubscribeOptions {
-  replay?: boolean
-}
-
-export interface PtyInstanceRegistry {
-  snapshot(): PtyInstanceState[]
-  subscribe(listener: PtyInstanceListener, options?: PtyInstanceSubscribeOptions): () => void
-  upsert(chatId: string, patch: Partial<Omit<PtyInstanceState, "chatId">>): void
-  markExitedIfCurrent(
-    chatId: string,
-    pid: number,
-    patch: Partial<Omit<PtyInstanceState, "chatId">>,
-  ): void
-  remove(chatId: string): void
-}
-
-export interface CreatePtyInstanceRegistryOptions {
-  coalesceMs?: number
-  exitedTtlMs?: number
-}
-
-const DEFAULT_COALESCE_MS = 100
-const DEFAULT_EXITED_TTL_MS = 60_000
-
-export function createPtyInstanceRegistry(
-  options: CreatePtyInstanceRegistryOptions = {},
-): PtyInstanceRegistry {
-  const coalesceMs = options.coalesceMs ?? DEFAULT_COALESCE_MS
-  const exitedTtlMs = options.exitedTtlMs ?? DEFAULT_EXITED_TTL_MS
-  const states = new Map<string, PtyInstanceState>()
-  const listeners = new Set<PtyInstanceListener>()
-  const pendingFlushes = new Map<string, ReturnType<typeof setTimeout>>()
-  const exitedPrunes = new Map<string, ReturnType<typeof setTimeout>>()
-
-  function emit(delta: PtyInstanceDelta): void {
-    for (const listener of listeners) listener(delta)
-  }
-
-  function clone(state: PtyInstanceState): PtyInstanceState {
-    return { ...state }
-  }
-
-  function cancelPendingFlush(chatId: string): void {
-    const handle = pendingFlushes.get(chatId)
-    if (handle) {
-      clearTimeout(handle)
-      pendingFlushes.delete(chatId)
-    }
-  }
-
-  function cancelExitedPrune(chatId: string): void {
-    const handle = exitedPrunes.get(chatId)
-    if (handle) {
-      clearTimeout(handle)
-      exitedPrunes.delete(chatId)
-    }
-  }
-
-  function scheduleExitedPrune(chatId: string): void {
-    if (exitedTtlMs <= 0) return
-    cancelExitedPrune(chatId)
-    exitedPrunes.set(
-      chatId,
-      setTimeout(() => {
-        exitedPrunes.delete(chatId)
-        removeInternal(chatId)
-      }, exitedTtlMs),
-    )
-  }
-
-  function reconcileExitedTimer(chatId: string, phase: PtyInstanceState["phase"]): void {
-    if (phase === "exited") scheduleExitedPrune(chatId)
-    else cancelExitedPrune(chatId)
-  }
-
-  function flushUpdate(chatId: string): void {
-    pendingFlushes.delete(chatId)
-    const state = states.get(chatId)
-    if (!state) return
-    emit({ type: "updated", instance: clone(state) })
-  }
-
-  function removeInternal(chatId: string): void {
-    if (!states.has(chatId)) return
-    cancelPendingFlush(chatId)
-    cancelExitedPrune(chatId)
-    states.delete(chatId)
-    emit({ type: "removed", chatId })
-  }
-
-  return {
-    snapshot(): PtyInstanceState[] {
-      return Array.from(states.values(), clone)
-    },
-
-    subscribe(listener, opts): () => void {
-      listeners.add(listener)
-      if (opts?.replay) {
-        for (const state of states.values()) {
-          listener({ type: "added", instance: clone(state) })
-        }
-      }
-      return () => {
-        listeners.delete(listener)
-      }
-    },
-
-    upsert(chatId, patch): void {
-      const existing = states.get(chatId)
-      if (existing) {
-        const next: PtyInstanceState = { ...existing, ...patch, chatId }
-        states.set(chatId, next)
-        reconcileExitedTimer(chatId, next.phase)
-        if (coalesceMs <= 0) {
-          emit({ type: "updated", instance: clone(next) })
-          return
-        }
-        if (!pendingFlushes.has(chatId)) {
-          pendingFlushes.set(
-            chatId,
-            setTimeout(() => flushUpdate(chatId), coalesceMs),
-          )
-        }
-        return
-      }
-      const baseline: PtyInstanceState = {
-        chatId,
-        sessionId: null,
-        pid: null,
-        cwd: "",
-        model: "",
-        accountLabel: null,
-        oauthMasked: null,
-        phase: "spawning",
-        startedAt: 0,
-        lastEventAt: 0,
-        turnCount: 0,
-        tokensIn: 0,
-        tokensOut: 0,
-        planMode: null,
-        smokeTest: null,
-        outputRingTail: null,
-        exitedAt: null,
-        exitCode: null,
-        rssBytes: null,
-        rssPeakBytes: null,
-        cpuPercent: null,
-        cpuPeakPercent: null,
-        ...patch,
-      }
-      states.set(chatId, baseline)
-      reconcileExitedTimer(chatId, baseline.phase)
-      emit({ type: "added", instance: clone(baseline) })
-    },
-
-    markExitedIfCurrent(chatId, pid, patch): void {
-      const existing = states.get(chatId)
-      if (!existing || existing.pid !== pid) return
-      this.upsert(chatId, patch)
-    },
-
-    remove(chatId): void {
-      removeInternal(chatId)
-    },
-  }
-}