@cuongtran001/kanna 0.43.2 → 0.45.0

package/src/server/background-tasks.test.ts

@@ -0,0 +1,293 @@
+import { describe, expect, it } from "bun:test"
+import { spawn } from "bun"
+import { BackgroundTaskRegistry, type BackgroundTask } from "./background-tasks"
+import type { AnalyticsReporter } from "./analytics"
+
+function makeAnalytics() {
+  const calls: Array<{ name: string; properties?: Record<string, unknown> }> = []
+  const reporter: AnalyticsReporter = {
+    track: (name, properties) => { calls.push({ name, properties }) },
+    trackLaunch: () => {},
+  }
+  return { reporter, calls }
+}
+
+const drainingSample = (
+  overrides: Partial<Extract<BackgroundTask, { kind: "draining_stream" }>> = {},
+): Extract<BackgroundTask, { kind: "draining_stream" }> => ({
+  kind: "draining_stream",
+  id: "ds-1",
+  chatId: "chat-1",
+  startedAt: 1_700_000_000_000,
+  lastOutput: "",
+  ...overrides,
+})
+
+describe("BackgroundTaskRegistry", () => {
+  it("registers and lists a task", () => {
+    const r = new BackgroundTaskRegistry()
+    r.register(drainingSample())
+    expect(r.list()).toHaveLength(1)
+    expect(r.list()[0].id).toBe("ds-1")
+  })
+
+  it("filters by chatId", () => {
+    const r = new BackgroundTaskRegistry()
+    r.register(drainingSample())
+    r.register(drainingSample({ id: "ds-2", chatId: "chat-2" }))
+    expect(r.listByChat("chat-1").map((t) => t.id)).toEqual(["ds-1"])
+  })
+
+  it("unregisters a task", () => {
+    const r = new BackgroundTaskRegistry()
+    r.register(drainingSample())
+    r.unregister("ds-1")
+    expect(r.list()).toHaveLength(0)
+  })
+
+  it("emits added/updated/removed events in order", () => {
+    const r = new BackgroundTaskRegistry()
+    const events: string[] = []
+    r.on("added", () => events.push("added"))
+    r.on("updated", () => events.push("updated"))
+    r.on("removed", () => events.push("removed"))
+    r.register(drainingSample())
+    r.update("ds-1", { lastOutput: "hi" })
+    r.unregister("ds-1")
+    expect(events).toEqual(["added", "updated", "removed"])
+  })
+
+  it("update() throws when patch.kind mismatches the stored task kind", () => {
+    const r = new BackgroundTaskRegistry()
+    r.register(drainingSample())
+    expect(() =>
+      r.update("ds-1", { kind: "bash_shell" } as Partial<BackgroundTask>),
+    ).toThrow("BackgroundTaskRegistry.update: kind mismatch (draining_stream -> bash_shell)")
+  })
+
+  it("listByChat excludes terminal_pty tasks (no chatId field)", () => {
+    const r = new BackgroundTaskRegistry()
+    r.register(drainingSample({ id: "ds-1", chatId: "chat-1" }))
+    r.register({
+      kind: "terminal_pty",
+      id: "pty-1",
+      ptyId: "p1",
+      cwd: "/tmp",
+      startedAt: 1_700_000_000_000,
+      lastOutput: "",
+    })
+    const ids = r.listByChat("chat-1").map((t) => t.id)
+    expect(ids).toEqual(["ds-1"])
+  })
+})
+
+describe("BackgroundTaskRegistry.stop", () => {
+  it("sends SIGTERM, then SIGKILL after grace, on a real process", async () => {
+    // Spawn a Bun script that ignores SIGTERM and stays alive.
+    const child = spawn({
+      cmd: ["bun", "-e", "process.on('SIGTERM', () => {}); setInterval(() => {}, 1000);"],
+      stdin: "ignore",
+    })
+    // Wait for the child process to finish initializing its signal handlers
+    // before calling stop(), otherwise the SIGTERM arrives before registration.
+    await Bun.sleep(300)
+    const r = new BackgroundTaskRegistry()
+    r.register({
+      kind: "bash_shell",
+      id: "sh-1",
+      chatId: null,
+      command: "bun",
+      shellId: "shell-1",
+      pid: child.pid!,
+      startedAt: Date.now(),
+      lastOutput: "",
+      status: "running",
+    })
+    const result = await r.stop("sh-1", { graceMs: 200 })
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.method).toBe("sigkill")
+    }
+    await child.exited
+  }, 5000)
+
+  it("force: true uses SIGKILL immediately", async () => {
+    const child = spawn({
+      cmd: ["bun", "-e", "setInterval(() => {}, 1000);"],
+      stdin: "ignore",
+    })
+    const r = new BackgroundTaskRegistry()
+    r.register({
+      kind: "bash_shell",
+      id: "sh-2",
+      chatId: null,
+      command: "bun",
+      shellId: "shell-2",
+      pid: child.pid!,
+      startedAt: Date.now(),
+      lastOutput: "",
+      status: "running",
+    })
+    const result = await r.stop("sh-2", { force: true })
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.method).toBe("sigkill")
+    }
+    await child.exited
+  }, 5000)
+
+  it("PID-reuse guard: returns ok:false when comm does not match", async () => {
+    const r = new BackgroundTaskRegistry()
+    r.register({
+      kind: "bash_shell",
+      id: "sh-3",
+      chatId: null,
+      command: "definitely-not-this-one",
+      shellId: "shell-3",
+      pid: 1, // init/launchd, never matches "definitely-not-this-one"
+      startedAt: Date.now(),
+      lastOutput: "",
+      status: "running",
+    })
+    const result = await r.stop("sh-3")
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+      expect(result.error).toContain("PID mismatch")
+    }
+    expect(r.list()).toHaveLength(0) // dropped from registry
+  })
+
+  it("word-boundary guard: 'bunbar' does not match a 'bun' process", async () => {
+    // Spawn a real bun process so we have a live PID that ps shows as "bun ..."
+    const child = spawn({
+      cmd: ["bun", "-e", "setInterval(() => {}, 1000);"],
+      stdin: "ignore",
+    })
+    await Bun.sleep(200)
+    const r = new BackgroundTaskRegistry()
+    r.register({
+      kind: "bash_shell",
+      id: "sh-wb",
+      chatId: null,
+      // "bunbar" starts with "bun" — the old substring match would wrongly accept it
+      command: "bunbar",
+      shellId: "shell-wb",
+      pid: child.pid!,
+      startedAt: Date.now(),
+      lastOutput: "",
+      status: "running",
+    })
+    const result = await r.stop("sh-wb")
+    // verifyComm should reject because no word boundary match for "bunbar"
+    expect(result.ok).toBe(false)
+    if (!result.ok) {
+      expect(result.error).toContain("PID mismatch")
+    }
+    // Clean up the orphaned child
+    try {
+      process.kill(child.pid!, "SIGKILL")
+    } catch {
+      // already dead
+    }
+    await child.exited
+  }, 5000)
+
+  it("analytics: bg_task_stopped emitted after successful stop", async () => {
+    const { reporter, calls } = makeAnalytics()
+    const child = spawn({
+      cmd: ["bun", "-e", "setInterval(() => {}, 1000);"],
+      stdin: "ignore",
+    })
+    await Bun.sleep(200)
+    const r = new BackgroundTaskRegistry({ analytics: reporter })
+    const startedAt = Date.now() - 500
+    r.register({
+      kind: "bash_shell",
+      id: "sh-analytics",
+      chatId: null,
+      command: "bun",
+      shellId: "shell-analytics",
+      pid: child.pid!,
+      startedAt,
+      lastOutput: "",
+      status: "running",
+    })
+    // bg_task_registered is emitted on register
+    expect(calls).toHaveLength(1)
+    expect(calls[0]?.name).toBe("bg_task_registered")
+    expect(calls[0]?.properties?.task_kind).toBe("bash_shell")
+
+    const result = await r.stop("sh-analytics", { force: true })
+    expect(result.ok).toBe(true)
+    // bg_task_stopped is emitted after successful stop
+    expect(calls).toHaveLength(2)
+    expect(calls[1]?.name).toBe("bg_task_stopped")
+    expect(calls[1]?.properties?.task_kind).toBe("bash_shell")
+    expect(calls[1]?.properties?.force).toBe(true)
+    expect(typeof calls[1]?.properties?.age_ms).toBe("number")
+    await child.exited
+  }, 5000)
+
+  it("analytics: bg_task_stopped not emitted on failed stop (PID mismatch)", async () => {
+    const { reporter, calls } = makeAnalytics()
+    const r = new BackgroundTaskRegistry({ analytics: reporter })
+    r.register({
+      kind: "bash_shell",
+      id: "sh-no-emit",
+      chatId: null,
+      command: "definitely-not-this-one",
+      shellId: "shell-no-emit",
+      pid: 1,
+      startedAt: Date.now(),
+      lastOutput: "",
+      status: "running",
+    })
+    const result = await r.stop("sh-no-emit")
+    expect(result.ok).toBe(false)
+    // Only bg_task_registered, no bg_task_stopped
+    expect(calls).toHaveLength(1)
+    expect(calls[0]?.name).toBe("bg_task_registered")
+  })
+
+  it("killShell strategy hook: invoked instead of POSIX signals", async () => {
+    const child = spawn({
+      cmd: ["bun", "-e", "setInterval(() => {}, 1000);"],
+      stdin: "ignore",
+    })
+    await Bun.sleep(200)
+    const r = new BackgroundTaskRegistry()
+    r.register({
+      kind: "bash_shell",
+      id: "sh-ks",
+      chatId: null,
+      command: "bun",
+      shellId: "shell-ks",
+      pid: child.pid!,
+      startedAt: Date.now(),
+      lastOutput: "",
+      status: "running",
+    })
+
+    let strategyCalled = 0
+    r.setStrategies({
+      killShell: async (task) => {
+        strategyCalled++
+        // Actually kill so the test doesn't leave a zombie
+        try {
+          process.kill(task.pid!, "SIGKILL")
+        } catch {
+          // already gone
+        }
+      },
+    })
+
+    const result = await r.stop("sh-ks")
+    expect(result.ok).toBe(true)
+    if (result.ok) {
+      expect(result.method).toBe("sigterm")
+    }
+    expect(strategyCalled).toBe(1)
+    expect(r.list()).toHaveLength(0)
+    await child.exited
+  }, 5000)
+})

package/src/server/background-tasks.ts

@@ -0,0 +1,219 @@
+import type { BackgroundTask } from "../shared/types"
+import type { AnalyticsReporter } from "./analytics"
+
+export type { BackgroundTask }
+
+export type RegistryEvent = "added" | "updated" | "removed"
+export type Listener = (task: BackgroundTask) => void
+export type Unsubscribe = () => void
+
+export type StopResult =
+  | { ok: true; method: "sigterm" | "sigkill" | "close" | "shutdown" }
+  | { ok: false; error: string }
+
+export type StopOptions = { force?: boolean; graceMs?: number }
+
+export type StopStrategies = {
+  killShell?: (task: Extract<BackgroundTask, { kind: "bash_shell" }>) => Promise<void>
+  closeStream?: (task: Extract<BackgroundTask, { kind: "draining_stream" }>) => Promise<void>
+  killPty?: (task: Extract<BackgroundTask, { kind: "terminal_pty" }>) => Promise<void>
+  shutdownCodex?: (task: Extract<BackgroundTask, { kind: "codex_session" }>) => Promise<void>
+}
+
+async function safeKill(pid: number, signal: "SIGTERM" | "SIGKILL"): Promise<void> {
+  // Try the process group first so child processes (e.g. spawned by a shell) are
+  // also signalled. Fall back to single-pid kill if the group signal fails.
+  // Note: ESRCH from -pid means "no such process group" (the pid is not a
+  // group leader), so we always fall through to the single-pid kill in that case.
+  let groupKilled = false
+  try {
+    process.kill(-pid, signal)
+    groupKilled = true
+  } catch {
+    // Any error (ESRCH = no group, EPERM, EINVAL) means group kill failed;
+    // fall through to single-pid kill below.
+  }
+  if (groupKilled) return
+  try {
+    process.kill(pid, signal)
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code
+    if (code === "ESRCH") return
+    throw err
+  }
+}
+
+async function waitForExit(pid: number, timeoutMs: number): Promise<boolean> {
+  const start = Date.now()
+  while (Date.now() - start < timeoutMs) {
+    try {
+      process.kill(pid, 0)
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException).code
+      if (code === "ESRCH") return true
+      // EPERM and other codes mean the process still exists; keep polling.
+    }
+    await Bun.sleep(50)
+  }
+  return false
+}
+
+async function verifyComm(pid: number, expectedCommand: string): Promise<boolean> {
+  try {
+    const proc = Bun.spawn({
+      cmd: ["ps", "-p", String(pid), "-o", "command="],
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "ignore",
+    })
+    const out = (await new Response(proc.stdout).text()).trim()
+    await proc.exited
+    if (!out) return false
+    const cmdToken = expectedCommand.split(/\s+/)[0] ?? ""
+    if (!cmdToken) return true
+    const escaped = cmdToken.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+    return new RegExp(`(?:^|[/\\s])${escaped}(?:\\s|$)`).test(out)
+  } catch {
+    return false
+  }
+}
+
+export interface BackgroundTaskRegistryOptions {
+  analytics?: AnalyticsReporter
+}
+
+export class BackgroundTaskRegistry {
+  private tasks = new Map<string, BackgroundTask>()
+  private listeners: Record<RegistryEvent, Set<Listener>> = {
+    added: new Set(),
+    updated: new Set(),
+    removed: new Set(),
+  }
+  private strategies: StopStrategies = {}
+  private readonly analytics: AnalyticsReporter | undefined
+
+  constructor(options: BackgroundTaskRegistryOptions = {}) {
+    this.analytics = options.analytics
+  }
+
+  setStrategies(strategies: StopStrategies): void {
+    this.strategies = { ...this.strategies, ...strategies }
+  }
+
+  list(): BackgroundTask[] {
+    return Array.from(this.tasks.values())
+  }
+
+  /**
+   * Returns tasks whose chatId matches the given value.
+   * terminal_pty tasks are intentionally excluded because they have no chatId field.
+   */
+  listByChat(chatId: string): BackgroundTask[] {
+    return this.list().filter((t) => "chatId" in t && t.chatId === chatId)
+  }
+
+  register(task: BackgroundTask): void {
+    this.tasks.set(task.id, task)
+    this.emit("added", task)
+    this.analytics?.track("bg_task_registered", { task_kind: task.kind })
+  }
+
+  update(id: string, patch: Partial<BackgroundTask>): void {
+    const prev = this.tasks.get(id)
+    if (!prev) return
+    if (patch.kind !== undefined && patch.kind !== prev.kind) {
+      throw new Error(`BackgroundTaskRegistry.update: kind mismatch (${prev.kind} -> ${patch.kind})`)
+    }
+    const next = { ...prev, ...patch } as BackgroundTask
+    this.tasks.set(id, next)
+    this.emit("updated", next)
+  }
+
+  unregister(id: string): void {
+    const prev = this.tasks.get(id)
+    if (!prev) return
+    this.tasks.delete(id)
+    this.emit("removed", prev)
+  }
+
+  on(event: RegistryEvent, cb: Listener): Unsubscribe {
+    this.listeners[event].add(cb)
+    return () => this.listeners[event].delete(cb)
+  }
+
+  async stop(id: string, opts: StopOptions = {}): Promise<StopResult> {
+    const task = this.tasks.get(id)
+    if (!task) return { ok: false, error: "task not found" }
+
+    const result = await this.runStop(task, opts)
+
+    if (result.ok) {
+      this.analytics?.track("bg_task_stopped", {
+        task_kind: task.kind,
+        age_ms: Date.now() - task.startedAt,
+        force: opts.force ?? false,
+      })
+    }
+
+    return result
+  }
+
+  private async runStop(task: BackgroundTask, opts: StopOptions): Promise<StopResult> {
+    if (task.kind === "draining_stream") {
+      await this.strategies.closeStream?.(task)
+      this.unregister(task.id)
+      return { ok: true, method: "close" }
+    }
+    if (task.kind === "terminal_pty") {
+      await this.strategies.killPty?.(task)
+      this.unregister(task.id)
+      return { ok: true, method: "close" }
+    }
+    if (task.kind === "codex_session") {
+      await this.strategies.shutdownCodex?.(task)
+      this.unregister(task.id)
+      return { ok: true, method: "shutdown" }
+    }
+
+    // bash_shell: signal lifecycle with PID-reuse guard
+    if (task.pid == null) return { ok: false, error: "no pid recorded" }
+
+    const commOk = await verifyComm(task.pid, task.command)
+    if (!commOk) {
+      this.unregister(task.id)
+      return { ok: false, error: "PID mismatch (process reused)" }
+    }
+
+    if (opts.force) {
+      this.update(task.id, { status: "stopping" })
+      await safeKill(task.pid, "SIGKILL")
+      this.unregister(task.id)
+      return { ok: true, method: "sigkill" }
+    }
+
+    // If the SDK provides a custom kill strategy, delegate to it.
+    if (this.strategies.killShell) {
+      this.update(task.id, { status: "stopping" })
+      await this.strategies.killShell(task)
+      this.unregister(task.id)
+      return { ok: true, method: "sigterm" }
+    }
+
+    this.update(task.id, { status: "stopping" })
+    await safeKill(task.pid, "SIGTERM")
+    const grace = opts.graceMs ?? 3000
+    const exited = await waitForExit(task.pid, grace)
+    if (exited) {
+      this.unregister(task.id)
+      return { ok: true, method: "sigterm" }
+    }
+    await safeKill(task.pid, "SIGKILL")
+    await waitForExit(task.pid, 1000)
+    this.unregister(task.id)
+    return { ok: true, method: "sigkill" }
+  }
+
+  private emit(event: RegistryEvent, task: BackgroundTask): void {
+    for (const cb of this.listeners[event]) cb(task)
+  }
+}

package/src/server/cli-runtime.test.ts

@@ -1,9 +1,14 @@
-import { afterEach, describe, expect, test } from "bun:test"
+import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 import { compareVersions, classifyInstallVersionFailure, parseArgs, runCli } from "./cli-runtime"
 import { CLI_SUPPRESS_OPEN_ONCE_ENV_VAR } from "./restart"
 
 const originalRuntimeProfile = process.env.KANNA_RUNTIME_PROFILE
 const originalSuppressOpen = process.env[CLI_SUPPRESS_OPEN_ONCE_ENV_VAR]
+const originalDisableSelfUpdate = process.env.KANNA_DISABLE_SELF_UPDATE
+
+beforeEach(() => {
+  delete process.env.KANNA_DISABLE_SELF_UPDATE
+})
 
 afterEach(() => {
   if (originalRuntimeProfile === undefined) {
@@ -16,6 +21,11 @@ afterEach(() => {
   } else {
     process.env[CLI_SUPPRESS_OPEN_ONCE_ENV_VAR] = originalSuppressOpen
   }
+  if (originalDisableSelfUpdate === undefined) {
+    delete process.env.KANNA_DISABLE_SELF_UPDATE
+  } else {
+    process.env.KANNA_DISABLE_SELF_UPDATE = originalDisableSelfUpdate
+  }
 })
 
 function createDeps(overrides: Partial<Parameters<typeof runCli>[1]> = {}) {
@@ -277,6 +287,7 @@ describe("runCli", () => {
   test("starts normally when no newer version exists", async () => {
     const { calls, deps } = createDeps()
     process.env.KANNA_RUNTIME_PROFILE = "prod"
+    delete process.env.KANNA_DISABLE_SELF_UPDATE
 
     const result = await runCli(["--port", "4000", "--no-open"], deps)
 
@@ -468,6 +479,7 @@ describe("runCli", () => {
   })
 
   test("returns restarting when a newer version is available", async () => {
+    delete process.env.KANNA_DISABLE_SELF_UPDATE
     const { calls, deps } = createDeps({
       fetchLatestVersion: async (packageName) => {
         calls.fetchLatestVersion.push(packageName)
@@ -483,6 +495,7 @@ describe("runCli", () => {
   })
 
   test("falls back to current version when install fails", async () => {
+    delete process.env.KANNA_DISABLE_SELF_UPDATE
     const { calls, deps } = createDeps({
       fetchLatestVersion: async (packageName) => {
         calls.fetchLatestVersion.push(packageName)
@@ -507,6 +520,7 @@ describe("runCli", () => {
   })
 
   test("falls back to current version when the registry check fails", async () => {
+    delete process.env.KANNA_DISABLE_SELF_UPDATE
     const { calls, deps } = createDeps({
       fetchLatestVersion: async (packageName) => {
         calls.fetchLatestVersion.push(packageName)

package/src/server/cloudflare-tunnel/e2e.test.ts

@@ -51,6 +51,7 @@ describe("cloudflare tunnel e2e", () => {
   let gateway: TunnelGateway
   let pendingChildren: FakeChild[]
   let broadcasts: string[]
+  let pendingWrites: Promise<void>[]
 
   beforeEach(async () => {
     dataDir = await mkdtemp(join(tmpdir(), "kanna-tunnel-e2e-"))
@@ -70,6 +71,7 @@ describe("cloudflare tunnel e2e", () => {
 
     pendingChildren = []
     broadcasts = []
+    pendingWrites = []
 
     manager = new TunnelManager({
       cloudflaredPath: "cloudflared",
@@ -79,7 +81,7 @@ describe("cloudflare tunnel e2e", () => {
         return child
       },
       onEvent: (event: CloudflareTunnelEvent) => {
-        void store.appendTunnelEvent(event)
+        pendingWrites.push(store.appendTunnelEvent(event))
         broadcasts.push(event.chatId)
       },
     })
@@ -102,6 +104,7 @@ describe("cloudflare tunnel e2e", () => {
   afterEach(async () => {
     gateway.shutdown()
     appSettings.dispose()
+    await Promise.all(pendingWrites)
     await rm(dataDir, { recursive: true, force: true })
   })
 

package/src/server/codex-app-server.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test"
 import { EventEmitter } from "node:events"
 import { PassThrough } from "node:stream"
 import { CodexAppServerManager } from "./codex-app-server"
+import { BackgroundTaskRegistry } from "./background-tasks"
 
 class FakeCodexProcess extends EventEmitter {
   readonly stdin = new PassThrough()
@@ -1813,4 +1814,72 @@ describe("CodexAppServerManager", () => {
     expect(resultEvent?.entry.subtype).toBe("error")
     expect(resultEvent?.entry.result).toContain("fatal: app-server crashed")
   })
+
+  test("registers codex_session entry in BackgroundTaskRegistry on startSession", async () => {
+    const fakeProcess = new FakeCodexProcess((message, child) => {
+      if (message.method === "initialize") {
+        child.writeServerMessage({ id: message.id, result: { userAgent: "codex-test" } })
+      } else if (message.method === "thread/start") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { thread: { id: "thread-reg-1" }, model: "gpt-5.4", reasoningEffort: "high" },
+        })
+      }
+    })
+
+    const registry = new BackgroundTaskRegistry()
+    const manager = new CodexAppServerManager({
+      spawnProcess: () => fakeProcess as never,
+      backgroundTasks: registry,
+    })
+
+    await manager.startSession({
+      chatId: "chat-reg-1",
+      cwd: "/tmp/project",
+      model: "gpt-5.4",
+      sessionToken: null,
+    })
+
+    const tasks = registry.list()
+    const task = tasks.find((t) => t.id === "codex:chat-reg-1")
+    expect(task).toBeDefined()
+    expect(task?.kind).toBe("codex_session")
+    if (task?.kind === "codex_session") {
+      expect(task.chatId).toBe("chat-reg-1")
+      expect(task.pid).toBeNull()
+      expect(typeof task.startedAt).toBe("number")
+    }
+  })
+
+  test("unregisters codex_session entry from BackgroundTaskRegistry on stopSession", async () => {
+    const fakeProcess = new FakeCodexProcess((message, child) => {
+      if (message.method === "initialize") {
+        child.writeServerMessage({ id: message.id, result: { userAgent: "codex-test" } })
+      } else if (message.method === "thread/start") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { thread: { id: "thread-reg-2" }, model: "gpt-5.4", reasoningEffort: "high" },
+        })
+      }
+    })
+
+    const registry = new BackgroundTaskRegistry()
+    const manager = new CodexAppServerManager({
+      spawnProcess: () => fakeProcess as never,
+      backgroundTasks: registry,
+    })
+
+    await manager.startSession({
+      chatId: "chat-reg-2",
+      cwd: "/tmp/project",
+      model: "gpt-5.4",
+      sessionToken: null,
+    })
+
+    expect(registry.list().find((t) => t.id === "codex:chat-reg-2")).toBeDefined()
+
+    manager.stopSession("chat-reg-2")
+
+    expect(registry.list().find((t) => t.id === "codex:chat-reg-2")).toBeUndefined()
+  })
 })