@cuongtran001/kanna 0.39.2

package/src/server/auto-continue/read-model.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, test } from "bun:test"
+import { deriveChatSchedules } from "./read-model"
+import type { AutoContinueEvent } from "./events"
+
+function proposed(chatId: string, scheduleId: string, at = 1_000): AutoContinueEvent {
+  return {
+    v: 3,
+    kind: "auto_continue_proposed",
+    timestamp: at,
+    chatId,
+    scheduleId,
+    detectedAt: at,
+    resetAt: at + 10_000,
+    tz: "Asia/Saigon",
+
+  }
+}
+
+function accepted(chatId: string, scheduleId: string, at = 2_000, source: "user" | "auto_setting" = "user"): AutoContinueEvent {
+  return {
+    v: 3,
+    kind: "auto_continue_accepted",
+    timestamp: at,
+    chatId,
+    scheduleId,
+    scheduledAt: at + 10_000,
+    tz: "Asia/Saigon",
+    source,
+    resetAt: at + 10_000,
+    detectedAt: at,
+  }
+}
+
+describe("deriveChatSchedules", () => {
+  test("empty event list returns empty map + null live", () => {
+    const result = deriveChatSchedules([])
+    expect(result.schedules).toEqual({})
+    expect(result.liveScheduleId).toBeNull()
+  })
+
+  test("proposed event yields state=proposed with liveScheduleId set", () => {
+    const result = deriveChatSchedules([proposed("c1", "s1")])
+    expect(result.schedules["s1"].state).toBe("proposed")
+    expect(result.schedules["s1"].scheduledAt).toBeNull()
+    expect(result.liveScheduleId).toBe("s1")
+  })
+
+  test("accept after propose promotes to scheduled", () => {
+    const result = deriveChatSchedules([proposed("c1", "s1"), accepted("c1", "s1")])
+    expect(result.schedules["s1"].state).toBe("scheduled")
+    expect(result.schedules["s1"].scheduledAt).toBe(12_000)
+    expect(result.liveScheduleId).toBe("s1")
+  })
+
+  test("accept with source=auto_setting without prior proposed still produces scheduled", () => {
+    const result = deriveChatSchedules([accepted("c1", "s1", 1_500, "auto_setting")])
+    expect(result.schedules["s1"].state).toBe("scheduled")
+    expect(result.schedules["s1"].resetAt).toBe(11_500)
+    expect(result.liveScheduleId).toBe("s1")
+  })
+
+  test("cancelled schedule is terminal and not live", () => {
+    const result = deriveChatSchedules([
+      proposed("c1", "s1"),
+      accepted("c1", "s1"),
+      { v: 3, kind: "auto_continue_cancelled", timestamp: 3_000, chatId: "c1", scheduleId: "s1", reason: "user" },
+    ])
+    expect(result.schedules["s1"].state).toBe("cancelled")
+    expect(result.liveScheduleId).toBeNull()
+  })
+
+  test("fired schedule is terminal and retains scheduledAt", () => {
+    const result = deriveChatSchedules([
+      proposed("c1", "s1"),
+      accepted("c1", "s1"),
+      { v: 3, kind: "auto_continue_fired", timestamp: 12_000, chatId: "c1", scheduleId: "s1" },
+    ])
+    expect(result.schedules["s1"].state).toBe("fired")
+    expect(result.schedules["s1"].scheduledAt).toBe(12_000)
+    expect(result.liveScheduleId).toBeNull()
+  })
+
+  test("live schedule tracks most recent non-terminal", () => {
+    const result = deriveChatSchedules([
+      proposed("c1", "s1", 1_000),
+      { v: 3, kind: "auto_continue_cancelled", timestamp: 1_100, chatId: "c1", scheduleId: "s1", reason: "user" },
+      proposed("c1", "s2", 2_000),
+    ])
+    expect(result.schedules["s1"].state).toBe("cancelled")
+    expect(result.schedules["s2"].state).toBe("proposed")
+    expect(result.liveScheduleId).toBe("s2")
+  })
+
+  test("reschedule updates scheduledAt without changing state", () => {
+    const result = deriveChatSchedules([
+      proposed("c1", "s1"),
+      accepted("c1", "s1"),
+      { v: 3, kind: "auto_continue_rescheduled", timestamp: 2_500, chatId: "c1", scheduleId: "s1", scheduledAt: 20_000 },
+    ])
+    expect(result.schedules["s1"].state).toBe("scheduled")
+    expect(result.schedules["s1"].scheduledAt).toBe(20_000)
+  })
+
+  test("events for different chats produce independent results", () => {
+    const events = [proposed("c1", "s1"), proposed("c2", "s2")]
+    expect(deriveChatSchedules(events, "c1").liveScheduleId).toBe("s1")
+    expect(deriveChatSchedules(events, "c2").liveScheduleId).toBe("s2")
+  })
+})

package/src/server/auto-continue/read-model.ts

@@ -0,0 +1,83 @@
+import type { AutoContinueSchedule } from "../../shared/types"
+import type { AutoContinueEvent } from "./events"
+
+export interface ChatSchedulesProjection {
+  schedules: Record<string, AutoContinueSchedule>
+  liveScheduleId: string | null
+}
+
+const EMPTY: ChatSchedulesProjection = { schedules: {}, liveScheduleId: null }
+
+export function deriveChatSchedules(
+  events: readonly AutoContinueEvent[],
+  chatId?: string
+): ChatSchedulesProjection {
+  const schedules: Record<string, AutoContinueSchedule> = {}
+  let liveScheduleId: string | null = null
+  for (const event of events) {
+    if (chatId && event.chatId !== chatId) continue
+    applyOne(schedules, event)
+    const schedule = schedules[event.scheduleId]
+    if (schedule && (schedule.state === "proposed" || schedule.state === "scheduled")) {
+      liveScheduleId = schedule.scheduleId
+    } else if (liveScheduleId === event.scheduleId) {
+      liveScheduleId = null
+    }
+  }
+
+  if (Object.keys(schedules).length === 0 && liveScheduleId === null) return EMPTY
+  return { schedules, liveScheduleId }
+}
+
+function applyOne(schedules: Record<string, AutoContinueSchedule>, event: AutoContinueEvent): void {
+  switch (event.kind) {
+    case "auto_continue_proposed":
+      schedules[event.scheduleId] = {
+        scheduleId: event.scheduleId,
+        state: "proposed",
+        scheduledAt: null,
+        tz: event.tz,
+        resetAt: event.resetAt,
+        detectedAt: event.detectedAt,
+      }
+      return
+    case "auto_continue_accepted":
+      schedules[event.scheduleId] = {
+        scheduleId: event.scheduleId,
+        state: "scheduled",
+        scheduledAt: event.scheduledAt,
+        tz: event.tz,
+        resetAt: event.resetAt,
+        detectedAt: event.detectedAt,
+      }
+      return
+    case "auto_continue_rescheduled": {
+      const existing = schedules[event.scheduleId]
+      if (!existing) return
+      schedules[event.scheduleId] = { ...existing, scheduledAt: event.scheduledAt }
+      return
+    }
+    case "auto_continue_cancelled": {
+      const existing = schedules[event.scheduleId]
+      if (!existing) return
+      schedules[event.scheduleId] = { ...existing, state: "cancelled" }
+      return
+    }
+    case "auto_continue_fired": {
+      const existing = schedules[event.scheduleId]
+      if (!existing) {
+        schedules[event.scheduleId] = {
+          scheduleId: event.scheduleId,
+          state: "fired",
+          scheduledAt: event.timestamp,
+          tz: "system",
+          resetAt: event.timestamp,
+          detectedAt: event.timestamp,
+        }
+        return
+      }
+      schedules[event.scheduleId] = { ...existing, state: "fired", scheduledAt: event.timestamp }
+      return
+    }
+  }
+}

package/src/server/auto-continue/schedule-manager.test.ts

@@ -0,0 +1,155 @@
+import { describe, expect, test } from "bun:test"
+import { ScheduleManager, type Clock } from "./schedule-manager"
+import type { AutoContinueEvent } from "./events"
+
+class FakeClock implements Clock {
+  private current = 0
+  private scheduled: Array<{ fireAt: number; fn: () => void; id: number }> = []
+  private nextId = 1
+
+  now() {
+    return this.current
+  }
+
+  setTimeout(fn: () => void, delayMs: number): number {
+    const id = this.nextId
+    this.nextId += 1
+    this.scheduled.push({ fireAt: this.current + Math.max(0, delayMs), fn, id })
+    return id
+  }
+
+  clearTimeout(id: number): void {
+    this.scheduled = this.scheduled.filter((entry) => entry.id !== id)
+  }
+
+  advance(ms: number) {
+    this.current += ms
+    const due = this.scheduled.filter((entry) => entry.fireAt <= this.current)
+    this.scheduled = this.scheduled.filter((entry) => entry.fireAt > this.current)
+    for (const { fn } of due) fn()
+  }
+
+  pending() {
+    return this.scheduled.length
+  }
+}
+
+function event(kind: AutoContinueEvent["kind"], overrides: Partial<AutoContinueEvent> = {}): AutoContinueEvent {
+  const base = { v: 3 as const, timestamp: 0, chatId: "c1", scheduleId: "s1" }
+  switch (kind) {
+    case "auto_continue_proposed":
+      return { ...base, kind, detectedAt: 0, resetAt: 1_000, tz: "UTC", ...overrides } as AutoContinueEvent
+    case "auto_continue_accepted":
+      return { ...base, kind, scheduledAt: 1_000, tz: "UTC", source: "user", resetAt: 1_000, detectedAt: 0, ...overrides } as AutoContinueEvent
+    case "auto_continue_rescheduled":
+      return { ...base, kind, scheduledAt: 2_000, ...overrides } as AutoContinueEvent
+    case "auto_continue_cancelled":
+      return { ...base, kind, reason: "user", ...overrides } as AutoContinueEvent
+    case "auto_continue_fired":
+      return { ...base, kind, ...overrides } as AutoContinueEvent
+  }
+}
+
+describe("ScheduleManager", () => {
+  test("proposed event does not arm a timer", () => {
+    const clock = new FakeClock()
+    const fired: string[] = []
+    const manager = new ScheduleManager({
+      clock,
+      fire: async (chatId, scheduleId) => { fired.push(`${chatId}:${scheduleId}`) },
+    })
+    manager.onEvent(event("auto_continue_proposed"))
+    expect(clock.pending()).toBe(0)
+    expect(fired).toEqual([])
+  })
+
+  test("accepted event arms a timer that fires at scheduledAt", () => {
+    const clock = new FakeClock()
+    const fired: string[] = []
+    const manager = new ScheduleManager({
+      clock,
+      fire: async (chatId, scheduleId) => { fired.push(`${chatId}:${scheduleId}`) },
+    })
+    manager.onEvent(event("auto_continue_accepted", { scheduledAt: 1_000 }))
+    expect(clock.pending()).toBe(1)
+    clock.advance(1_000)
+    expect(fired).toEqual(["c1:s1"])
+  })
+
+  test("rescheduled replaces the pending timer", () => {
+    const clock = new FakeClock()
+    const fired: string[] = []
+    const manager = new ScheduleManager({
+      clock,
+      fire: async (_, id) => { fired.push(id) },
+    })
+    manager.onEvent(event("auto_continue_accepted", { scheduledAt: 1_000 }))
+    manager.onEvent(event("auto_continue_rescheduled", { scheduledAt: 3_000 }))
+    clock.advance(1_000)
+    expect(fired).toEqual([])
+    clock.advance(2_000)
+    expect(fired).toEqual(["s1"])
+  })
+
+  test("cancelled clears the pending timer", () => {
+    const clock = new FakeClock()
+    const fired: string[] = []
+    const manager = new ScheduleManager({
+      clock,
+      fire: async (_, id) => { fired.push(id) },
+    })
+    manager.onEvent(event("auto_continue_accepted", { scheduledAt: 1_000 }))
+    manager.onEvent(event("auto_continue_cancelled"))
+    clock.advance(1_000)
+    expect(fired).toEqual([])
+  })
+
+  test("rehydrate arms future schedules and fires past-due ones", async () => {
+    const clock = new FakeClock()
+    clock.advance(5_000)
+    const fired: string[] = []
+    const manager = new ScheduleManager({
+      clock,
+      fire: async (_, id) => { fired.push(id) },
+    })
+    manager.rehydrate([
+      event("auto_continue_accepted", { scheduleId: "past", scheduledAt: 1_000 }),
+      event("auto_continue_accepted", { scheduleId: "future", scheduledAt: 10_000 }),
+    ])
+    await Promise.resolve()
+    expect(fired).toEqual(["past"])
+    expect(clock.pending()).toBe(1)
+    clock.advance(5_000)
+    expect(fired).toEqual(["past", "future"])
+  })
+
+  test("rehydrate skips terminal states", () => {
+    const clock = new FakeClock()
+    const fired: string[] = []
+    const manager = new ScheduleManager({
+      clock,
+      fire: async (_, id) => { fired.push(id) },
+    })
+    manager.rehydrate([
+      event("auto_continue_accepted", { scheduleId: "done", scheduledAt: 1_000 }),
+      event("auto_continue_fired", { scheduleId: "done" }),
+      event("auto_continue_accepted", { scheduleId: "cancelled", scheduledAt: 1_000 }),
+      event("auto_continue_cancelled", { scheduleId: "cancelled" }),
+    ])
+    clock.advance(10_000)
+    expect(fired).toEqual([])
+  })
+
+  test("firing a timer does not double-fire on subsequent events", () => {
+    const clock = new FakeClock()
+    const fired: string[] = []
+    const manager = new ScheduleManager({
+      clock,
+      fire: async (_, id) => { fired.push(id) },
+    })
+    manager.onEvent(event("auto_continue_accepted", { scheduledAt: 1_000 }))
+    clock.advance(1_000)
+    manager.onEvent(event("auto_continue_fired"))
+    expect(fired).toEqual(["s1"])
+  })
+})

package/src/server/auto-continue/schedule-manager.ts

@@ -0,0 +1,116 @@
+import type { AutoContinueEvent } from "./events"
+import { deriveChatSchedules } from "./read-model"
+
+export interface Clock {
+  now(): number
+  setTimeout(fn: () => void, delayMs: number): number
+  clearTimeout(id: number): void
+}
+
+export const realClock: Clock = {
+  now: () => Date.now(),
+  setTimeout: (fn, delayMs) => setTimeout(fn, delayMs) as unknown as number,
+  clearTimeout: (id) => clearTimeout(id as unknown as NodeJS.Timeout),
+}
+
+export interface ScheduleManagerArgs {
+  clock?: Clock
+  fire: (chatId: string, scheduleId: string) => Promise<void>
+  onError?: (error: unknown) => void
+}
+
+export class ScheduleManager {
+  private readonly clock: Clock
+  private readonly fireFn: ScheduleManagerArgs["fire"]
+  private readonly onError: (error: unknown) => void
+  private readonly timers = new Map<string, number>()
+  private readonly pendingByScheduleId = new Map<string, { chatId: string; scheduledAt: number }>()
+
+  constructor(args: ScheduleManagerArgs) {
+    this.clock = args.clock ?? realClock
+    this.fireFn = args.fire
+    this.onError = args.onError ?? ((error) => console.error("[kanna/schedule-manager]", error))
+  }
+
+  rehydrate(events: readonly AutoContinueEvent[]) {
+    const byChat = new Map<string, AutoContinueEvent[]>()
+    for (const event of events) {
+      const list = byChat.get(event.chatId) ?? []
+      list.push(event)
+      byChat.set(event.chatId, list)
+    }
+    for (const [chatId, chatEvents] of byChat.entries()) {
+      const projection = deriveChatSchedules(chatEvents, chatId)
+      for (const schedule of Object.values(projection.schedules)) {
+        if (schedule.state !== "scheduled") continue
+        if (schedule.scheduledAt === null) continue
+        this.arm(chatId, schedule.scheduleId, schedule.scheduledAt)
+      }
+    }
+  }
+
+  onEvent(event: AutoContinueEvent) {
+    switch (event.kind) {
+      case "auto_continue_proposed":
+        return
+      case "auto_continue_accepted":
+        this.arm(event.chatId, event.scheduleId, event.scheduledAt)
+        return
+      case "auto_continue_rescheduled":
+        this.arm(event.chatId, event.scheduleId, event.scheduledAt)
+        return
+      case "auto_continue_cancelled":
+      case "auto_continue_fired":
+        this.clear(event.scheduleId)
+        return
+      default: {
+        const _exhaustive: never = event
+        void _exhaustive
+        return
+      }
+    }
+  }
+
+  private arm(chatId: string, scheduleId: string, scheduledAt: number) {
+    this.clear(scheduleId)
+    this.pendingByScheduleId.set(scheduleId, { chatId, scheduledAt })
+    const delay = scheduledAt - this.clock.now()
+
+    const run = async () => {
+      this.timers.delete(scheduleId)
+      this.pendingByScheduleId.delete(scheduleId)
+      try {
+        await this.fireFn(chatId, scheduleId)
+      } catch (error) {
+        this.onError(error)
+      }
+    }
+
+    // Past-due schedules fire out-of-band via microtask rather than clock.setTimeout.
+    // This keeps clock.pending() reflecting only genuinely future timers.
+    if (delay <= 0) {
+      void Promise.resolve().then(run)
+      return
+    }
+
+    const timerId = this.clock.setTimeout(() => { void run() }, delay)
+    this.timers.set(scheduleId, timerId)
+  }
+
+  private clear(scheduleId: string) {
+    const timerId = this.timers.get(scheduleId)
+    if (timerId !== undefined) {
+      this.clock.clearTimeout(timerId)
+      this.timers.delete(scheduleId)
+    }
+    this.pendingByScheduleId.delete(scheduleId)
+  }
+
+  shutdown() {
+    for (const timerId of this.timers.values()) {
+      this.clock.clearTimeout(timerId)
+    }
+    this.timers.clear()
+    this.pendingByScheduleId.clear()
+  }
+}

package/src/server/claude-session-importer.test.ts

@@ -0,0 +1,214 @@
+import { describe, expect, test } from "bun:test"
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { EventStore } from "./event-store"
+import { importClaudeSessions } from "./claude-session-importer"
+
+function fresh() {
+  const dataDir = mkdtempSync(path.join(tmpdir(), "kanna-data-"))
+  const homeDir = mkdtempSync(path.join(tmpdir(), "kanna-home-"))
+  const realProj = mkdtempSync(path.join(tmpdir(), "kanna-proj-"))
+  return {
+    dataDir,
+    homeDir,
+    realProj,
+    cleanup: () => {
+      rmSync(dataDir, { recursive: true, force: true })
+      rmSync(homeDir, { recursive: true, force: true })
+      rmSync(realProj, { recursive: true, force: true })
+    },
+  }
+}
+
+function seedSession(homeDir: string, realProj: string, sessionId: string) {
+  const folderName = realProj.replace(/\//g, "-")
+  const projDir = path.join(homeDir, ".claude", "projects", folderName)
+  mkdirSync(projDir, { recursive: true })
+  const line1 = JSON.stringify({
+    type: "user",
+    uuid: "u1",
+    sessionId,
+    cwd: realProj,
+    timestamp: "2026-04-20T10:00:00.000Z",
+    message: { role: "user", content: "hi" },
+  })
+  const line2 = JSON.stringify({
+    type: "assistant",
+    uuid: "a1",
+    sessionId,
+    cwd: realProj,
+    timestamp: "2026-04-20T10:00:01.000Z",
+    message: { role: "assistant", id: "m1", content: [{ type: "text", text: "hello" }] },
+  })
+  writeFileSync(path.join(projDir, `${sessionId}.jsonl`), `${line1}\n${line2}\n`, "utf8")
+}
+
+describe("importClaudeSessions", () => {
+  test("imports a session, creating project + chat + messages", async () => {
+    const ctx = fresh()
+    try {
+      seedSession(ctx.homeDir, ctx.realProj, "sess-aaa")
+      const store = new EventStore(ctx.dataDir)
+      await store.initialize()
+
+      const result = await importClaudeSessions({ store, homeDir: ctx.homeDir })
+
+      expect(result.imported).toBe(1)
+      expect(result.skipped).toBe(0)
+      expect(result.failed).toBe(0)
+
+      const chats = [...store.state.chatsById.values()].filter((c) => !c.deletedAt)
+      expect(chats.length).toBe(1)
+      expect(chats[0].sessionToken).toBe("sess-aaa")
+      expect(chats[0].provider).toBe("claude")
+      expect(store.getMessages(chats[0].id).length).toBe(2)
+    } finally {
+      ctx.cleanup()
+    }
+  })
+
+  test("re-import is a no-op (dedup by sessionToken)", async () => {
+    const ctx = fresh()
+    try {
+      seedSession(ctx.homeDir, ctx.realProj, "sess-bbb")
+      const store = new EventStore(ctx.dataDir)
+      await store.initialize()
+
+      await importClaudeSessions({ store, homeDir: ctx.homeDir })
+      const second = await importClaudeSessions({ store, homeDir: ctx.homeDir })
+
+      expect(second.imported).toBe(0)
+      expect(second.skipped).toBe(1)
+    } finally {
+      ctx.cleanup()
+    }
+  })
+
+  test("skips session whose cwd no longer exists", async () => {
+    const ctx = fresh()
+    try {
+      seedSession(ctx.homeDir, ctx.realProj, "sess-ccc")
+      rmSync(ctx.realProj, { recursive: true, force: true })
+      const store = new EventStore(ctx.dataDir)
+      await store.initialize()
+
+      const result = await importClaudeSessions({ store, homeDir: ctx.homeDir })
+      expect(result.imported).toBe(0)
+      expect(result.failed).toBe(1)
+    } finally {
+      ctx.cleanup()
+    }
+  })
+
+  test("derives title from array-form user text", async () => {
+    const ctx = fresh()
+    try {
+      const folderName = ctx.realProj.replace(/\//g, "-")
+      const projDir = path.join(ctx.homeDir, ".claude", "projects", folderName)
+      mkdirSync(projDir, { recursive: true })
+      const line = JSON.stringify({
+        type: "user",
+        uuid: "u1",
+        sessionId: "sess-array",
+        cwd: ctx.realProj,
+        timestamp: "2026-04-20T10:00:00.000Z",
+        message: {
+          role: "user",
+          content: [{ type: "text", text: "analyse this repo" }],
+        },
+      })
+      const line2 = JSON.stringify({
+        type: "assistant",
+        uuid: "a1",
+        sessionId: "sess-array",
+        cwd: ctx.realProj,
+        timestamp: "2026-04-20T10:00:01.000Z",
+        message: { role: "assistant", id: "m1", content: [{ type: "text", text: "sure" }] },
+      })
+      writeFileSync(path.join(projDir, "sess-array.jsonl"), `${line}\n${line2}\n`, "utf8")
+
+      const store = new EventStore(ctx.dataDir)
+      await store.initialize()
+      const result = await importClaudeSessions({ store, homeDir: ctx.homeDir })
+      expect(result.imported).toBe(1)
+
+      const chats = [...store.state.chatsById.values()].filter((c) => !c.deletedAt)
+      expect(chats.length).toBe(1)
+      expect(chats[0].title).toBe("analyse this repo")
+    } finally {
+      ctx.cleanup()
+    }
+  })
+
+  test("re-import with unchanged file is skipped (hash match)", async () => {
+    const ctx = fresh()
+    try {
+      seedSession(ctx.homeDir, ctx.realProj, "sess-hash-1")
+      const store = new EventStore(ctx.dataDir)
+      await store.initialize()
+
+      const first = await importClaudeSessions({ store, homeDir: ctx.homeDir })
+      expect(first.imported).toBe(1)
+
+      const second = await importClaudeSessions({ store, homeDir: ctx.homeDir })
+      expect(second.imported).toBe(0)
+      expect(second.updated).toBe(0)
+      expect(second.skipped).toBe(1)
+    } finally {
+      ctx.cleanup()
+    }
+  })
+
+  test("re-import after JSONL grows appends new messages and counts as updated", async () => {
+    const ctx = fresh()
+    try {
+      const folderName = ctx.realProj.replace(/\//g, "-")
+      const projDir = path.join(ctx.homeDir, ".claude", "projects", folderName)
+      mkdirSync(projDir, { recursive: true })
+      const jsonlPath = path.join(projDir, "sess-grow.jsonl")
+
+      const line1 = JSON.stringify({
+        type: "user", uuid: "u1", sessionId: "sess-grow", cwd: ctx.realProj,
+        timestamp: "2026-04-20T10:00:00.000Z",
+        message: { role: "user", content: "first" },
+      })
+      const line2 = JSON.stringify({
+        type: "assistant", uuid: "a1", sessionId: "sess-grow", cwd: ctx.realProj,
+        timestamp: "2026-04-20T10:00:01.000Z",
+        message: { role: "assistant", id: "m1", content: [{ type: "text", text: "hello" }] },
+      })
+      writeFileSync(jsonlPath, `${line1}\n${line2}\n`, "utf8")
+
+      const store = new EventStore(ctx.dataDir)
+      await store.initialize()
+
+      const first = await importClaudeSessions({ store, homeDir: ctx.homeDir })
+      expect(first.imported).toBe(1)
+      const chats = [...store.state.chatsById.values()].filter((c) => !c.deletedAt)
+      expect(chats.length).toBe(1)
+      expect(store.getMessages(chats[0].id).length).toBe(2)
+
+      // append a new turn
+      const line3 = JSON.stringify({
+        type: "user", uuid: "u2", sessionId: "sess-grow", cwd: ctx.realProj,
+        timestamp: "2026-04-20T10:00:02.000Z",
+        message: { role: "user", content: "second" },
+      })
+      const line4 = JSON.stringify({
+        type: "assistant", uuid: "a2", sessionId: "sess-grow", cwd: ctx.realProj,
+        timestamp: "2026-04-20T10:00:03.000Z",
+        message: { role: "assistant", id: "m2", content: [{ type: "text", text: "world" }] },
+      })
+      writeFileSync(jsonlPath, `${line1}\n${line2}\n${line3}\n${line4}\n`, "utf8")
+
+      const second = await importClaudeSessions({ store, homeDir: ctx.homeDir })
+      expect(second.imported).toBe(0)
+      expect(second.updated).toBe(1)
+      expect(second.skipped).toBe(0)
+      expect(store.getMessages(chats[0].id).length).toBe(4)
+    } finally {
+      ctx.cleanup()
+    }
+  })
+})