@cuongtran001/kanna 1.63.2 → 1.63.3

package/src/server/import-subagent-drill.e2e.test.ts

@@ -6,7 +6,7 @@ import { importSessionsByIds } from "./claude-session-importer.adapter"
 import { createTestEventStore } from "./storage/test-helpers"
 import { createSubagentTranscriptRegistry } from "./subagent-transcript-registry"
 import { handleObservabilityCommand } from "./ws-router-observability"
-import { encodeCwd } from "./claude-pty/jsonl-path.adapter"
+import { encodeCwd } from "./claude-projects-path.adapter"
 import type { ServerEnvelope } from "../shared/protocol"
 
 describe("subagent drill-in for imported chats (e2e)", () => {

package/src/server/imported-subagents-dir.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import { deriveImportedSubagentsDir } from "./imported-subagents-dir"
-import { encodeCwd } from "./claude-pty/jsonl-path.adapter"
+import { encodeCwd } from "./claude-projects-path.adapter"
 
 const REAL_CWD = process.cwd()
 const encodedCwd = encodeCwd(REAL_CWD)

package/src/server/imported-subagents-dir.ts

@@ -1,6 +1,6 @@
 import { homedir } from "node:os"
 import path from "node:path"
-import { computeProjectDir } from "./claude-pty/jsonl-path.adapter"
+import { computeProjectDir } from "./claude-projects-path.adapter"
 
 export function deriveImportedSubagentsDir(args: {
   cwd: string

package/src/server/kanna-mcp.test.ts

@@ -106,39 +106,6 @@ const makeArgs = (toolCallback?: Parameters<typeof buildKannaMcpTools>[0]["toolC
   tunnelGateway: null,
 })
 
-test("feature flag off → ask_user_question / exit_plan_mode NOT registered", () => {
-  delete process.env.KANNA_MCP_TOOL_CALLBACKS
-  const tools = buildKannaMcpTools(makeArgs(undefined))
-  const names = tools.map((t) => t.name)
-  expect(names).not.toContain("ask_user_question")
-  expect(names).not.toContain("exit_plan_mode")
-})
-
-test("feature flag on → tools registered when toolCallback present", () => {
-  process.env.KANNA_MCP_TOOL_CALLBACKS = "1"
-  const stub: Parameters<typeof buildKannaMcpTools>[0]["toolCallback"] = {
-    submit: async () => ({ status: "answered", decision: { kind: "deny" as const, reason: "test" } }),
-    answer: async () => {},
-    cancel: async () => {},
-    cancelAllForChat: async () => {},
-    recoverOnStartup: async () => {},
-  }
-  const tools = buildKannaMcpTools(makeArgs(stub))
-  const names = tools.map((t) => t.name)
-  expect(names).toContain("ask_user_question")
-  expect(names).toContain("exit_plan_mode")
-  delete process.env.KANNA_MCP_TOOL_CALLBACKS
-})
-
-test("feature flag on but toolCallback absent → tools NOT registered", () => {
-  process.env.KANNA_MCP_TOOL_CALLBACKS = "1"
-  const tools = buildKannaMcpTools(makeArgs(undefined))
-  const names = tools.map((t) => t.name)
-  expect(names).not.toContain("ask_user_question")
-  expect(names).not.toContain("exit_plan_mode")
-  delete process.env.KANNA_MCP_TOOL_CALLBACKS
-})
-
 test("feature flag on → all 8 new mcp__kanna__* tools registered", () => {
   process.env.KANNA_MCP_TOOL_CALLBACKS = "1"
   try {
@@ -169,48 +136,6 @@ test("feature flag on → all 8 new mcp__kanna__* tools registered", () => {
 })
 
 
-const callbackStub = (): Parameters<typeof buildKannaMcpTools>[0]["toolCallback"] => ({
-  submit: async () => ({ status: "answered", decision: { kind: "deny" as const, reason: "test" } }),
-  answer: async () => {},
-  cancel: async () => {},
-  cancelAllForChat: async () => {},
-  recoverOnStartup: async () => {},
-})
-
-test("forceInteractiveToolCallbacks → ask_user_question / exit_plan_mode registered with env flag UNSET", () => {
-  delete process.env.KANNA_MCP_TOOL_CALLBACKS
-  const tools = buildKannaMcpTools({
-    ...makeArgs(callbackStub()),
-    forceInteractiveToolCallbacks: true,
-  })
-  const names = tools.map((t) => t.name)
-  expect(names).toContain("ask_user_question")
-  expect(names).toContain("exit_plan_mode")
-})
-
-test("forceInteractiveToolCallbacks does NOT register the 8 built-in shims (env flag UNSET)", () => {
-  delete process.env.KANNA_MCP_TOOL_CALLBACKS
-  const tools = buildKannaMcpTools({
-    ...makeArgs(callbackStub()),
-    forceInteractiveToolCallbacks: true,
-  })
-  const names = tools.map((t) => t.name)
-  for (const n of ["read", "glob", "grep", "bash", "edit", "write", "webfetch", "websearch"]) {
-    expect(names).not.toContain(n)
-  }
-})
-
-test("forceInteractiveToolCallbacks but toolCallback absent → nothing registered (fail-safe)", () => {
-  delete process.env.KANNA_MCP_TOOL_CALLBACKS
-  const tools = buildKannaMcpTools({
-    ...makeArgs(undefined),
-    forceInteractiveToolCallbacks: true,
-  })
-  const names = tools.map((t) => t.name)
-  expect(names).not.toContain("ask_user_question")
-  expect(names).not.toContain("exit_plan_mode")
-})
-
 describe("buildDelegateProgressEmitter", () => {
   function makeEntry(over: Partial<TranscriptEntry> = {}): TranscriptEntry {
     return { _id: "e1", createdAt: 1, kind: "assistant_text", text: "x", ...over } as TranscriptEntry

package/src/server/kanna-mcp.ts

@@ -20,8 +20,6 @@ import { buildProjectFileContentUrl, buildLocalFileContentUrl } from "../shared/
 import { inferAttachmentContentType, inferProjectFileContentType } from "./uploads"
 import type { TranscriptEntry } from "../shared/types"
 import type { TunnelGateway } from "./cloudflare-tunnel/gateway"
-import { createAskUserQuestionTool } from "./kanna-mcp-tools/ask-user-question"
-import { createExitPlanModeTool } from "./kanna-mcp-tools/exit-plan-mode"
 import { createReadTool } from "./kanna-mcp-tools/read.adapter"
 import { createGlobTool } from "./kanna-mcp-tools/glob.adapter"
 import { createGrepTool } from "./kanna-mcp-tools/grep.adapter"
@@ -81,7 +79,6 @@ export interface KannaMcpArgs extends OfferDownloadArgs {
   chatPolicy?: ChatPermissionPolicy
   subagentOrchestrator?: SubagentOrchestrator
   delegationContext?: KannaMcpDelegationContext
-  forceInteractiveToolCallbacks?: boolean
   restrictedAllowedPaths?: readonly string[]
   setupLoop?: (input: LoopSetupInput) => Promise<SetupLoopHandlerResult>
   stopLoop?: () => Promise<void>
@@ -1046,50 +1043,7 @@ export function buildKannaMcpTools(args: KannaMcpArgs): KannaSdkToolList {
     )
   }
 
-  const envCallbacksEnabled = process.env.KANNA_MCP_TOOL_CALLBACKS === "1"
-  const interactiveEnabled =
-    (envCallbacksEnabled || args.forceInteractiveToolCallbacks === true) && Boolean(args.toolCallback)
-  const builtinShimsEnabled = envCallbacksEnabled && Boolean(args.toolCallback)
-
-  if (interactiveEnabled && args.toolCallback) {
-    const askTool = createAskUserQuestionTool({ toolCallback: args.toolCallback })
-    const exitPlanTool = createExitPlanModeTool({ toolCallback: args.toolCallback })
-
-    tools.push(
-      tool(
-        askTool.name,
-        "Ask the user a question with multiple choice answers",
-        askTool.schema.shape,
-        async (input, extra) => {
-          const requestId = isRecord(extra) && (typeof extra.requestId === "string" || typeof extra.requestId === "number") ? extra.requestId : undefined
-          const toolUseId = requestId != null ? String(requestId) : randomUUID()
-          return await askTool.handler(input, {
-            chatId: chatId ?? "",
-            sessionId,
-            toolUseId,
-            cwd,
-            chatPolicy,
-          })
-        },
-      ),
-      tool(
-        exitPlanTool.name,
-        "Submit a plan for user approval before continuing",
-        exitPlanTool.schema.shape,
-        async (input, extra) => {
-          const requestId = isRecord(extra) && (typeof extra.requestId === "string" || typeof extra.requestId === "number") ? extra.requestId : undefined
-          const toolUseId = requestId != null ? String(requestId) : randomUUID()
-          return await exitPlanTool.handler(input, {
-            chatId: chatId ?? "",
-            sessionId,
-            toolUseId,
-            cwd,
-            chatPolicy,
-          })
-        },
-      ),
-    )
-  }
+  const builtinShimsEnabled = process.env.KANNA_MCP_TOOL_CALLBACKS === "1" && Boolean(args.toolCallback)
 
   if (builtinShimsEnabled && args.toolCallback) {
     const readTool = createReadTool({ toolCallback: args.toolCallback })

package/src/server/server.test.ts

@@ -3,7 +3,7 @@ import {
   AUTH_DEFAULTS,
   CLAUDE_AUTH_DEFAULTS,
   CLAUDE_DRIVER_DEFAULTS,
-  CLAUDE_PTY_LIFECYCLE_DEFAULTS,
+  CLAUDE_LIFECYCLE_DEFAULTS,
   CLOUDFLARE_TUNNEL_DEFAULTS,
   PACKAGE_UPDATE_SETTINGS_DEFAULTS,
   PLUGIN_SETTINGS_DEFAULTS,
@@ -58,7 +58,7 @@ function makeSnapshot(overrides: Partial<AppSettingsSnapshot> = {}): AppSettings
     customMcpServers: [],
     customModels: [],
     textSnippets: [],
-    claudeDriver: { ...CLAUDE_DRIVER_DEFAULTS, lifecycle: { ...CLAUDE_PTY_LIFECYCLE_DEFAULTS } },
+    claudeDriver: { ...CLAUDE_DRIVER_DEFAULTS, lifecycle: { ...CLAUDE_LIFECYCLE_DEFAULTS } },
     globalPromptAppend: "",
     shareDefaultTtlHours: 24,
     subagentRuntime: { runTimeoutMs: 600_000, defaultLoopSubagentId: null },
@@ -97,17 +97,15 @@ describe("buildAgentAppSettingsView", () => {
     expect(view.providerDefaults.claude.modelOptions.contextWindow).toBe("1m")
   })
 
-  test("forwards claudeDriver preference and lifecycle", () => {
+  test("forwards claudeDriver lifecycle", () => {
     const view = buildAgentAppSettingsView(
       makeSnapshot({
         claudeDriver: {
-          preference: "pty",
-          lifecycle: { ...CLAUDE_PTY_LIFECYCLE_DEFAULTS, idleTimeoutMs: 1234, maxConcurrent: 7 },
+          lifecycle: { ...CLAUDE_LIFECYCLE_DEFAULTS, idleTimeoutMs: 1234, maxConcurrent: 7 },
         },
       }),
     )
 
-    expect(view.claudeDriver.preference).toBe("pty")
     expect(view.claudeDriver.lifecycle.idleTimeoutMs).toBe(1234)
     expect(view.claudeDriver.lifecycle.maxConcurrent).toBe(7)
   })
@@ -117,7 +115,7 @@ describe("buildAgentAppSettingsView", () => {
     expect(view.globalPromptAppend).toBe("")
   })
 
-  test("forwards customMcpServers so both drivers receive the user's MCP entries", () => {
+  test("forwards customMcpServers so the agent receives the user's MCP entries", () => {
     const context7: McpServerConfig = {
       id: "mcp-context7",
       name: "context7",

package/src/server/server.ts

@@ -30,8 +30,6 @@ import { fetchOpenRouterModelsRaw } from "./openrouter-models-io.adapter"
 import { getMachineDisplayName } from "./machine-name.adapter"
 import { TerminalManager } from "./terminal-manager"
 import { TerminalPidRegistry } from "./terminal-pid-registry.adapter"
-import { ClaudePtyRegistry } from "./claude-pty/pid-registry.adapter"
-import { createPtyInstanceRegistry } from "./claude-pty/pty-instance-registry"
 import { createBoardRegistry } from "./board-registry"
 import { createBoardStore } from "./board-store.adapter"
 import { createBoardSync } from "./board-sync"
@@ -215,8 +213,6 @@ async function createApplicationServices(options: StartKannaServerOptions): Prom
   if (reapedTerminals.length > 0) {
     log.info(`[kanna] reaped ${reapedTerminals.length} orphan terminal process group(s) from previous run`)
   }
-  const claudePtyRegistry = new ClaudePtyRegistry(path.join(store.dataDir, "claude-pty.json"))
-  const ptyInstanceRegistry = createPtyInstanceRegistry()
   const boardStore = createBoardStore({ filePath: path.join(store.dataDir, "boards.db") })
   const boardRegistry = createBoardRegistry({ store: boardStore })
   const boardSync = createBoardSync({
@@ -236,9 +232,8 @@ async function createApplicationServices(options: StartKannaServerOptions): Prom
   })
   const subagentTranscriptRegistry = createSubagentTranscriptRegistry()
   const backgroundTaskOutputRegistry = createBackgroundTaskOutputRegistry(backgroundTaskOutputIo)
-  const reapedClaudePty = await claudePtyRegistry.reapStale()
-  if (reapedClaudePty.length > 0) {
-    log.info(`[kanna] reaped ${reapedClaudePty.length} orphan claude PTY process group(s) from previous run`)
+  if (process.env.KANNA_CLAUDE_DRIVER === "pty") {
+    log.warn("[kanna] KANNA_CLAUDE_DRIVER=pty is ignored: the PTY driver was removed and Claude chats run on the Agent SDK. Unset the variable to silence this warning.")
   }
   const keybindings = new KeybindingsManager()
   const appSettings = new AppSettingsManager(path.join(store.dataDir, "settings.json"))
@@ -390,8 +385,6 @@ async function createApplicationServices(options: StartKannaServerOptions): Prom
     tunnelGateway,
     oauthPool,
     toolCallback,
-    claudePtyRegistry,
-    ptyInstanceRegistry,
     workflowRegistry,
     boardRegistry,
     backgroundTaskOutputRegistry,
@@ -526,7 +519,6 @@ async function createApplicationServices(options: StartKannaServerOptions): Prom
     machineDisplayName,
     updateManager,
     pushManager,
-    ptyInstances: ptyInstanceRegistry,
     workflowRegistry,
     boardRegistry,
     boardSync,
@@ -538,14 +530,6 @@ async function createApplicationServices(options: StartKannaServerOptions): Prom
     backgroundTaskOutputRegistry,
     subagentTranscriptRegistry,
     followedSessionRegistry,
-    killPtyInstance: async (chatId: string) => {
-      try {
-        await agent.killPtyInstance(chatId)
-        return { ok: true }
-      } catch (err) {
-        return { ok: false, error: err instanceof Error ? err.message : String(err) }
-      }
-    },
     sessionShare: sessionShareService,
     packageUpdateManager,
     genuiDatasets,

package/src/server/subagent-orchestrator.test.ts

@@ -519,7 +519,6 @@ describe("SubagentOrchestrator", () => {
       sendPrompt: async () => {},
       setModel: async () => {},
       setPermissionMode: async () => {},
-      getSupportedCommands: async () => [],
       getAccountInfo: async () => null,
     }
 

package/src/server/subagent-provider-run.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import type { JsonValue } from "../shared/json"
-import type { ClaudeModelOptions, Subagent, TranscriptEntry } from "../shared/types"
+import type { ClaudeModelOptions, CustomModelEntry, Subagent, TranscriptEntry } from "../shared/types"
 import type { HarnessEvent, HarnessTurn, HarnessToolRequest } from "./harness-types"
 import type { StartCodexSessionArgs, CodexSessionScope } from "./codex-app-server"
 import { buildSubagentProviderRun, composeInitialPrompt, composeSubagentSystemPrompt, drainOneTurn, type BuildSubagentProviderRunArgs } from "./subagent-provider-run"
@@ -96,6 +96,37 @@ function makeArgs(over: Partial<BuildSubagentProviderRunArgs> = {}): BuildSubage
 }
 
 
+const HAIKU_WITH_1M: CustomModelEntry = {
+  id: "claude-haiku-5-5",
+  label: "Claude Haiku 5.5",
+  provider: "claude",
+  contextWindowOptions: [{ id: "200k", label: "200k" }, { id: "1m", label: "1M" }],
+  createdAt: 1,
+  updatedAt: 1,
+}
+
+async function modelPassedToSession(args: BuildSubagentProviderRunArgs): Promise<string | undefined> {
+  let model: string | undefined
+  const run = buildSubagentProviderRun({
+    ...args,
+    startClaudeSession: async (sessionArgs) => {
+      model = sessionArgs.model
+      return {
+        provider: "claude" as const,
+        stream: makeHarnessTurn([]).stream,
+        interrupt: async () => {},
+        close: () => {},
+        closed: Promise.resolve(),
+        sendPrompt: async () => {},
+        setModel: async () => {},
+        setPermissionMode: async () => {},
+      }
+    },
+  })
+  await run.start(() => {}, () => {})
+  return model
+}
+
 describe("composeInitialPrompt", () => {
   const subagent = makeSubagent({ name: "reviewer" })
 
@@ -205,7 +236,6 @@ describe("buildSubagentProviderRun – Claude", () => {
         closed: Promise.resolve(),
         setModel: async () => {},
         setPermissionMode: async () => {},
-        getSupportedCommands: async () => [],
       }),
     })
 
@@ -239,7 +269,6 @@ describe("buildSubagentProviderRun – Claude", () => {
           sendPrompt: async () => {},
           setModel: async () => {},
           setPermissionMode: async () => {},
-          getSupportedCommands: async () => [],
         }
       },
     })
@@ -248,6 +277,22 @@ describe("buildSubagentProviderRun – Claude", () => {
     expect(captured?.systemPromptOverride).toBe("You are alpha.\n\n## Workspace instructions\n\nAlways TDD.")
   })
 
+  test("runs a Claude subagent at the 1M context window it is configured for", async () => {
+    const model = await modelPassedToSession(makeArgs({
+      subagent: makeSubagent({ model: "claude-haiku-5-5" }),
+      customModels: [HAIKU_WITH_1M],
+    }))
+    expect(model).toBe("claude-haiku-5-5[1m]")
+  })
+
+  test("keeps the bare model id when the model does not offer the 1M window", async () => {
+    const model = await modelPassedToSession(makeArgs({
+      subagent: makeSubagent({ model: "claude-haiku-5-5" }),
+      customModels: [{ ...HAIKU_WITH_1M, contextWindowOptions: [{ id: "200k", label: "200k" }] }],
+    }))
+    expect(model).toBe("claude-haiku-5-5")
+  })
+
   test("leaves systemPromptOverride untouched when no globalPromptAppend", async () => {
     let captured: { systemPromptOverride?: string } | undefined
     const args = makeArgs({
@@ -262,7 +307,6 @@ describe("buildSubagentProviderRun – Claude", () => {
           sendPrompt: async () => {},
           setModel: async () => {},
           setPermissionMode: async () => {},
-          getSupportedCommands: async () => [],
         }
       },
     })
@@ -297,7 +341,6 @@ describe("buildSubagentProviderRun – Claude", () => {
         closed: Promise.resolve(),
         setModel: async () => {},
         setPermissionMode: async () => {},
-        getSupportedCommands: async () => [],
       }),
     })
 
@@ -341,7 +384,6 @@ describe("buildSubagentProviderRun – Claude", () => {
           sendPrompt: async () => {},
           setModel: async () => {},
           setPermissionMode: async () => {},
-          getSupportedCommands: async () => [],
         }
       },
     })
@@ -506,7 +548,6 @@ describe("buildSubagentProviderRun – keep-alive Claude", () => {
         closed: Promise.resolve(),
         setModel: async () => {},
         setPermissionMode: async () => {},
-        getSupportedCommands: async () => [],
         pushChannelPrompt: async (text: string) => {
           pushed.push(text)
           pushEvent(makeTextEvent(`r:${text}`))
@@ -547,7 +588,6 @@ describe("buildSubagentProviderRun – keep-alive Claude", () => {
           sendPrompt: async () => {},
           setModel: async () => {},
           setPermissionMode: async () => {},
-          getSupportedCommands: async () => [],
           pushChannelPrompt: async (_text: string) => {},
         }
       },
@@ -571,7 +611,6 @@ describe("buildSubagentProviderRun – keep-alive Claude", () => {
         closed: Promise.resolve(),
         setModel: async () => {},
         setPermissionMode: async () => {},
-        getSupportedCommands: async () => [],
       }),
     })
 
@@ -599,7 +638,6 @@ describe("buildSubagentProviderRun – keep-alive Claude", () => {
         closed: Promise.resolve(),
         setModel: async () => {},
         setPermissionMode: async () => {},
-        getSupportedCommands: async () => [],
       }),
     })
 

package/src/server/subagent-provider-run.ts

@@ -3,11 +3,13 @@ import type { HarnessEvent, HarnessToolRequest, HarnessTurn } from "./harness-ty
 import type { CodexAppServerManager } from "./codex-app-server"
 import type {
   AgentProvider,
+  CustomModelEntry,
   ProviderUsage,
   ResolvedStackBinding,
   Subagent,
   TranscriptEntry,
 } from "../shared/types"
+import { normalizeClaudeContextWindow, resolveClaudeApiModelId } from "../shared/types"
 import {
   buildCodexDeveloperInstructions,
   renderInstructionSections,
@@ -54,7 +56,6 @@ export interface BuildSubagentProviderRunArgs {
     getArmedLoop?: (chatId: string) => ArmedLoopInfo | null
     chatTaskStore?: ChatTaskStorePort
   }) => Promise<ClaudeSessionHandle>
-  claudeDriverIsPty?: boolean
   subagentOrchestrator?: SubagentOrchestrator
   delegationContext?: KannaMcpDelegationContext
   getArmedLoop?: (chatId: string) => ArmedLoopInfo | null
@@ -65,6 +66,7 @@ export interface BuildSubagentProviderRunArgs {
   pickOauthToken: () => { token: string; baseUrl?: string } | null
   readOpenRouterKey?: () => Promise<string | null>
   projectId: string
+  customModels?: readonly CustomModelEntry[]
   globalPromptAppend?: string
   stackProjects?: ResolvedStackBinding[]
   instructions?: Omit<KannaSystemPromptOptions, "stackProjects" | "globalPromptAppend">
@@ -85,7 +87,7 @@ export function buildSubagentProviderRun(args: BuildSubagentProviderRunArgs): Pr
     systemPrompt: args.subagent.systemPrompt,
     preamble: args.primer,
     maxTurns: args.subagent.maxTurns,
-    nativeMaxTurns: args.subagent.provider === "claude" && !args.claudeDriverIsPty,
+    nativeMaxTurns: args.subagent.provider === "claude",
     authReady: async () => args.authReady(args.subagent.provider),
     async start(onChunk, onEntry, opts) {
       const initialPrompt = composeInitialPrompt(args.subagent, args.primer, args.userInstruction)
@@ -128,6 +130,13 @@ export function composeInitialPrompt(
   return `(no prior context — proceed based on your system prompt and the @agent/${subagent.name} mention)`
 }
 
+function claudeSubagentModelId(args: BuildSubagentProviderRunArgs): string {
+  const { model, provider, modelOptions } = args.subagent
+  if (provider !== "claude") return model
+  const requested = "contextWindow" in modelOptions ? modelOptions.contextWindow : undefined
+  return resolveClaudeApiModelId(model, normalizeClaudeContextWindow(model, requested, args.customModels))
+}
+
 async function runClaudeSubagent(opts: {
   args: BuildSubagentProviderRunArgs
   initialPrompt: string
@@ -142,7 +151,7 @@ async function runClaudeSubagent(opts: {
     projectId: args.projectId,
     localPath: args.cwd,
     additionalDirectories: args.additionalDirectories,
-    model: args.subagent.model,
+    model: claudeSubagentModelId(args),
     effort: args.subagent.modelOptions?.reasoningEffort,
     planMode: false,
     sessionToken: null,

package/src/server/tool-callback.test.ts

@@ -126,7 +126,7 @@ describe("tool-callback durable protocol", () => {
     })
     const p = svc.submit(baseInput)
     await new Promise<void>((r) => setTimeout(r, 0))
-    await svc.cancelAllForChat("chat-1", "PTY shutdown")
+    await svc.cancelAllForChat("chat-1", "session shutdown")
     const res = await p
     expect(res.status).toBe("canceled")
   })

package/src/server/ws-router-agent-ctrl.test.ts

@@ -10,7 +10,6 @@ function makeAgent(overrides: Partial<AgentCtrlAgentDep> = {}): AgentCtrlAgentDe
     rescheduleAutoContinue: mock(async () => {}),
     cancelAutoContinue: mock(async () => {}),
     runCronCommand: mock(async () => null),
-    cancel: mock(async () => {}),
     ...overrides,
   }
 }
@@ -27,14 +26,12 @@ function makeTunnel(overrides: Partial<TunnelGatewayDep> = {}): TunnelGatewayDep
 function makeDeps(
   agentOverrides?: Partial<AgentCtrlAgentDep>,
   tunnel?: TunnelGatewayDep | undefined,
-  killPty?: AgentCtrlCommandDeps["killPtyInstance"],
 ): AgentCtrlCommandDeps & { sent: unknown[]; broadcasts: string[] } {
   const sent: unknown[] = []
   const broadcasts: string[] = []
   return {
     agent: makeAgent(agentOverrides),
     tunnelGateway: tunnel,
-    killPtyInstance: killPty,
     send: (envelope) => { sent.push(envelope) },
     broadcastChatAndSidebar: async (chatId) => { broadcasts.push(chatId) },
     sent,
@@ -128,46 +125,4 @@ describe("handleAgentCtrlCommand", () => {
     expect((tunnel.retry as ReturnType<typeof mock>)).toHaveBeenCalledWith("c-7", "t-4")
     expect(deps.broadcasts).toEqual(["c-7"])
   })
-
-
-  test("pty.cancel — acks {ok:true} on success", async () => {
-    const deps = makeDeps()
-    const cmd: ClientCommand = { type: "pty.cancel", chatId: "c-8" }
-    const handled = await handleAgentCtrlCommand(deps, cmd, "r8")
-    expect(handled).toBe(true)
-    expect((deps.agent.cancel as ReturnType<typeof mock>)).toHaveBeenCalledWith("c-8")
-    const ack = deps.sent[0] as { result: { ok: boolean } }
-    expect(ack.result.ok).toBe(true)
-  })
-
-  test("pty.cancel — acks {ok:false} when agent.cancel throws", async () => {
-    const deps = makeDeps({ cancel: mock(async () => { throw new Error("boom") }) })
-    const cmd: ClientCommand = { type: "pty.cancel", chatId: "c-9" }
-    const handled = await handleAgentCtrlCommand(deps, cmd, "r9")
-    expect(handled).toBe(true)
-    const ack = deps.sent[0] as { result: { ok: boolean; error: string } }
-    expect(ack.result.ok).toBe(false)
-    expect(ack.result.error).toBe("boom")
-  })
-
-  test("pty.kill — returns {ok:false} error when killPtyInstance is absent", async () => {
-    const deps = makeDeps(undefined, undefined, undefined)
-    const cmd: ClientCommand = { type: "pty.kill", chatId: "c-10" }
-    const handled = await handleAgentCtrlCommand(deps, cmd, "r10")
-    expect(handled).toBe(true)
-    const ack = deps.sent[0] as { result: { ok: boolean; error: string } }
-    expect(ack.result.ok).toBe(false)
-    expect(ack.result.error).toContain("not available")
-  })
-
-  test("pty.kill — delegates to killPtyInstance and acks with its result", async () => {
-    const killFn = mock(async (_chatId: string) => ({ ok: true }))
-    const deps = makeDeps(undefined, undefined, killFn)
-    const cmd: ClientCommand = { type: "pty.kill", chatId: "c-11" }
-    const handled = await handleAgentCtrlCommand(deps, cmd, "r11")
-    expect(handled).toBe(true)
-    expect(killFn).toHaveBeenCalledWith("c-11")
-    const ack = deps.sent[0] as { result: { ok: boolean } }
-    expect(ack.result.ok).toBe(true)
-  })
 })

package/src/server/ws-router-agent-ctrl.ts

@@ -7,7 +7,6 @@ export interface AgentCtrlAgentDep {
   rescheduleAutoContinue(chatId: string, scheduleId: string, scheduledAt: number): Promise<void>
   cancelAutoContinue(chatId: string, scheduleId: string, reason: "user" | "chat_deleted"): Promise<void>
   runCronCommand(chatId: string, result: import("../shared/cron/types").CronParseResult): Promise<string | null>
-  cancel(chatId: string): Promise<void>
 }
 
 export interface TunnelGatewayDep {
@@ -19,7 +18,6 @@ export interface TunnelGatewayDep {
 export interface AgentCtrlCommandDeps {
   agent: AgentCtrlAgentDep
   tunnelGateway: TunnelGatewayDep | undefined
-  killPtyInstance: ((chatId: string) => Promise<{ ok: boolean; error?: string }>) | undefined
   send: (envelope: ServerEnvelope) => void
   broadcastChatAndSidebar: (chatId: string) => Promise<void>
 }
@@ -30,7 +28,7 @@ export async function handleAgentCtrlCommand(
   command: ClientCommand,
   id: string,
 ): Promise<boolean> {
-  const { agent, tunnelGateway, killPtyInstance, send, broadcastChatAndSidebar } = deps
+  const { agent, tunnelGateway, send, broadcastChatAndSidebar } = deps
 
   switch (command.type) {
     case "autoContinue.accept": {
@@ -98,34 +96,6 @@ export async function handleAgentCtrlCommand(
       await broadcastChatAndSidebar(command.chatId)
       return true
     }
-    case "pty.cancel": {
-      try {
-        await agent.cancel(command.chatId)
-        send({ v: PROTOCOL_VERSION, type: "ack", id, result: { ok: true } })
-      } catch (err) {
-        send({
-          v: PROTOCOL_VERSION,
-          type: "ack",
-          id,
-          result: { ok: false, error: err instanceof Error ? err.message : String(err) },
-        })
-      }
-      return true
-    }
-    case "pty.kill": {
-      if (!killPtyInstance) {
-        send({
-          v: PROTOCOL_VERSION,
-          type: "ack",
-          id,
-          result: { ok: false, error: "pty kill not available" },
-        })
-        return true
-      }
-      const result = await killPtyInstance(command.chatId)
-      send({ v: PROTOCOL_VERSION, type: "ack", id, result })
-      return true
-    }
     default:
       return false
   }