@cuongtran001/kanna 1.63.2 → 1.63.3

package/src/server/app-settings.ts

@@ -25,16 +25,15 @@ import {
   AUTH_SESSION_MAX_AGE_DAYS_MIN,
   CLAUDE_AUTH_DEFAULTS,
   CLAUDE_DRIVER_DEFAULTS,
-  CLAUDE_PTY_IDLE_TIMEOUT_MS_MAX,
-  CLAUDE_PTY_IDLE_TIMEOUT_MS_MIN,
-  CLAUDE_PTY_LIFECYCLE_DEFAULTS,
-  CLAUDE_PTY_MAX_CONCURRENT_MAX,
-  CLAUDE_PTY_MAX_CONCURRENT_MIN,
+  CLAUDE_IDLE_TIMEOUT_MS_MAX,
+  CLAUDE_IDLE_TIMEOUT_MS_MIN,
+  CLAUDE_LIFECYCLE_DEFAULTS,
+  CLAUDE_MAX_CONCURRENT_MAX,
+  CLAUDE_MAX_CONCURRENT_MIN,
   DEFAULT_CLAUDE_MODEL_OPTIONS,
   DEFAULT_CODEX_MODEL_OPTIONS,
   DEFAULT_OPENROUTER_SDK_MODEL,
   GLOBAL_PROMPT_APPEND_MAX_CHARS,
-  isClaudeDriverPreference,
   isClaudeReasoningEffort,
   isCodexReasoningEffort,
   normalizeClaudeContextWindow,
@@ -60,10 +59,9 @@ import {
   type ChatSoundId,
   type ChatSoundPreference,
   type ClaudeAuthSettings,
-  type ClaudeDriverPreference,
   type ClaudeDriverSettings,
   type ClaudeModelOptions,
-  type ClaudePtyLifecycleSettings,
+  type ClaudeLifecycleSettings,
   type CloudflareTunnelSettings,
   type CodexModelOptions,
   type OpenRouterModelOptions,
@@ -729,35 +727,35 @@ function normalizeTokenEntry<T>(value: T, warnings: string[]): OAuthTokenEntry |
   }
 }
 
-function normalizeClaudePtyLifecycle<T>(value: T, warnings: string[]): ClaudePtyLifecycleSettings {
+function normalizeClaudeLifecycle<T>(value: T, warnings: string[]): ClaudeLifecycleSettings {
   const source = isPlainObject(value) ? value : null
   if (value !== undefined && !source) {
     warnings.push("claudeDriver.lifecycle must be an object")
   }
   const idleRaw = source?.idleTimeoutMs
-  let idleTimeoutMs = CLAUDE_PTY_LIFECYCLE_DEFAULTS.idleTimeoutMs
+  let idleTimeoutMs = CLAUDE_LIFECYCLE_DEFAULTS.idleTimeoutMs
   if (idleRaw !== undefined) {
     if (typeof idleRaw !== "number" || !Number.isFinite(idleRaw)) {
       warnings.push("claudeDriver.lifecycle.idleTimeoutMs must be a number")
-    } else if (idleRaw < CLAUDE_PTY_IDLE_TIMEOUT_MS_MIN || idleRaw > CLAUDE_PTY_IDLE_TIMEOUT_MS_MAX) {
+    } else if (idleRaw < CLAUDE_IDLE_TIMEOUT_MS_MIN || idleRaw > CLAUDE_IDLE_TIMEOUT_MS_MAX) {
       warnings.push(
-        `claudeDriver.lifecycle.idleTimeoutMs must be between ${CLAUDE_PTY_IDLE_TIMEOUT_MS_MIN} and ${CLAUDE_PTY_IDLE_TIMEOUT_MS_MAX}`,
+        `claudeDriver.lifecycle.idleTimeoutMs must be between ${CLAUDE_IDLE_TIMEOUT_MS_MIN} and ${CLAUDE_IDLE_TIMEOUT_MS_MAX}`,
       )
-      idleTimeoutMs = clampNumber(idleRaw, CLAUDE_PTY_LIFECYCLE_DEFAULTS.idleTimeoutMs, CLAUDE_PTY_IDLE_TIMEOUT_MS_MIN, CLAUDE_PTY_IDLE_TIMEOUT_MS_MAX)
+      idleTimeoutMs = clampNumber(idleRaw, CLAUDE_LIFECYCLE_DEFAULTS.idleTimeoutMs, CLAUDE_IDLE_TIMEOUT_MS_MIN, CLAUDE_IDLE_TIMEOUT_MS_MAX)
     } else {
       idleTimeoutMs = Math.round(idleRaw)
     }
   }
   const maxRaw = source?.maxConcurrent
-  let maxConcurrent = CLAUDE_PTY_LIFECYCLE_DEFAULTS.maxConcurrent
+  let maxConcurrent = CLAUDE_LIFECYCLE_DEFAULTS.maxConcurrent
   if (maxRaw !== undefined) {
     if (typeof maxRaw !== "number" || !Number.isFinite(maxRaw)) {
       warnings.push("claudeDriver.lifecycle.maxConcurrent must be a number")
-    } else if (maxRaw < CLAUDE_PTY_MAX_CONCURRENT_MIN || maxRaw > CLAUDE_PTY_MAX_CONCURRENT_MAX) {
+    } else if (maxRaw < CLAUDE_MAX_CONCURRENT_MIN || maxRaw > CLAUDE_MAX_CONCURRENT_MAX) {
       warnings.push(
-        `claudeDriver.lifecycle.maxConcurrent must be between ${CLAUDE_PTY_MAX_CONCURRENT_MIN} and ${CLAUDE_PTY_MAX_CONCURRENT_MAX}`,
+        `claudeDriver.lifecycle.maxConcurrent must be between ${CLAUDE_MAX_CONCURRENT_MIN} and ${CLAUDE_MAX_CONCURRENT_MAX}`,
       )
-      maxConcurrent = clampNumber(maxRaw, CLAUDE_PTY_LIFECYCLE_DEFAULTS.maxConcurrent, CLAUDE_PTY_MAX_CONCURRENT_MIN, CLAUDE_PTY_MAX_CONCURRENT_MAX)
+      maxConcurrent = clampNumber(maxRaw, CLAUDE_LIFECYCLE_DEFAULTS.maxConcurrent, CLAUDE_MAX_CONCURRENT_MIN, CLAUDE_MAX_CONCURRENT_MAX)
     } else {
       maxConcurrent = Math.round(maxRaw)
     }
@@ -771,18 +769,10 @@ function normalizeClaudeDriverSettings<T>(value: T, warnings: string[]): ClaudeD
     warnings.push("claudeDriver must be an object")
     return {
       ...CLAUDE_DRIVER_DEFAULTS,
-      lifecycle: { ...CLAUDE_PTY_LIFECYCLE_DEFAULTS },
+      lifecycle: { ...CLAUDE_LIFECYCLE_DEFAULTS },
     }
   }
-  const rawPref = typeof source?.preference === "string" ? source.preference : undefined
-  const preference: ClaudeDriverPreference = isClaudeDriverPreference(rawPref)
-    ? rawPref
-    : CLAUDE_DRIVER_DEFAULTS.preference
-  if (source?.preference !== undefined && !isClaudeDriverPreference(rawPref)) {
-    warnings.push(`claudeDriver.preference must be "sdk" or "pty"`)
-  }
-  const lifecycle = normalizeClaudePtyLifecycle(source?.lifecycle, warnings)
-  return { preference, lifecycle }
+  return { lifecycle: normalizeClaudeLifecycle(source?.lifecycle, warnings) }
 }
 
 function normalizeGlobalPromptAppend<T>(value: T, warnings: string[]): string {
@@ -1593,7 +1583,6 @@ function applyPatch(state: AppSettingsState, patch: AppSettingsPatch): AppSettin
     textSnippets: nextTextSnippets,
     ...mergePluginPatch(state, patch),
     claudeDriver: {
-      preference: patch.claudeDriver?.preference ?? state.claudeDriver.preference,
       lifecycle: {
         ...state.claudeDriver.lifecycle,
         ...patch.claudeDriver?.lifecycle,
@@ -1713,24 +1702,20 @@ export class AppSettingsManager {
   }
 
   async setClaudeDriver(patch: {
-    preference?: ClaudeDriverPreference
-    lifecycle?: Partial<ClaudePtyLifecycleSettings>
+    lifecycle?: Partial<ClaudeLifecycleSettings>
   }) {
-    if (patch.preference !== undefined && !isClaudeDriverPreference(patch.preference)) {
-      throw new Error(`claudeDriver.preference must be "sdk" or "pty"`)
-    }
     if (patch.lifecycle?.idleTimeoutMs !== undefined) {
       const value = patch.lifecycle.idleTimeoutMs
       if (typeof value !== "number" || !Number.isFinite(value)
-        || value < CLAUDE_PTY_IDLE_TIMEOUT_MS_MIN || value > CLAUDE_PTY_IDLE_TIMEOUT_MS_MAX) {
-        throw new Error(`claudeDriver.lifecycle.idleTimeoutMs must be between ${CLAUDE_PTY_IDLE_TIMEOUT_MS_MIN} and ${CLAUDE_PTY_IDLE_TIMEOUT_MS_MAX}`)
+        || value < CLAUDE_IDLE_TIMEOUT_MS_MIN || value > CLAUDE_IDLE_TIMEOUT_MS_MAX) {
+        throw new Error(`claudeDriver.lifecycle.idleTimeoutMs must be between ${CLAUDE_IDLE_TIMEOUT_MS_MIN} and ${CLAUDE_IDLE_TIMEOUT_MS_MAX}`)
       }
     }
     if (patch.lifecycle?.maxConcurrent !== undefined) {
       const value = patch.lifecycle.maxConcurrent
       if (typeof value !== "number" || !Number.isFinite(value)
-        || value < CLAUDE_PTY_MAX_CONCURRENT_MIN || value > CLAUDE_PTY_MAX_CONCURRENT_MAX) {
-        throw new Error(`claudeDriver.lifecycle.maxConcurrent must be between ${CLAUDE_PTY_MAX_CONCURRENT_MIN} and ${CLAUDE_PTY_MAX_CONCURRENT_MAX}`)
+        || value < CLAUDE_MAX_CONCURRENT_MIN || value > CLAUDE_MAX_CONCURRENT_MAX) {
+        throw new Error(`claudeDriver.lifecycle.maxConcurrent must be between ${CLAUDE_MAX_CONCURRENT_MIN} and ${CLAUDE_MAX_CONCURRENT_MAX}`)
       }
     }
     return this.writePatch({ claudeDriver: patch })

package/src/server/auto-continue/e2e.test.ts

@@ -100,7 +100,6 @@ describe("auto-continue end-to-end", () => {
           closed: Promise.resolve(),
           setModel: async () => {},
           setPermissionMode: async () => {},
-          getSupportedCommands: async () => [],
           sendPrompt: async () => {
             events.throw(makeRateLimitError(resetAtMs))
           },

package/src/server/background-task-output-registry.test.ts

@@ -1,7 +1,7 @@
 import { describe, test, expect } from "bun:test"
 import { createBackgroundTaskOutputRegistry } from "./background-task-output-registry"
 import type { BackgroundTaskOutputDeps } from "./background-task-output-registry"
-import { OUTPUT_RING_DEFAULT_BYTES } from "./claude-pty/output-ring"
+import { OUTPUT_RING_DEFAULT_BYTES } from "./output-ring"
 
 function makeDeps(fileContents: Map<string, string> = new Map()): BackgroundTaskOutputDeps & { advance(path: string, append: string): void } {
   const contents = new Map(fileContents)

package/src/server/background-task-output-registry.ts

@@ -1,4 +1,4 @@
-import { OutputRing, OUTPUT_RING_DEFAULT_BYTES } from "./claude-pty/output-ring"
+import { OutputRing, OUTPUT_RING_DEFAULT_BYTES } from "./output-ring"
 
 export interface BackgroundTaskOutputDeps {
   statSize(path: string): number | null

package/src/server/claude-cancel-handler.test.ts

@@ -28,7 +28,6 @@ function makeFakeHandle(): ClaudeSessionHandle {
     sendPrompt: async () => {},
     setModel: async () => {},
     setPermissionMode: async () => {},
-    getSupportedCommands: async () => [],
   }
 }
 
@@ -107,8 +106,6 @@ type DepOverrides = {
   stateChanges?: string[]
   rejectCalled?: string[]
   orchestratorCancelled?: string[]
-  closedSessions?: string[]
-  driver?: "sdk" | "pty"
 }
 
 function makeDeps(overrides: DepOverrides = {}): CancelHandlerDeps {
@@ -122,8 +119,6 @@ function makeDeps(overrides: DepOverrides = {}): CancelHandlerDeps {
   const stateChanges = overrides.stateChanges ?? []
   const rejectCalled = overrides.rejectCalled ?? []
   const orchestratorCancelled = overrides.orchestratorCancelled ?? []
-  const closedSessions = overrides.closedSessions ?? []
-  const driver = overrides.driver ?? "sdk"
 
   return {
     drainingStreams,
@@ -138,8 +133,6 @@ function makeDeps(overrides: DepOverrides = {}): CancelHandlerDeps {
     },
     claudeSessions,
     emitStateChange: (chatId) => { stateChanges.push(chatId) },
-    resolveClaudeDriverPreference: () => driver,
-    closeClaudeSession: (chatId) => { closedSessions.push(chatId) },
   }
 }
 
@@ -276,24 +269,6 @@ describe("self-wake turn cancel", () => {
     expect(stateChanges).toContain("chat-1")
   })
 
-  test("PTY driver drops the dead session after a self-wake interrupt", async () => {
-    const session = makeSession({ selfWakeActive: true })
-    session.session = {
-      ...session.session,
-      interrupt: async () => {},
-    }
-    const closedSessions: string[] = []
-    const deps = makeDeps({
-      claudeSessions: new Map([["chat-1", session]]),
-      closedSessions,
-      driver: "pty",
-    })
-
-    await cancelChat(deps, "chat-1")
-
-    expect(closedSessions).toContain("chat-1")
-  })
-
   test("no self-wake, no session interrupt — stays a no-op", async () => {
     let interrupted = false
     const session = makeSession({ selfWakeActive: false })
@@ -557,39 +532,6 @@ describe("interrupt and close", () => {
     const deps = makeDeps({ activeTurns })
     await expect(cancelChat(deps, "chat-1")).resolves.toBeUndefined()
   })
-
-  test("closes Claude session on PTY driver for claude provider", async () => {
-    const closedSessions: string[] = []
-    const session = makeSession({ chatId: "chat-1" })
-    const claudeSessions = new Map([["chat-1", session]])
-    const active = makeActiveTurn({ provider: "claude" })
-    const activeTurns = new Map([["chat-1", active]])
-    const deps = makeDeps({ activeTurns, claudeSessions, closedSessions, driver: "pty" })
-    await cancelChat(deps, "chat-1")
-    expect(closedSessions).toContain("chat-1")
-  })
-
-  test("does NOT close Claude session on SDK driver", async () => {
-    const closedSessions: string[] = []
-    const session = makeSession({ chatId: "chat-1" })
-    const claudeSessions = new Map([["chat-1", session]])
-    const active = makeActiveTurn({ provider: "claude" })
-    const activeTurns = new Map([["chat-1", active]])
-    const deps = makeDeps({ activeTurns, claudeSessions, closedSessions, driver: "sdk" })
-    await cancelChat(deps, "chat-1")
-    expect(closedSessions.length).toBe(0)
-  })
-
-  test("does NOT close Claude session for codex provider even on PTY", async () => {
-    const closedSessions: string[] = []
-    const session = makeSession({ chatId: "chat-1" })
-    const claudeSessions = new Map([["chat-1", session]])
-    const active = makeActiveTurn({ provider: "codex" })
-    const activeTurns = new Map([["chat-1", active]])
-    const deps = makeDeps({ activeTurns, claudeSessions, closedSessions, driver: "pty" })
-    await cancelChat(deps, "chat-1")
-    expect(closedSessions.length).toBe(0)
-  })
 })
 
 

package/src/server/claude-cancel-handler.ts

@@ -1,5 +1,5 @@
 
-import type { ClaudeDriverPreference, TranscriptEntry } from "../shared/types"
+import type { TranscriptEntry } from "../shared/types"
 import type { ActiveTurn, ClaudeSessionState, StartingTurn } from "./claude-session-state"
 import type { PendingToolSlots } from "./pending-tool-slot"
 import type { HarnessTurn } from "./harness-types"
@@ -51,10 +51,6 @@ export interface CancelHandlerDeps {
   claudeSessions: ClaudeSessionsMap
 
   emitStateChange(chatId: string): void
-
-  resolveClaudeDriverPreference(): ClaudeDriverPreference
-
-  closeClaudeSession(chatId: string, session: ClaudeSessionState): void
 }
 
 
@@ -120,10 +116,6 @@ export async function cancelChat(
         ])
       } catch {
       }
-      if (deps.resolveClaudeDriverPreference() === "pty") {
-        deps.closeClaudeSession(chatId, session)
-        deps.emitStateChange(chatId)
-      }
     }
     return
   }
@@ -178,12 +170,4 @@ export async function cancelChat(
   } catch {
   }
   active.turn.close()
-
-  if (active.provider === "claude" && deps.resolveClaudeDriverPreference() === "pty") {
-    const session = deps.claudeSessions.get(chatId)
-    if (session) {
-      deps.closeClaudeSession(chatId, session)
-    }
-  }
-
 }

package/src/server/claude-harness-stream.test.ts

@@ -326,3 +326,137 @@ describe("createClaudeHarnessStream", () => {
     expect(lastSnapshot.usage.maxTokens).toBeGreaterThanOrEqual(1_000_000)
   })
 })
+
+describe("createClaudeHarnessStream cost attachment", () => {
+  test("claude result cost is attached to the final-turn snapshot", async () => {
+    const events = await collect([
+      {
+        type: "assistant",
+        session_id: "sess-cost",
+        message: { id: "m1", role: "assistant", content: [] },
+        usage: { input_tokens: 100, output_tokens: 50 },
+      },
+      {
+        type: "result",
+        subtype: "success",
+        session_id: "sess-cost",
+        is_error: false,
+        total_cost_usd: 0.0123,
+        usage: { input_tokens: 100, output_tokens: 50 },
+        duration_ms: 10,
+        num_turns: 1,
+        result: "ok",
+      },
+    ])
+
+    const cwuEntries = events.flatMap((ev) =>
+      ev.type === "transcript" && ev.entry.kind === "context_window_updated" ? [ev.entry] : [],
+    )
+    const lastCwu = cwuEntries.at(-1)
+    expect(lastCwu).toBeDefined()
+    expect(lastCwu!.usage.costUsd).toBeCloseTo(0.0123, 6)
+  })
+
+  test("openrouter turn gets computed cost from a price resolver", async () => {
+    const price: ModelPrice = { inputPerMTok: 3, outputPerMTok: 15 }
+    const events = await collect(
+      [
+        {
+          type: "assistant",
+          session_id: "sess-or",
+          message: { id: "m1", role: "assistant", content: [] },
+          usage: { input_tokens: 1_000_000, output_tokens: 0 },
+        },
+        {
+          type: "result",
+          subtype: "success",
+          session_id: "sess-or",
+          is_error: false,
+          usage: { input_tokens: 1_000_000, output_tokens: 0 },
+          duration_ms: 10,
+          num_turns: 1,
+          result: "ok",
+        },
+      ],
+      undefined,
+      () => price,
+    )
+
+    const cwuEntries = events.flatMap((ev) =>
+      ev.type === "transcript" && ev.entry.kind === "context_window_updated" ? [ev.entry] : [],
+    )
+    const lastCwu = cwuEntries.at(-1)
+    expect(lastCwu).toBeDefined()
+    expect(lastCwu!.usage.costUsd).toBeCloseTo(3, 6)
+  })
+})
+
+describe("result entry usage + cost enrichment", () => {
+  test("claude: result entry carries usage tokens and provider costUsd", async () => {
+    const events = await collect([
+      {
+        type: "assistant",
+        session_id: "sess-ru",
+        message: { id: "m1", role: "assistant", content: [] },
+        usage: { input_tokens: 200, output_tokens: 80 },
+      },
+      {
+        type: "result",
+        subtype: "success",
+        session_id: "sess-ru",
+        is_error: false,
+        total_cost_usd: 0.02,
+        usage: { input_tokens: 200, output_tokens: 80 },
+        duration_ms: 100,
+        num_turns: 1,
+        result: "done",
+      },
+    ])
+
+    const resultEntries = events.flatMap((ev) =>
+      ev.type === "transcript" && ev.entry.kind === "result" ? [ev.entry] : [],
+    )
+    expect(resultEntries).toHaveLength(1)
+    const resultEntry = resultEntries[0]
+    expect(resultEntry.costUsd).toBeCloseTo(0.02, 6)
+    expect(resultEntry.usage).toBeDefined()
+    expect(resultEntry.usage?.outputTokens).toBe(80)
+    expect(resultEntry.usage?.inputTokens).toBe(200)
+  })
+
+  test("openrouter: result entry carries computed cost and usage tokens from resolver", async () => {
+    const price: ModelPrice = { inputPerMTok: 3, outputPerMTok: 15 }
+    const events = await collect(
+      [
+        {
+          type: "assistant",
+          session_id: "sess-oru",
+          message: { id: "m1", role: "assistant", content: [] },
+          usage: { input_tokens: 1_000_000, output_tokens: 0 },
+        },
+        {
+          type: "result",
+          subtype: "success",
+          session_id: "sess-oru",
+          is_error: false,
+          usage: { input_tokens: 1_000_000, output_tokens: 0 },
+          duration_ms: 10,
+          num_turns: 1,
+          result: "ok",
+        },
+      ],
+      undefined,
+      () => price,
+    )
+
+    const resultEntries = events.flatMap((ev) =>
+      ev.type === "transcript" && ev.entry.kind === "result" ? [ev.entry] : [],
+    )
+    expect(resultEntries).toHaveLength(1)
+    const resultEntry = resultEntries[0]
+    expect(resultEntry.costUsd).toBeCloseTo(3, 6)
+    expect(resultEntry.usage).toBeDefined()
+    expect(resultEntry.usage?.inputTokens).toBe(1_000_000)
+    expect(resultEntry.usage?.outputTokens).toBeUndefined()
+  })
+})

package/src/server/{claude-pty/jsonl-path.test.ts → claude-projects-path.adapter.test.ts}

@@ -3,7 +3,7 @@ import { mkdtemp, rm } from "node:fs/promises"
 import { homedir, tmpdir } from "node:os"
 import path from "node:path"
 import { describe, expect, test } from "bun:test"
-import { computeJsonlPath, computeProjectDir, computeWorkflowsDir, encodeCwd } from "./jsonl-path.adapter"
+import { computeProjectDir, computeWorkflowsDir, encodeCwd } from "./claude-projects-path.adapter"
 
 describe("encodeCwd", () => {
   test("absolute path: replaces / with -", () => {
@@ -23,24 +23,6 @@ describe("encodeCwd", () => {
   })
 })
 
-describe("computeJsonlPath", () => {
-  test("combines homeDir + encoded cwd + session uuid", async () => {
-    const tmp = await mkdtemp(path.join(tmpdir(), "kanna-jsonlpath-"))
-    try {
-      const realPath = realpathSync(tmp)
-      const encodedCwd = realPath.replace(/[^a-zA-Z0-9]/g, "-")
-      const result = computeJsonlPath({
-        homeDir: "/home/u",
-        cwd: tmp,
-        sessionId: "abc-123",
-      })
-      expect(result).toBe(`/home/u/.claude/projects/${encodedCwd}/abc-123.jsonl`)
-    } finally {
-      await rm(tmp, { recursive: true, force: true })
-    }
-  })
-})
-
 describe("encodeCwd realpath + dot replacement", () => {
   test("resolves macOS /var -> /private/var symlink", async () => {
     const tmp = await mkdtemp(path.join(tmpdir(), "kanna-encodecwd-"))

package/src/server/{claude-pty/jsonl-path.adapter.ts → claude-projects-path.adapter.ts}

@@ -39,17 +39,6 @@ export function computeProjectDir(args: {
   return path.join(args.homeDir, ".claude", "projects", encodeCwd(args.cwd))
 }
 
-export function computeJsonlPath(args: {
-  homeDir: string
-  cwd: string
-  sessionId: string
-}): string {
-  return path.join(
-    computeProjectDir({ homeDir: args.homeDir, cwd: args.cwd }),
-    `${args.sessionId}.jsonl`,
-  )
-}
-
 export function computeWorkflowsDir(args: {
   homeDir: string
   cwd: string

package/src/server/claude-send-command.test.ts

@@ -42,7 +42,6 @@ const STUB_HANDLE = {
   closed: Promise.resolve(),
   setModel: async () => {},
   setPermissionMode: async () => {},
-  getSupportedCommands: async () => [],
 }
 
 function makeTestSession(overrides: Partial<ConstructorParameters<typeof ClaudeSessionState>[0]> = {}): ClaudeSessionState {

package/src/server/claude-session-config-helpers.test.ts

@@ -1,10 +1,8 @@
-import { describe, test, expect, mock, beforeEach } from "bun:test"
+import { describe, test, expect, mock } from "bun:test"
 import {
-  resolveClaudeDriverPreference,
   getEnabledCustomMcpServers,
   buildOAuthBearers,
   resolveChatPolicy,
-  killPtyInstance,
   type ClaudeSessionConfigHelpersDeps,
 } from "./claude-session-config-helpers"
 import { POLICY_DEFAULT } from "../shared/permission-policy"
@@ -31,51 +29,13 @@ function makeDeps(overrides: Partial<ClaudeSessionConfigHelpersDeps> = {}): Clau
     getAppSettingsSnapshot: () => ({}),
     chatPolicy: POLICY_DEFAULT,
     store: { state: null },
-    ptyInstanceRegistry: null,
     ensureFreshToken: async () => "test-token",
     persistOAuthState: null,
-    killProcessTree: async (_pid) => {},
     ...overrides,
   }
 }
 
 
-describe("resolveClaudeDriverPreference", () => {
-  const originalEnv = process.env.KANNA_CLAUDE_DRIVER
-
-  beforeEach(() => {
-    delete process.env.KANNA_CLAUDE_DRIVER
-  })
-
-  test("returns 'pty' when settings preference is 'pty'", () => {
-    const deps = makeDeps({
-      getAppSettingsSnapshot: () => ({ claudeDriver: { preference: "pty" } }),
-    })
-    expect(resolveClaudeDriverPreference(deps)).toBe("pty")
-  })
-
-  test("returns 'sdk' when settings preference is 'sdk'", () => {
-    const deps = makeDeps({
-      getAppSettingsSnapshot: () => ({ claudeDriver: { preference: "sdk" } }),
-    })
-    expect(resolveClaudeDriverPreference(deps)).toBe("sdk")
-  })
-
-  test("falls through to env var when settings have no preference", () => {
-    process.env.KANNA_CLAUDE_DRIVER = "pty"
-    const deps = makeDeps({ getAppSettingsSnapshot: () => ({}) })
-    expect(resolveClaudeDriverPreference(deps)).toBe("pty")
-    process.env.KANNA_CLAUDE_DRIVER = originalEnv ?? ""
-    if (!originalEnv) delete process.env.KANNA_CLAUDE_DRIVER
-  })
-
-  test("defaults to 'sdk' when no settings and no env var", () => {
-    const deps = makeDeps({ getAppSettingsSnapshot: () => ({}) })
-    expect(resolveClaudeDriverPreference(deps)).toBe("sdk")
-  })
-})
-
-
 describe("getEnabledCustomMcpServers", () => {
   test("returns only enabled servers", () => {
     const enabled = makeServer({ id: "s1", enabled: true })
@@ -245,52 +205,3 @@ describe("resolveChatPolicy", () => {
     expect(result).toEqual(POLICY_DEFAULT)
   })
 })
-
-
-describe("killPtyInstance", () => {
-  test("throws when no PTY instance found for chat", async () => {
-    const deps = makeDeps({
-      ptyInstanceRegistry: {
-        snapshot: () => [],
-        markExitedIfCurrent: () => {},
-      },
-    })
-    await expect(killPtyInstance(deps, "chat-1")).rejects.toThrow("No live PTY instance for chat")
-  })
-
-  test("throws when PTY instance has no pid", async () => {
-    const deps = makeDeps({
-      ptyInstanceRegistry: {
-        snapshot: () => [{ chatId: "chat-1", pid: null }],
-        markExitedIfCurrent: () => {},
-      },
-    })
-    await expect(killPtyInstance(deps, "chat-1")).rejects.toThrow("No live PTY instance for chat")
-  })
-
-  test("calls killProcessTree with the instance pid", async () => {
-    const killed: number[] = []
-    const deps = makeDeps({
-      ptyInstanceRegistry: {
-        snapshot: () => [{ chatId: "chat-1", pid: 42 }],
-        markExitedIfCurrent: () => {},
-      },
-      killProcessTree: async (pid) => { killed.push(pid) },
-    })
-    await killPtyInstance(deps, "chat-1")
-    expect(killed).toEqual([42])
-  })
-
-  test("calls markExitedIfCurrent after killProcessTree", async () => {
-    const marked: Array<{ chatId: string; pid: number }> = []
-    const deps = makeDeps({
-      ptyInstanceRegistry: {
-        snapshot: () => [{ chatId: "chat-1", pid: 99 }],
-        markExitedIfCurrent: (chatId, pid) => { marked.push({ chatId, pid }) },
-      },
-    })
-    await killPtyInstance(deps, "chat-1")
-    expect(marked).toHaveLength(1)
-    expect(marked[0]).toMatchObject({ chatId: "chat-1", pid: 99 })
-  })
-})