@cuongtran001/kanna 1.63.2 → 1.63.3

package/src/server/claude-pty/smoke-test.test.ts

@@ -1,199 +0,0 @@
-import { describe, expect, test, beforeEach, afterEach } from "bun:test"
-import { mkdtemp, rm, writeFile } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import path from "node:path"
-import { createSmokeTestGate, createFileSmokeTestCache, type SmokeTestProbeFn, type SmokeTestCache } from "./smoke-test"
-
-let workHome: string
-
-function inMemoryCache(): SmokeTestCache {
-  const store = new Map<string, { result: "pass" | "fail"; ts: number }>()
-  return {
-    async get(key) { return store.get(key) ?? null },
-    async set(key, entry) { store.set(key, entry) },
-    async invalidate() { store.clear() },
-  }
-}
-
-beforeEach(async () => {
-  workHome = await mkdtemp(path.join(tmpdir(), "kanna-smoke-"))
-  await writeFile(path.join(workHome, "fake-claude"), "#!/bin/sh\necho fake\n", { mode: 0o755 })
-})
-
-afterEach(async () => {
-  await rm(workHome, { recursive: true, force: true })
-})
-
-describe("createSmokeTestGate", () => {
-  test("cached PASS skips probe", async () => {
-    let probeRan = false
-    const probe: SmokeTestProbeFn = async () => { probeRan = true; return "pass" }
-    const cache = inMemoryCache()
-    await cache.set("aaa|claude-opus-4-7", { result: "pass", ts: Date.now() })
-    const gate = createSmokeTestGate({ probe, cache, ttlMs: 24 * 3600 * 1000, now: () => Date.now() })
-    const result = await gate.canSpawn({ binarySha256: "aaa", model: "claude-opus-4-7" })
-    expect(result.ok).toBe(true)
-    expect(probeRan).toBe(false)
-  })
-
-  test("a cached result for one endpoint is not reused for another", async () => {
-    let probeRan = 0
-    const probe: SmokeTestProbeFn = async () => { probeRan += 1; return "pass" }
-    const cache = inMemoryCache()
-    const gate = createSmokeTestGate({ probe, cache, ttlMs: 24 * 3600 * 1000, now: () => Date.now() })
-
-    await gate.canSpawn({ binarySha256: "aaa", model: "m1" })
-    expect(probeRan).toBe(1)
-
-    await gate.canSpawn({ binarySha256: "aaa", model: "m1", baseUrl: "https://proxy.example" })
-    expect(probeRan).toBe(2)
-
-    await gate.canSpawn({ binarySha256: "aaa", model: "m1", baseUrl: "https://proxy.example" })
-    expect(probeRan).toBe(2)
-  })
-
-  test("an absent endpoint keeps the legacy cache key, so existing entries still hit", async () => {
-    let probeRan = false
-    const probe: SmokeTestProbeFn = async () => { probeRan = true; return "pass" }
-    const cache = inMemoryCache()
-    await cache.set("ccc|m1", { result: "pass", ts: Date.now() })
-    const gate = createSmokeTestGate({ probe, cache, ttlMs: 24 * 3600 * 1000, now: () => Date.now() })
-
-    expect((await gate.canSpawn({ binarySha256: "ccc", model: "m1" })).ok).toBe(true)
-    expect((await gate.canSpawn({ binarySha256: "ccc", model: "m1", baseUrl: null })).ok).toBe(true)
-    expect(probeRan).toBe(false)
-  })
-
-  test("cached FAIL refuses spawn without running probe", async () => {
-    let probeRan = false
-    const probe: SmokeTestProbeFn = async () => { probeRan = true; return "pass" }
-    const cache = inMemoryCache()
-    await cache.set("bbb|claude-opus-4-7", { result: "fail", ts: Date.now() })
-    const gate = createSmokeTestGate({ probe, cache, ttlMs: 24 * 3600 * 1000, now: () => Date.now() })
-    const result = await gate.canSpawn({ binarySha256: "bbb", model: "claude-opus-4-7" })
-    expect(result.ok).toBe(false)
-    if (!result.ok) expect(result.reason).toMatch(/disallowedTools/i)
-    expect(probeRan).toBe(false)
-  })
-
-  test("cache miss runs probe and caches PASS", async () => {
-    let probeRan = false
-    const probe: SmokeTestProbeFn = async () => { probeRan = true; return "pass" }
-    const cache = inMemoryCache()
-    const gate = createSmokeTestGate({ probe, cache, ttlMs: 24 * 3600 * 1000, now: () => Date.now() })
-    const result = await gate.canSpawn({ binarySha256: "ccc", model: "m1" })
-    expect(result.ok).toBe(true)
-    expect(probeRan).toBe(true)
-    const cached = await cache.get("ccc|m1")
-    expect(cached?.result).toBe("pass")
-  })
-
-  test("cache miss runs probe and refuses spawn on FAIL", async () => {
-    const probe: SmokeTestProbeFn = async () => "fail"
-    const cache = inMemoryCache()
-    const gate = createSmokeTestGate({ probe, cache, ttlMs: 24 * 3600 * 1000, now: () => Date.now() })
-    const result = await gate.canSpawn({ binarySha256: "ddd", model: "m1" })
-    expect(result.ok).toBe(false)
-    const cached = await cache.get("ddd|m1")
-    expect(cached?.result).toBe("fail")
-  })
-
-  test("expired cache entry triggers re-probe", async () => {
-    let probeRan = 0
-    const probe: SmokeTestProbeFn = async () => { probeRan++; return "pass" }
-    const cache = inMemoryCache()
-    let nowMs = 1_000_000
-    await cache.set("eee|m1", { result: "pass", ts: nowMs })
-    const gate = createSmokeTestGate({ probe, cache, ttlMs: 1000, now: () => nowMs })
-    await gate.canSpawn({ binarySha256: "eee", model: "m1" })
-    expect(probeRan).toBe(0)
-    nowMs += 2000
-    await gate.canSpawn({ binarySha256: "eee", model: "m1" })
-    expect(probeRan).toBe(1)
-  })
-})
-
-describe("createSmokeTestGate singleflight (adr-20260522-oauth-token-share-cap)", () => {
-  test("concurrent canSpawn calls on same (sha,model) collapse to one probe", async () => {
-    let probeStartCount = 0
-    const resolvers: Array<(r: "pass" | "fail") => void> = []
-    const probe: SmokeTestProbeFn = () => {
-      probeStartCount += 1
-      return new Promise<"pass" | "fail">((r) => { resolvers.push(r) })
-    }
-    const cache = inMemoryCache()
-    const gate = createSmokeTestGate({ probe, cache, ttlMs: 24 * 3600 * 1000, now: () => Date.now() })
-
-    const results = [
-      gate.canSpawn({ binarySha256: "fff", model: "m1" }),
-      gate.canSpawn({ binarySha256: "fff", model: "m1" }),
-      gate.canSpawn({ binarySha256: "fff", model: "m1" }),
-      gate.canSpawn({ binarySha256: "fff", model: "m1" }),
-      gate.canSpawn({ binarySha256: "fff", model: "m1" }),
-    ]
-    await Promise.resolve()
-    expect(probeStartCount).toBe(1)
-    expect(resolvers).toHaveLength(1)
-    resolvers[0]("pass")
-    const resolved = await Promise.all(results)
-    for (const r of resolved) expect(r.ok).toBe(true)
-    expect(probeStartCount).toBe(1)
-  })
-
-  test("after a probe resolves, future cache-miss callers run a fresh probe", async () => {
-    let probeStartCount = 0
-    const probe: SmokeTestProbeFn = async () => { probeStartCount += 1; return "pass" }
-    const cache: SmokeTestCache = {
-      async get() { return null },
-      async set() { },
-      async invalidate() { },
-    }
-    const gate = createSmokeTestGate({ probe, cache, ttlMs: 24 * 3600 * 1000, now: () => Date.now() })
-    await gate.canSpawn({ binarySha256: "ggg", model: "m1" })
-    await gate.canSpawn({ binarySha256: "ggg", model: "m1" })
-    expect(probeStartCount).toBe(2)
-  })
-
-  test("singleflight is keyed by (sha,model) — different keys probe independently", async () => {
-    let probeStartCount = 0
-    const resolvers: Array<(r: "pass" | "fail") => void> = []
-    const probe: SmokeTestProbeFn = () => {
-      probeStartCount += 1
-      return new Promise<"pass" | "fail">((r) => { resolvers.push(r) })
-    }
-    const cache = inMemoryCache()
-    const gate = createSmokeTestGate({ probe, cache, ttlMs: 24 * 3600 * 1000, now: () => Date.now() })
-    const a = gate.canSpawn({ binarySha256: "hhh", model: "m1" })
-    const b = gate.canSpawn({ binarySha256: "hhh", model: "m2" })
-    await Promise.resolve()
-    expect(probeStartCount).toBe(2)
-    expect(resolvers).toHaveLength(2)
-    resolvers[0]("pass")
-    resolvers[1]("pass")
-    await Promise.all([a, b])
-  })
-})
-
-describe("createFileSmokeTestCache", () => {
-  test("round-trips an entry through disk", async () => {
-    const dir = path.join(workHome, "smoke-cache")
-    const cache = createFileSmokeTestCache({ cacheDir: dir })
-    await cache.set("abc|m1", { result: "pass", ts: 1234 })
-    const got = await cache.get("abc|m1")
-    expect(got).toEqual({ result: "pass", ts: 1234 })
-  })
-
-  test("returns null on missing key", async () => {
-    const cache = createFileSmokeTestCache({ cacheDir: path.join(workHome, "smoke-cache-2") })
-    const got = await cache.get("missing|m1")
-    expect(got).toBeNull()
-  })
-
-  test("invalidate wipes the dir", async () => {
-    const dir = path.join(workHome, "smoke-cache-3")
-    const cache = createFileSmokeTestCache({ cacheDir: dir })
-    await cache.set("xxx|m", { result: "pass", ts: 1 })
-    await cache.invalidate()
-    expect(await cache.get("xxx|m")).toBeNull()
-  })
-})

package/src/server/claude-pty/smoke-test.ts

@@ -1,182 +0,0 @@
-import path from "node:path"
-import {
-  fileExists,
-  makeTempCwd,
-  mkdirRecursive,
-  readTextFile,
-  rmDirRecursive,
-  writeFile0600,
-} from "./smoke-test-io.adapter"
-import { isRecord } from "../../shared/errors"
-import { buildPtyEnv } from "./env"
-import { OutputRing } from "./output-ring"
-import { spawnPtyProcess as defaultSpawnPtyProcess } from "./pty-process.adapter"
-import { waitForTuiReadyWithTrustDismiss, sendUserPrompt, sendExitCommand } from "./tui-control"
-import { startTranscriptStream, waitForResultEntry } from "./tui-source.adapter"
-import { computeProjectDir } from "./jsonl-path.adapter"
-import { log } from "../../shared/log"
-
-export type SmokeTestProbeFn = () => Promise<"pass" | "fail">
-
-export interface SmokeTestCacheEntry {
-  result: "pass" | "fail"
-  ts: number
-}
-
-export interface SmokeTestCache {
-  get(key: string): Promise<SmokeTestCacheEntry | null>
-  set(key: string, entry: SmokeTestCacheEntry): Promise<void>
-  invalidate(): Promise<void>
-}
-
-export interface SmokeTestGateArgs {
-  probe: SmokeTestProbeFn
-  cache: SmokeTestCache
-  ttlMs: number
-  now: () => number
-}
-
-export interface CanSpawnArgs {
-  binarySha256: string
-  model: string
-  baseUrl?: string | null
-}
-
-export interface SmokeTestGate {
-  canSpawn(args: CanSpawnArgs): Promise<{ ok: true } | { ok: false; reason: string }>
-}
-
-export function createSmokeTestGate(args: SmokeTestGateArgs): SmokeTestGate {
-  const { probe, cache, ttlMs, now } = args
-  const inFlight = new Map<string, Promise<{ ok: true } | { ok: false; reason: string }>>()
-  return {
-    async canSpawn(spawnArgs: CanSpawnArgs) {
-      const key = spawnArgs.baseUrl
-        ? `${spawnArgs.binarySha256}|${spawnArgs.model}|${spawnArgs.baseUrl}`
-        : `${spawnArgs.binarySha256}|${spawnArgs.model}`
-      const cached = await cache.get(key)
-      const currentTs = now()
-      if (cached && currentTs - cached.ts < ttlMs) {
-        if (cached.result === "pass") return { ok: true }
-        return { ok: false, reason: "cached smoke test FAIL: --disallowedTools not enforced for this claude binary + model" }
-      }
-      const existing = inFlight.get(key)
-      if (existing) return existing
-      const run = (async () => {
-        const probeResult = await probe()
-        await cache.set(key, { result: probeResult, ts: now() })
-        if (probeResult === "pass") return { ok: true } as const
-        return { ok: false, reason: "smoke test FAIL: claude invoked a disallowedTool — refusing spawn" } as const
-      })()
-      inFlight.set(key, run)
-      try {
-        return await run
-      } finally {
-        inFlight.delete(key)
-      }
-    },
-  }
-}
-
-export interface BuildLiveSmokeProbeArgs {
-  claudeBinPath: string
-  model: string
-  oauthToken: string
-  homeDir: string
-  baseUrl?: string | null
-  spawnPtyProcess?: typeof defaultSpawnPtyProcess
-}
-
-export function buildLiveSmokeProbe(args: BuildLiveSmokeProbeArgs): SmokeTestProbeFn {
-  const spawnPty = args.spawnPtyProcess ?? defaultSpawnPtyProcess
-  return async () => {
-    const tmpCwd = await makeTempCwd("kanna-smoke-cwd-")
-    const ring = new OutputRing()
-    const cliArgs = [
-      "--model", args.model,
-      "--permission-mode", "acceptEdits",
-      "--dangerously-skip-permissions",
-      "--disallowedTools", "Bash",
-    ]
-    const spawnEnv = buildPtyEnv({
-      baseEnv: process.env,
-      homeDir: args.homeDir,
-      oauthToken: args.oauthToken,
-      baseUrl: args.baseUrl,
-    })
-    const pty = await spawnPty({
-      command: args.claudeBinPath,
-      args: cliArgs,
-      cwd: tmpCwd,
-      env: spawnEnv,
-      onOutput: (chunk) => ring.append(chunk),
-    })
-    let probeResult: "pass" | "fail" = "pass"
-    try {
-      await waitForTuiReadyWithTrustDismiss(pty, ring, { hardCapMs: 15_000 })
-      const projectDir = computeProjectDir({ homeDir: args.homeDir, cwd: tmpCwd })
-      const stream = await startTranscriptStream({ projectDir, firstFileTimeoutMs: 20_000 })
-      try {
-        await sendUserPrompt(
-          pty,
-          ring,
-          "Use the Bash tool to run: ls /tmp. If the Bash tool is not available, reply with exactly BASH_UNAVAILABLE and end your turn. Do not use any other tool and do not look for alternatives.",
-        )
-        const filePath = await stream.filePath
-        await waitForResultEntry(stream, { timeoutMs: 30_000 })
-        const raw = await readTextFile(filePath)
-        for (const line of raw.split("\n")) {
-          if (!line.trim()) continue
-          let parsed: { message?: { content?: Array<{ type?: string; name?: string }> } }
-          try { parsed = JSON.parse(line) } catch { continue }
-          const blocks = parsed.message?.content
-          if (!Array.isArray(blocks)) continue
-          for (const b of blocks) {
-            if (b?.type === "tool_use" && b.name === "Bash") {
-              probeResult = "fail"
-            }
-          }
-        }
-      } finally {
-        stream.close()
-      }
-    } catch (err) {
-      const errWithCode: { code?: string } = isRecord(err) ? err : {}
-      if (err instanceof Error && errWithCode.code === "rate_limited") throw err
-      log.warn("[kanna/pty] smoke probe errored, treating as FAIL", String(err))
-      probeResult = "fail"
-    } finally {
-      try { await sendExitCommand(pty) } catch { }
-      try { pty.close() } catch { }
-      try { await rmDirRecursive(tmpCwd) } catch { }
-    }
-    return probeResult
-  }
-}
-
-export function createFileSmokeTestCache(args: { cacheDir: string }): SmokeTestCache {
-  const dir = args.cacheDir
-  const fileFor = (key: string) => path.join(dir, `${key.replace(/[^a-z0-9._-]/gi, "_")}.json`)
-  return {
-    async get(key) {
-      const fp = fileFor(key)
-      if (!fileExists(fp)) return null
-      try {
-        const raw = await readTextFile(fp)
-        const parsed: SmokeTestCacheEntry = JSON.parse(raw)
-        if (parsed.result !== "pass" && parsed.result !== "fail") return null
-        if (typeof parsed.ts !== "number") return null
-        return parsed
-      } catch {
-        return null
-      }
-    },
-    async set(key, entry) {
-      await mkdirRecursive(dir)
-      await writeFile0600(fileFor(key), JSON.stringify(entry))
-    },
-    async invalidate() {
-      try { await rmDirRecursive(dir) } catch { }
-    },
-  }
-}

package/src/server/claude-pty/tui-control.test.ts

@@ -1,300 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-  sendUserPrompt,
-  sendExitCommand,
-  dismissTrustDialogIfPresent,
-  dismissDevChannelsDialogIfPresent,
-  waitForTuiReady,
-  waitForTuiReadyWithTrustDismiss,
-  waitForTuiReadyDismissingDialogs,
-  TRUST_DIALOG_MARKER,
-  TUI_READY_MARKER,
-  DEV_CHANNELS_DIALOG_MARKER,
-} from "./tui-control"
-import { OutputRing } from "./output-ring"
-import type { PtyProcess } from "./pty-process.adapter"
-
-function fakePty(): PtyProcess & { sent: string[] } {
-  const sent: string[] = []
-  return {
-    sent,
-    pid: 99997,
-    async sendInput(data: string) { sent.push(data) },
-    resize() { },
-    exited: new Promise<number>(() => { }),
-    close() { },
-    kill() { },
-  } as PtyProcess & { sent: string[] }
-}
-
-describe("sendUserPrompt", () => {
-  test("writes bracketed-paste wrapped text then separate carriage return once ring grows", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    setTimeout(() => ring.append("[Pasted text #1 +56 lines]"), 5)
-    await sendUserPrompt(pty, ring, "say hi", { commitTimeoutMs: 500, pollMs: 1 })
-    expect(pty.sent).toEqual(["\x1b[200~say hi\x1b[201~", "\r"])
-  })
-
-  test("empty string still emits paste markers + carriage return after commit", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    setTimeout(() => ring.append("x"), 5)
-    await sendUserPrompt(pty, ring, "", { commitTimeoutMs: 500, pollMs: 1 })
-    expect(pty.sent).toEqual(["\x1b[200~\x1b[201~", "\r"])
-  })
-
-  test("sends Enter after commitTimeoutMs even if the ring never grows (degraded fallback)", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    const start = Date.now()
-    await sendUserPrompt(pty, ring, "no echo", { commitTimeoutMs: 50, pollMs: 5 })
-    const elapsed = Date.now() - start
-    expect(pty.sent).toEqual(["\x1b[200~no echo\x1b[201~", "\r"])
-    expect(elapsed).toBeGreaterThanOrEqual(45)
-  })
-})
-
-describe("sendExitCommand", () => {
-  test("writes /exit + carriage return", async () => {
-    const pty = fakePty()
-    await sendExitCommand(pty)
-    expect(pty.sent).toEqual(["/exit\r"])
-  })
-})
-
-describe("dismissTrustDialogIfPresent", () => {
-  test("sends carriage return when ringbuf contains trust marker", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    ring.append("Quick safety check: Do you trust this folder? trust this folder")
-    const dismissed = await dismissTrustDialogIfPresent(pty, ring)
-    expect(dismissed).toBe(true)
-    expect(pty.sent).toEqual(["\r"])
-  })
-
-  test("does nothing when ringbuf lacks trust marker", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    ring.append("Welcome back c!")
-    const dismissed = await dismissTrustDialogIfPresent(pty, ring)
-    expect(dismissed).toBe(false)
-    expect(pty.sent).toEqual([])
-  })
-
-  test("exported TRUST_DIALOG_MARKER is the substring matched", () => {
-    expect(TRUST_DIALOG_MARKER).toBe("trust this folder")
-  })
-})
-
-describe("waitForTuiReady", () => {
-  test("returns 'marker' when ringbuf already contains the input-box marker", async () => {
-    const ring = new OutputRing()
-    ring.append("❯ ")
-    const result = await waitForTuiReady(ring, { hardCapMs: 1000, pollMs: 10, quietPeriodMs: 0 })
-    expect(result).toBe("marker")
-  })
-
-  test("returns 'timeout' when no marker appears within hardCapMs", async () => {
-    const ring = new OutputRing()
-    const result = await waitForTuiReady(ring, { hardCapMs: 200, pollMs: 10, quietPeriodMs: 0 })
-    expect(result).toBe("timeout")
-  })
-
-  test("polls until marker appears", async () => {
-    const ring = new OutputRing()
-    setTimeout(() => ring.append("❯ "), 50)
-    const start = Date.now()
-    const result = await waitForTuiReady(ring, { hardCapMs: 1000, pollMs: 10, quietPeriodMs: 0 })
-    const elapsed = Date.now() - start
-    expect(result).toBe("marker")
-    expect(elapsed).toBeLessThan(300)
-  })
-
-  test("waits for ring to stay quiet for quietPeriodMs after marker hit", async () => {
-    const ring = new OutputRing()
-    ring.append("splash banner ❯ ")
-    const interval = setInterval(() => ring.append("."), 30)
-    setTimeout(() => clearInterval(interval), 200)
-    const start = Date.now()
-    const result = await waitForTuiReady(ring, { hardCapMs: 2000, pollMs: 10, quietPeriodMs: 150 })
-    const elapsed = Date.now() - start
-    expect(result).toBe("marker")
-    expect(elapsed).toBeGreaterThanOrEqual(300)
-  })
-
-  test("resolves immediately when ring stays quiet from the start", async () => {
-    const ring = new OutputRing()
-    ring.append("❯ ")
-    const start = Date.now()
-    const result = await waitForTuiReady(ring, { hardCapMs: 2000, pollMs: 10, quietPeriodMs: 80 })
-    const elapsed = Date.now() - start
-    expect(result).toBe("marker")
-    expect(elapsed).toBeGreaterThanOrEqual(70)
-    expect(elapsed).toBeLessThan(250)
-  })
-
-  test("exported TUI_READY_MARKER is the input-box prompt", () => {
-    expect(TUI_READY_MARKER).toBe("❯ ")
-  })
-
-  test("returns 'marker' when TUI renders ❯ with \\x1b[1C instead of space", async () => {
-    const ring = new OutputRing()
-    ring.append("❯\x1b[1C")
-    const result = await waitForTuiReady(ring, { hardCapMs: 1000, pollMs: 10 })
-    expect(result).toBe("marker")
-  })
-
-  test("returns 'marker' when TUI renders ❯ followed by U+00A0 (non-breaking space)", async () => {
-    const ring = new OutputRing()
-    ring.append("❯ ")
-    const result = await waitForTuiReady(ring, { hardCapMs: 1000, pollMs: 10 })
-    expect(result).toBe("marker")
-  })
-})
-
-describe("dismissTrustDialogIfPresent (ANSI-encoded ring)", () => {
-  test("detects trust dialog when words separated by \\x1b[1C (TUI rendering)", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    ring.append("\x1b[1C❯\x1b[1C1.\x1b[1CYes,\x1b[1CI\x1b[1Ctrust\x1b[1Cthis\x1b[1Cfolder\r\n")
-    const dismissed = await dismissTrustDialogIfPresent(pty, ring)
-    expect(dismissed).toBe(true)
-    expect(pty.sent).toEqual(["\r"])
-  })
-
-  test("does not false-trigger on plain text without trust marker", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    ring.append("\x1b[1CWelcome\x1b[1Cback!\x1b[0m❯ ")
-    const dismissed = await dismissTrustDialogIfPresent(pty, ring)
-    expect(dismissed).toBe(false)
-    expect(pty.sent).toEqual([])
-  })
-})
-
-describe("waitForTuiReadyWithTrustDismiss", () => {
-  test("returns 'ready' immediately when input box already present", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    ring.append("❯ ")
-    const result = await waitForTuiReadyWithTrustDismiss(pty, ring, { hardCapMs: 500, pollMs: 10 })
-    expect(result).toBe("ready")
-    expect(pty.sent).toEqual([])
-  })
-
-  test("dismisses ANSI trust dialog then resolves when input box appears", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    ring.append("\x1b[1Ctrust\x1b[1Cthis\x1b[1Cfolder")
-    setTimeout(() => ring.append("❯ "), 80)
-    const result = await waitForTuiReadyWithTrustDismiss(pty, ring, { hardCapMs: 1000, pollMs: 10 })
-    expect(result).toBe("ready")
-    expect(pty.sent).toContain("\r")
-  })
-
-  test("returns 'timeout' when neither marker appears", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    const result = await waitForTuiReadyWithTrustDismiss(pty, ring, { hardCapMs: 150, pollMs: 10 })
-    expect(result).toBe("timeout")
-    expect(pty.sent).toEqual([])
-  })
-
-  test("returns 'ready' when TUI renders ❯ with \\x1b[1C (ANSI cursor-forward)", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    ring.append("❯\x1b[1C")
-    const result = await waitForTuiReadyWithTrustDismiss(pty, ring, { hardCapMs: 500, pollMs: 10 })
-    expect(result).toBe("ready")
-    expect(pty.sent).toEqual([])
-  })
-
-  test("does not false-trigger on trust dialog's own ❯ selection cursor", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    ring.append("\x1b[1C❯\x1b[1C1.\x1b[1CYes,\x1b[1CI\x1b[1Ctrust\x1b[1Cthis\x1b[1Cfolder\r\n")
-    setTimeout(() => ring.append("❯\x1b[1C"), 80)
-    const result = await waitForTuiReadyWithTrustDismiss(pty, ring, { hardCapMs: 1000, pollMs: 10 })
-    expect(result).toBe("ready")
-    expect(pty.sent).toContain("\r")
-  })
-
-describe("dismissDevChannelsDialogIfPresent", () => {
-  test("sends carriage return when ring contains the dev-channels marker", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    ring.append("WARNING: Loading development channels ... for local channel development only")
-    const dismissed = await dismissDevChannelsDialogIfPresent(pty, ring)
-    expect(dismissed).toBe(true)
-    expect(pty.sent).toEqual(["\r"])
-  })
-  test("does nothing when the marker is absent", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    ring.append("some unrelated output")
-    const dismissed = await dismissDevChannelsDialogIfPresent(pty, ring)
-    expect(dismissed).toBe(false)
-    expect(pty.sent).toEqual([])
-  })
-  test("DEV_CHANNELS_DIALOG_MARKER is the substring matched", () => {
-    expect("for local channel development only").toContain(DEV_CHANNELS_DIALOG_MARKER)
-  })
-})
-
-  test("dismisses trust dialog only once even if marker persists in ring", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    ring.append("\x1b[1Ctrust\x1b[1Cthis\x1b[1Cfolder")
-    setTimeout(() => ring.append("❯ "), 80)
-    await waitForTuiReadyWithTrustDismiss(pty, ring, { hardCapMs: 1000, pollMs: 10 })
-    expect(pty.sent.filter((s) => s === "\r")).toHaveLength(1)
-  })
-
-  test("waits for ring to stay quiet for quietPeriodMs after post-dismiss marker hit", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    ring.append("\x1b[1Ctrust\x1b[1Cthis\x1b[1Cfolder")
-    setTimeout(() => ring.append("❯ "), 50)
-    const interval = setInterval(() => ring.append("."), 30)
-    setTimeout(() => clearInterval(interval), 250)
-    const start = Date.now()
-    const result = await waitForTuiReadyWithTrustDismiss(pty, ring, {
-      hardCapMs: 2000,
-      pollMs: 10,
-      quietPeriodMs: 150,
-    })
-    const elapsed = Date.now() - start
-    expect(result).toBe("ready")
-    expect(elapsed).toBeGreaterThanOrEqual(350)
-  })
-})
-
-describe("waitForTuiReadyDismissingDialogs", () => {
-  test("dismisses trust + dev dialogs, returns 'marker' once ❯ is clean", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    ring.append("Is this a project you trust this folder?")
-    setTimeout(() => ring.append(" for local channel development only ❯ 1. I am using this for local development"), 5)
-    setTimeout(() => ring.append("\n❯ "), 25)
-    const res = await waitForTuiReadyDismissingDialogs(pty, ring, { hardCapMs: 1000, pollMs: 2 })
-    expect(res).toBe("marker")
-    expect(pty.sent.filter((s) => s === "\r").length).toBeGreaterThanOrEqual(2)
-  })
-  test("returns 'timeout' if the input box never becomes clean", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    const res = await waitForTuiReadyDismissingDialogs(pty, ring, { hardCapMs: 60, pollMs: 5 })
-    expect(res).toBe("timeout")
-  })
-  test("does not return ready on the trust dialog's leftover ❯ before the dev dialog appears", async () => {
-    const pty = fakePty()
-    const ring = new OutputRing()
-    ring.append("Is this a project you trust this folder? ❯ 1. Yes, I trust this folder")
-    setTimeout(() => ring.append(" WARNING for local channel development only ❯ 1. I am using this for local development"), 15)
-    setTimeout(() => ring.append("\n❯ "), 40)
-    const res = await waitForTuiReadyDismissingDialogs(pty, ring, { hardCapMs: 2000, pollMs: 2 })
-    expect(res).toBe("marker")
-    expect(pty.sent.filter((s) => s === "\r").length).toBe(2)
-  })
-})