Skip to content

LLM Wiki is a cross-platform desktop application that turns your documents into an organized, interlinked knowledge base — automatically. Instead of traditional RAG (retrieve-and-answer from scratch every time), the LLM incrementally builds and maintains a persistent wiki from your sources。

TypeScript
56.5 KB
Raw Blame
import { describe, it, expect, beforeEach, vi } from "vitest"
import { createDeferred, flushMicrotasks, waitFor } from "@/test-helpers/deferred"

// Mock autoIngest so tests control success/failure timing.
vi.mock("./ingest", () => ({
  autoIngest: vi.fn(),
}))

// Mock fs so we don't hit the real filesystem.
vi.mock("@/commands/fs", () => ({
  readFile: vi.fn(),
  writeFile: vi.fn(),
  listDirectory: vi.fn(),
  deleteFile: vi.fn(),
}))

// Mock sweep-reviews since the queue drain dynamically imports it. The
// sweep itself has its own test file; here we just confirm it's triggered.
vi.mock("./sweep-reviews", () => ({
  sweepResolvedReviews: vi.fn().mockResolvedValue(0),
}))

// Mock the centralized page cascade used by cleanupWrittenFiles.
const cascadeDeleteWikiPageMock = vi.fn<(projectPath: string, filePath: string) => Promise<void>>(
  async () => {},
)
vi.mock("@/lib/wiki-page-delete", () => ({
  cascadeDeleteWikiPage: (projectPath: string, filePath: string) =>
    cascadeDeleteWikiPageMock(projectPath, filePath),
}))

// Mock project-identity — tests don't hit Tauri plugin-store. Maps the
// test UUIDs defined below back to their assigned paths.
const TEST_ID = "test-project-uuid"
const TEST_PATH = "/project"
const TEST_ID_B = "test-project-uuid-b"
const TEST_PATH_B = "/project-b"
const idToPath: Record<string, string> = {
  [TEST_ID]: TEST_PATH,
  [TEST_ID_B]: TEST_PATH_B,
}
vi.mock("@/lib/project-identity", () => ({
  ensureProjectId: vi.fn(),
  upsertProjectInfo: vi.fn(),
  getProjectPathById: vi.fn(async (id: string) => idToPath[id] ?? null),
  getProjectIdByPath: vi.fn(),
  loadRegistry: vi.fn(),
}))

import {
  enqueueIngest,
  enqueueBatch,
  enqueueInactiveProjectBatch,
  discardInactiveProjectTasksForSources,
  retryTask,
  retryTasks,
  retryAllFailedTasks,
  cancelTask,
  cancelTasks,
  removeTask,
  removeTasks,
  hasActiveRun,
  retainQueuedSelection,
  discardTasksForSources,
  cancelAllTasks,
  movePendingTask,
  clearCompletedTasks,
  clearQueueState,
  cleanupWrittenFiles,
  getQueue,
  getQueueSummary,
  restoreQueue,
  pauseProcessing,
  resumeProcessing,
  isQueuePaused,
  setIngestWorkerLimit,
  getIngestWorkerLimit,
  subscribeIngestQueue,
} from "./ingest-queue"
import { autoIngest } from "./ingest"
import { deleteFile, readFile, writeFile } from "@/commands/fs"
import { sweepResolvedReviews } from "./sweep-reviews"
import { useWikiStore } from "@/stores/wiki-store"

const mockAutoIngest = vi.mocked(autoIngest)
const mockReadFile = vi.mocked(readFile)
const mockWriteFile = vi.mocked(writeFile)
const mockDeleteFile = vi.mocked(deleteFile)
const mockSweep = vi.mocked(sweepResolvedReviews)

/** Simulate the app having opened `TEST_ID` at `TEST_PATH` so the queue
 *  module's `currentProjectId` / `currentProjectPath` are set. Most
 *  tests need this — enqueue / retry / cancel guard against inactive
 *  projects. */
async function activateProject(id: string = TEST_ID): Promise<void> {
  await restoreQueue(id, idToPath[id])
}

beforeEach(async () => {
  clearQueueState()
  mockAutoIngest.mockReset()
  mockReadFile.mockReset()
  mockWriteFile.mockReset()
  mockDeleteFile.mockReset()
  mockDeleteFile.mockResolvedValue(undefined as unknown as void)
  mockSweep.mockReset()
  mockSweep.mockResolvedValue(0)
  cascadeDeleteWikiPageMock.mockReset()
  cascadeDeleteWikiPageMock.mockImplementation(async (_projectPath, filePath) => {
    const { deleteFile } = await import("@/commands/fs")
    await deleteFile(filePath)
  })

  // Default: persisted queue file doesn't exist
  mockReadFile.mockRejectedValue(new Error("ENOENT"))
  mockWriteFile.mockResolvedValue(undefined as unknown as void)

  // Default: a valid LLM config so processNext doesn't reject.
  useWikiStore.getState().setLlmConfig({
    provider: "openai",
    apiKey: "test-key",
    model: "gpt-4",
    ollamaUrl: "",
    customEndpoint: "",
    maxContextSize: 128000,
  })

  await activateProject()
})

describe("ingest-queue — enqueue & basic processing", () => {
  it("pushes queue snapshots only while a subscriber is active", async () => {
    const run = createDeferred<string[]>()
    mockAutoIngest.mockReturnValue(run.promise)
    const snapshots: string[][] = []
    const unsubscribe = subscribeIngestQueue((tasks) => {
      snapshots.push(tasks.map((task) => task.sourcePath))
    })

    await enqueueIngest(TEST_ID, "raw/sources/report.pdf")
    expect(snapshots.some((paths) => paths.includes("raw/sources/report.pdf"))).toBe(true)

    const countBeforeUnsubscribe = snapshots.length
    unsubscribe()
    clearQueueState()
    expect(snapshots).toHaveLength(countBeforeUnsubscribe)
    run.resolve([])
  })

  it("does not let a queue subscriber failure block persistence", async () => {
    mockAutoIngest.mockReturnValue(new Promise(() => {}))
    const unsubscribe = subscribeIngestQueue(() => {
      throw new Error("subscriber failed")
    })

    await expect(enqueueIngest(TEST_ID, "raw/sources/report.pdf")).resolves.toBeTypeOf("string")
    expect(mockWriteFile).toHaveBeenCalled()
    unsubscribe()
  })

  it("clamps the configurable worker limit", () => {
    setIngestWorkerLimit(0)
    expect(getIngestWorkerLimit()).toBe(1)
    setIngestWorkerLimit(99)
    expect(getIngestWorkerLimit()).toBe(64)
    setIngestWorkerLimit(2.9)
    expect(getIngestWorkerLimit()).toBe(2)
  })

  it("persists inactive-project tasks and starts them when that project opens", async () => {
    const ids = await enqueueInactiveProjectBatch(TEST_ID_B, TEST_PATH_B, [
      {
        sourcePath: `${TEST_PATH_B}/raw/sources/scheduled-import/report.pdf`,
        folderContext: "scheduled-import",
      },
    ])

    expect(ids).toHaveLength(1)
    const inactiveWrite = mockWriteFile.mock.calls.find(
      ([path]) => path === `${TEST_PATH_B}/.llm-wiki/ingest-queue.json`,
    )
    expect(inactiveWrite).toBeDefined()
    const persisted = JSON.parse(String(inactiveWrite?.[1])) as Array<{
      sourcePath: string
      status: string
    }>
    expect(persisted).toMatchObject([
      {
        sourcePath: "raw/sources/scheduled-import/report.pdf",
        status: "pending",
      },
    ])

    mockReadFile.mockImplementation(async (path: string) => {
      if (path === `${TEST_PATH_B}/.llm-wiki/ingest-queue.json`) {
        return String(inactiveWrite?.[1])
      }
      throw new Error("ENOENT")
    })
    mockAutoIngest.mockResolvedValue(["wiki/sources/report.md"])

    await restoreQueue(TEST_ID_B, TEST_PATH_B)
    await flushMicrotasks(20)

    expect(mockAutoIngest).toHaveBeenCalledWith(
      TEST_PATH_B,
      `${TEST_PATH_B}/raw/sources/scheduled-import/report.pdf`,
      expect.any(Object),
      expect.any(AbortSignal),
      "scheduled-import",
      expect.any(Function),
      expect.objectContaining({ runCommit: expect.any(Function) }),
    )
    expect(getQueue()).toHaveLength(0)
  })

  it("recovers the inactive-project write chain after a persistence failure", async () => {
    mockWriteFile
      .mockRejectedValueOnce(new Error("disk temporarily unavailable"))
      .mockResolvedValue(undefined as unknown as void)

    await expect(enqueueInactiveProjectBatch(TEST_ID_B, TEST_PATH_B, [
      { sourcePath: `${TEST_PATH_B}/raw/sources/first.pdf`, folderContext: "" },
    ])).rejects.toThrow("disk temporarily unavailable")

    await expect(enqueueInactiveProjectBatch(TEST_ID_B, TEST_PATH_B, [
      { sourcePath: `${TEST_PATH_B}/raw/sources/second.pdf`, folderContext: "" },
    ])).resolves.toHaveLength(1)
    expect(mockWriteFile).toHaveBeenLastCalledWith(
      `${TEST_PATH_B}/.llm-wiki/ingest-queue.json`,
      expect.stringContaining("raw/sources/second.pdf"),
    )
  })

  it("discards persisted tasks for deleted inactive-project sources", async () => {
    mockReadFile.mockImplementation(async (path: string) => {
      if (path === `${TEST_PATH_B}/.llm-wiki/ingest-queue.json`) {
        return JSON.stringify([
          {
            id: "remove-me",
            projectId: TEST_ID_B,
            sourcePath: "raw/sources/old.pdf",
            folderContext: "",
            status: "pending",
            addedAt: 1,
            error: null,
            retryCount: 0,
          },
          {
            id: "keep-me",
            projectId: TEST_ID_B,
            sourcePath: "raw/sources/current.pdf",
            folderContext: "",
            status: "pending",
            addedAt: 2,
            error: null,
            retryCount: 0,
          },
        ])
      }
      throw new Error("ENOENT")
    })

    await expect(discardInactiveProjectTasksForSources(
      TEST_ID_B,
      TEST_PATH_B,
      ["raw/sources/old.pdf"],
    )).resolves.toBe(1)

    const lastWrite = mockWriteFile.mock.calls[mockWriteFile.mock.calls.length - 1]
    const persisted = JSON.parse(String(lastWrite?.[1])) as Array<{
      id: string
    }>
    expect(persisted.map((task) => task.id)).toEqual(["keep-me"])
  })

  it("enqueueIngest adds a pending task and triggers processing", async () => {
    mockAutoIngest.mockResolvedValue(["wiki/sources/foo.md"])

    const id = await enqueueIngest(TEST_ID, "raw/sources/a.md")
    expect(id).toMatch(/^ingest-/)

    // Let the async processing loop run
    await flushMicrotasks(10)

    // Task should have been processed and removed
    expect(mockAutoIngest).toHaveBeenCalledOnce()
    expect(getQueue()).toHaveLength(0)
    expect(getQueueSummary()).toMatchObject({ completed: 1, total: 1 })
  })

  it("persists queue to disk on enqueue", async () => {
    mockAutoIngest.mockImplementation(() => new Promise(() => {})) // never resolves
    await enqueueIngest(TEST_ID, "a.md")
    await flushMicrotasks(2)

    // writeFile should have been called to save the queue
    const calls = mockWriteFile.mock.calls
    expect(calls.length).toBeGreaterThan(0)
    const queuePath = calls[0][0]
    expect(queuePath).toContain(".llm-wiki/ingest-queue.json")
  })

  it("enqueueBatch queues multiple tasks and processes them serially", async () => {
    mockAutoIngest.mockResolvedValue(["wiki/sources/foo.md"])

    await enqueueBatch(TEST_ID, [
      { sourcePath: "a.md", folderContext: "" },
      { sourcePath: "b.md", folderContext: "" },
      { sourcePath: "c.md", folderContext: "" },
    ])

    await flushMicrotasks(50)

    expect(mockAutoIngest).toHaveBeenCalledTimes(3)
    expect(getQueue()).toHaveLength(0)
  })
})

describe("ingest-queue — concurrent workers", () => {
  it("fills the configured worker pool without exceeding its limit", async () => {
    setIngestWorkerLimit(2)
    const runs = new Map<string, ReturnType<typeof createDeferred<string[]>>>()
    mockAutoIngest.mockImplementation((_projectPath, sourcePath) => {
      const deferred = createDeferred<string[]>()
      runs.set(sourcePath, deferred)
      return deferred.promise
    })

    await enqueueBatch(TEST_ID, [
      { sourcePath: "a.md", folderContext: "" },
      { sourcePath: "b.md", folderContext: "" },
      { sourcePath: "c.md", folderContext: "" },
    ])
    await waitFor(() => mockAutoIngest.mock.calls.length === 2)
    expect(getQueueSummary()).toMatchObject({ processing: 2, pending: 1 })

    const firstRun = [...runs.values()][0]
    expect(firstRun).toBeDefined()
    firstRun.resolve(["wiki/sources/a.md"])
    await waitFor(() => mockAutoIngest.mock.calls.length === 3)
    expect(getQueueSummary().processing).toBe(2)

    for (const deferred of runs.values()) {
      if (!deferred.settled) deferred.resolve(["wiki/sources/completed.md"])
    }
    await waitFor(() => getQueue().length === 0)
    expect(getQueueSummary()).toMatchObject({ completed: 3, processing: 0, pending: 0 })
  })

  it("cancels one active worker without aborting its sibling", async () => {
    setIngestWorkerLimit(2)
    const signals = new Map<string, AbortSignal>()
    const runs = new Map<string, ReturnType<typeof createDeferred<string[]>>>()
    mockAutoIngest.mockImplementation((_projectPath, sourcePath, _config, signal) => {
      const deferred = createDeferred<string[]>()
      signals.set(sourcePath, signal as AbortSignal)
      runs.set(sourcePath, deferred)
      signal?.addEventListener("abort", () => deferred.reject(new Error("aborted")))
      return deferred.promise
    })

    await enqueueBatch(TEST_ID, [
      { sourcePath: "a.md", folderContext: "" },
      { sourcePath: "b.md", folderContext: "" },
    ])
    await waitFor(() => mockAutoIngest.mock.calls.length === 2)
    const firstTask = getQueue().find((task) => task.sourcePath === "a.md")
    expect(firstTask).toBeDefined()
    await cancelTask(firstTask?.id ?? "")

    expect(signals.get(`${TEST_PATH}/a.md`)?.aborted).toBe(true)
    expect(signals.get(`${TEST_PATH}/b.md`)?.aborted).toBe(false)
    const siblingRun = [...runs.entries()].find(([path]) => path.endsWith("/b.md"))?.[1]
    expect(siblingRun).toBeDefined()
    siblingRun?.resolve(["wiki/sources/b.md"])
    await waitFor(() => getQueueSummary().processing === 0)
    expect(getQueue().find((task) => task.sourcePath === "a.md")?.status).toBe("cancelled")
  })

  it("does not delete merged pages when cancelling a worker", async () => {
    const finish = createDeferred<string[]>()
    mockAutoIngest.mockImplementation(
      async (_projectPath, _sourcePath, _config, _signal, _folder, onFileWritten) => {
        onFileWritten?.("wiki/concepts/existing.md")
        return finish.promise
      },
    )

    await enqueueIngest(TEST_ID, "cancel-during-write.md")
    await waitFor(() => getQueueSummary().processing === 1)
    const task = getQueue()[0]
    await cancelTask(task.id)

    expect(mockDeleteFile).not.toHaveBeenCalled()
    finish.resolve(["wiki/concepts/existing.md"])
    await flushMicrotasks(10)
    expect(mockDeleteFile).not.toHaveBeenCalled()
  })

  it("does not restart a cancelled task until its previous worker exits", async () => {
    setIngestWorkerLimit(2)
    const firstRun = createDeferred<string[]>()
    mockAutoIngest
      .mockImplementationOnce(() => firstRun.promise)
      .mockResolvedValueOnce(["wiki/sources/retried.md"])

    await enqueueIngest(TEST_ID, "retry-after-cancel.md")
    await waitFor(() => mockAutoIngest.mock.calls.length === 1)
    const task = getQueue()[0]
    await cancelTask(task.id)
    await retryTask(task.id)
    await flushMicrotasks(10)
    expect(mockAutoIngest).toHaveBeenCalledTimes(1)

    firstRun.reject(new Error("aborted"))
    await waitFor(() => mockAutoIngest.mock.calls.length === 2)
    await waitFor(() => getQueue().length === 0)
  })

  it("ignores retry requests for a task that is still processing", async () => {
    setIngestWorkerLimit(2)
    const run = createDeferred<string[]>()
    mockAutoIngest.mockImplementation(() => run.promise)

    await enqueueIngest(TEST_ID, "still-processing.md")
    await waitFor(() => getQueueSummary().processing === 1)
    const task = getQueue()[0]
    await retryTask(task.id)

    expect(task.status).toBe("processing")
    expect(mockAutoIngest).toHaveBeenCalledTimes(1)
    run.resolve(["wiki/sources/still-processing.md"])
    await waitFor(() => getQueue().length === 0)
    expect(mockAutoIngest).toHaveBeenCalledTimes(1)
  })

  it("pauses and aborts every active worker after a provider usage limit", async () => {
    setIngestWorkerLimit(2)
    const signals: AbortSignal[] = []
    const firstRun = createDeferred<string[]>()
    const secondRun = createDeferred<string[]>()
    mockAutoIngest
      .mockImplementationOnce((_projectPath, _sourcePath, _config, signal) => {
        signals.push(signal as AbortSignal)
        return firstRun.promise
      })
      .mockImplementationOnce((_projectPath, _sourcePath, _config, signal) => {
        signals.push(signal as AbortSignal)
        signal?.addEventListener("abort", () => secondRun.reject(new Error("aborted")))
        return secondRun.promise
      })

    await enqueueBatch(TEST_ID, [
      { sourcePath: "limited.md", folderContext: "" },
      { sourcePath: "sibling.md", folderContext: "" },
    ])
    await waitFor(() => signals.length === 2)
    firstRun.reject(new Error("429 usage limit exceeded"))
    await waitFor(() => getQueueSummary().processing === 0)

    expect(signals[1].aborted).toBe(true)
    expect(isQueuePaused()).toBe(true)
    expect(getQueue().map((task) => task.status)).toEqual(["pending", "pending"])
    expect(getQueue().every((task) => task.retryCount === 0)).toBe(true)
  })
})

describe("ingest-queue — retry & failure", () => {
  it("retries a failing task up to MAX_RETRIES=3 then marks failed", async () => {
    mockAutoIngest.mockRejectedValue(new Error("LLM error"))

    await enqueueIngest(TEST_ID, "bad.md")
    await flushMicrotasks(30)

    expect(mockAutoIngest).toHaveBeenCalledTimes(3)
    const queue = getQueue()
    expect(queue).toHaveLength(1)
    expect(queue[0].status).toBe("failed")
    expect(queue[0].error).toContain("LLM error")
    expect(queue[0].retryCount).toBe(3)
  })

  it("succeeds on retry after transient failure", async () => {
    mockAutoIngest
      .mockRejectedValueOnce(new Error("transient"))
      .mockRejectedValueOnce(new Error("transient"))
      .mockResolvedValueOnce(["wiki/sources/foo.md"])

    await enqueueIngest(TEST_ID, "flaky.md")
    await flushMicrotasks(30)

    expect(mockAutoIngest).toHaveBeenCalledTimes(3)
    expect(getQueue()).toHaveLength(0)
  })

  it("treats autoIngest resolving to an empty array as a failure (not silent success)", async () => {
    // Regression: a webview refresh could abort the LLM fetch, making
    // streamChat's error path fire, which historically caused autoIngest
    // to `return []` — processNext then removed the task from the queue
    // as if it had succeeded. The safety net in processNext now rejects
    // zero-output completions and keeps the task around to retry.
    mockAutoIngest.mockResolvedValue([])

    await enqueueIngest(TEST_ID, "refresh-abort.md")
    await flushMicrotasks(30)

    // Three retries were attempted — the task didn't just vanish.
    expect(mockAutoIngest).toHaveBeenCalledTimes(3)
    const queue = getQueue()
    expect(queue).toHaveLength(1)
    expect(queue[0].status).toBe("failed")
    expect(queue[0].error).toContain("no output files")
    expect(queue[0].retryCount).toBe(3)
  })

  it("retryTask resets a failed task to pending and reprocesses it", async () => {
    mockAutoIngest.mockRejectedValue(new Error("always fails"))

    await enqueueIngest(TEST_ID, "x.md")
    await flushMicrotasks(20)
    expect(getQueue()[0].status).toBe("failed")

    const taskId = getQueue()[0].id
    expect(getQueue()[0].retryCount).toBe(3)
    mockAutoIngest.mockResolvedValueOnce(["wiki/sources/foo.md"])
    await retryTask(taskId)
    await flushMicrotasks(10)

    expect(getQueue()).toHaveLength(0)
  })

  it("retryAllFailedTasks requeues every failed task and resumes processing", async () => {
    const saved = [
      {
        id: "ingest-failed-a",
        sourcePath: "a.md",
        folderContext: "",
        status: "failed",
        addedAt: 0,
        error: "rate limit",
        retryCount: 3,
      },
      {
        id: "ingest-failed-b",
        sourcePath: "b.md",
        folderContext: "",
        status: "failed",
        addedAt: 1,
        error: "timeout",
        retryCount: 3,
      },
    ]
    mockReadFile.mockResolvedValue(JSON.stringify(saved))
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))

    await restoreQueue(TEST_ID, TEST_PATH)
    mockWriteFile.mockClear()

    const requeued = await retryAllFailedTasks()
    await flushMicrotasks(2)

    expect(requeued).toBe(2)
    expect(mockAutoIngest).toHaveBeenCalledOnce()
    expect(getQueue().map((task) => task.error)).toEqual([null, null])
    expect(getQueue().map((task) => task.retryCount)).toEqual([0, 0])
    expect(getQueue().map((task) => task.status)).toEqual(["processing", "pending"])
    expect(mockWriteFile).toHaveBeenCalled()
  })

  it("retryAllFailedTasks returns 0 when there are no failed tasks", async () => {
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))

    const requeued = await retryAllFailedTasks()

    expect(requeued).toBe(0)
    expect(mockAutoIngest).not.toHaveBeenCalled()
  })
})

describe("ingest-queue — cancel", () => {
  it("permanently discards queued work for a removed source", async () => {
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))
    await enqueueBatch(TEST_ID, [
      { sourcePath: "raw/sources/active.md", folderContext: "" },
      { sourcePath: "raw/sources/removed.md", folderContext: "" },
    ])
    await flushMicrotasks(2)

    expect(
      await discardTasksForSources([`${TEST_PATH}/raw/sources/removed.md`]),
    ).toBe(1)
    expect(getQueue().some((task) => task.sourcePath.endsWith("removed.md"))).toBe(false)
    expect(getQueue().some((task) => task.sourcePath.endsWith("active.md"))).toBe(true)
  })

  it("cancelTask retains a pending task for restart without calling autoIngest", async () => {
    mockAutoIngest.mockImplementation(() => new Promise(() => {})) // block first task

    await enqueueBatch(TEST_ID, [
      { sourcePath: "first.md", folderContext: "" },
      { sourcePath: "second.md", folderContext: "" },
    ])
    await flushMicrotasks(2)

    // first.md is processing; cancel second.md (still pending)
    const queue = getQueue()
    const second = queue.find((t) => t.sourcePath === "second.md")!
    await cancelTask(second.id)

    expect(getQueue().find((t) => t.sourcePath === "second.md")?.status).toBe("cancelled")
    expect(getQueue().find((t) => t.sourcePath === "first.md")).toBeDefined()
  })

  it("removeTask drops a cancelled task but leaves active ones alone", async () => {
    mockAutoIngest.mockImplementation(() => new Promise(() => {})) // block first task

    await enqueueBatch(TEST_ID, [
      { sourcePath: "first.md", folderContext: "" },
      { sourcePath: "second.md", folderContext: "" },
    ])
    await flushMicrotasks(2)

    const second = getQueue().find((t) => t.sourcePath === "second.md")!
    await cancelTask(second.id)
    expect(await removeTask(second.id)).toBe(true)
    expect(getQueue().some((t) => t.sourcePath === "second.md")).toBe(false)

    // Processing tasks are not removable — cancel them first.
    const first = getQueue().find((t) => t.sourcePath === "first.md")!
    expect(await removeTask(first.id)).toBe(false)
    expect(getQueue().some((t) => t.sourcePath === "first.md")).toBe(true)
  })

  it("removeTask drops a failed task and persists the removal", async () => {
    mockReadFile.mockResolvedValue(JSON.stringify([
      { id: "ingest-failed-a", sourcePath: "a.md", folderContext: "", status: "failed", addedAt: 1, error: "boom", retryCount: 3 },
      { id: "ingest-failed-b", sourcePath: "b.md", folderContext: "", status: "failed", addedAt: 2, error: "boom", retryCount: 3 },
    ]))
    await restoreQueue(TEST_ID, TEST_PATH)
    mockWriteFile.mockClear()

    expect(await removeTask("ingest-failed-a")).toBe(true)
    expect(getQueue().map((t) => t.id)).toEqual(["ingest-failed-b"])
    const calls = mockWriteFile.mock.calls
    const [path, snapshot] = calls[calls.length - 1]
    expect(path).toBe(`${TEST_PATH}/.llm-wiki/ingest-queue.json`)
    // Not just "the removed ID is gone" — a snapshot of `[]` would satisfy that
    // while silently losing the survivor on the next restore.
    expect(JSON.parse(snapshot).map((t: { id: string }) => t.id))
      .toEqual(["ingest-failed-b"])
  })

  it("removeTask refuses a cancelled task whose run has not exited yet", async () => {
    // autoIngest never settles, so the run keeps its slot in activeRuns even
    // after the abort. Status is "cancelled" but the worker is still alive.
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))

    await enqueueBatch(TEST_ID, [{ sourcePath: "in-flight.md", folderContext: "" }])
    await flushMicrotasks(2)

    const task = getQueue().find((t) => t.sourcePath === "in-flight.md")!
    expect(task.status).toBe("processing")
    await cancelTask(task.id)
    expect(getQueue().find((t) => t.id === task.id)!.status).toBe("cancelled")

    // Removing now would free the sourcePath for a re-import, and the new task
    // would get a fresh ID that processNext's activeRuns guard cannot match.
    expect(await removeTask(task.id)).toBe(false)
    expect(await removeTasks([task.id])).toBe(0)
    expect(getQueue().some((t) => t.id === task.id)).toBe(true)
  })

  it("removeTasks drops only the stopped tasks in the selection", async () => {
    mockAutoIngest.mockImplementation(() => new Promise(() => {})) // block first task

    await enqueueBatch(TEST_ID, [
      { sourcePath: "processing.md", folderContext: "" },
      { sourcePath: "cancelled.md", folderContext: "" },
      { sourcePath: "pending.md", folderContext: "" },
    ])
    await flushMicrotasks(2)

    const cancelled = getQueue().find((t) => t.sourcePath === "cancelled.md")!
    await cancelTask(cancelled.id)

    const removed = await removeTasks(getQueue().map((t) => t.id))
    expect(removed).toBe(1)
    expect(getQueue().map((t) => t.sourcePath)).toEqual(["processing.md", "pending.md"])

    // Unknown IDs and an empty selection are no-ops, not throws.
    expect(await removeTasks(["ingest-does-not-exist"])).toBe(0)
    expect(await removeTasks([])).toBe(0)
  })

  it("retainQueuedSelection keeps rows the core refused to remove", async () => {
    mockAutoIngest.mockImplementation(() => new Promise(() => {})) // block first task

    await enqueueBatch(TEST_ID, [
      { sourcePath: "stuck.md", folderContext: "" },
      { sourcePath: "gone.md", folderContext: "" },
      { sourcePath: "kept.md", folderContext: "" },
    ])
    await flushMicrotasks(2)

    const stuck = getQueue().find((t) => t.sourcePath === "stuck.md")!
    const gone = getQueue().find((t) => t.sourcePath === "gone.md")!
    const kept = getQueue().find((t) => t.sourcePath === "kept.md")!

    await cancelTask(stuck.id) // cancelled, but its run never settles
    await cancelTask(gone.id)
    expect(await removeTask(gone.id)).toBe(true)

    const next = retainQueuedSelection(new Set([stuck.id, gone.id, kept.id]), getQueue())
    expect(next.has(gone.id)).toBe(false) // actually removed
    expect(next.has(stuck.id)).toBe(true) // guard refused it — must stay selected
    expect(next.has(kept.id)).toBe(true) // untouched
    // ...and the panel hides its remove button rather than offering a no-op.
    expect(hasActiveRun(stuck.id)).toBe(true)
    expect(hasActiveRun(kept.id)).toBe(false)

    // Unchanged membership returns the same Set so React can skip the update.
    const unchanged = new Set([stuck.id, kept.id])
    expect(retainQueuedSelection(unchanged, getQueue())).toBe(unchanged)
  })

  it("batch-cancelled tasks can be batch-restarted", async () => {
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))
    await enqueueBatch(TEST_ID, [
      { sourcePath: "active.md", folderContext: "" },
      { sourcePath: "b.md", folderContext: "" },
      { sourcePath: "c.md", folderContext: "" },
    ])
    await flushMicrotasks(2)
    const stopped = getQueue().filter((task) => task.status === "pending")

    expect(await cancelTasks(stopped.map((task) => task.id))).toBe(2)
    expect(getQueue().filter((task) => task.status === "cancelled")).toHaveLength(2)
    expect(await retryTasks(stopped.map((task) => task.id))).toBe(2)
    expect(getQueue().filter((task) => task.status === "pending")).toHaveLength(2)
  })

  it("enqueueing a cancelled source restarts the retained task without duplication", async () => {
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))
    await enqueueBatch(TEST_ID, [
      { sourcePath: "active.md", folderContext: "" },
      { sourcePath: "cancelled.md", folderContext: "old" },
    ])
    await flushMicrotasks(2)
    const stopped = getQueue().find((task) => task.sourcePath === "cancelled.md")!
    await cancelTask(stopped.id)

    const restartedId = await enqueueIngest(TEST_ID, "cancelled.md", "new")

    expect(restartedId).toBe(stopped.id)
    expect(getQueue().filter((task) => task.sourcePath === "cancelled.md")).toHaveLength(1)
    expect(getQueue().find((task) => task.id === stopped.id)).toMatchObject({
      status: "pending",
      folderContext: "new",
    })
  })

  it("discards an old in-flight result when a cancelled task is immediately restarted", async () => {
    let finishOldRun: ((files: string[]) => void) | undefined
    mockAutoIngest
      .mockImplementationOnce(
        () => new Promise<string[]>((resolve) => {
          finishOldRun = resolve
        }),
      )
      .mockResolvedValueOnce(["wiki/restart-new.md"])

    await enqueueIngest(TEST_ID, "restart.md")
    await flushMicrotasks(2)
    const task = getQueue()[0]
    await cancelTask(task.id)
    await retryTasks([task.id])

    // Simulate a provider that ignores AbortSignal and completes the old run.
    finishOldRun?.(["wiki/restart.md"])
    await vi.waitFor(() => expect(mockAutoIngest).toHaveBeenCalledTimes(2))
    await vi.waitFor(() => expect(getQueue()).toHaveLength(0))

    expect(getQueueSummary().completed).toBe(1)
  })

  it("moves pending task priority without crossing the processing task", async () => {
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))
    await enqueueBatch(TEST_ID, [
      { sourcePath: "active.md", folderContext: "" },
      { sourcePath: "b.md", folderContext: "" },
      { sourcePath: "c.md", folderContext: "" },
      { sourcePath: "d.md", folderContext: "" },
    ])
    await flushMicrotasks(2)
    const d = getQueue().find((task) => task.sourcePath === "d.md")!

    expect(await movePendingTask(d.id, "up")).toBe(true)
    expect(getQueue().map((task) => task.sourcePath)).toEqual([
      "active.md",
      "b.md",
      "d.md",
      "c.md",
    ])
  })
})

describe("ingest-queue — cancelAllTasks", () => {
  it("retains pending and processing tasks as cancelled alongside failed ones", async () => {
    // Block the processing task so it doesn't finish on its own.
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))

    await enqueueBatch(TEST_ID, [
      { sourcePath: "a.md", folderContext: "" },
      { sourcePath: "b.md", folderContext: "" },
      { sourcePath: "c.md", folderContext: "" },
    ])
    await flushMicrotasks(2)

    // Manually set one task to "failed" so we can verify it survives.
    const failedTask = getQueue()[2]
    ;(failedTask as { status: string }).status = "failed"

    const removed = await cancelAllTasks()

    expect(removed).toBe(2)
    expect(getQueue()).toHaveLength(3)
    expect(getQueue().map((task) => task.status)).toEqual(["cancelled", "cancelled", "failed"])
  })

  it("returns 0 when the queue is empty", async () => {
    const removed = await cancelAllTasks()
    expect(removed).toBe(0)
    expect(getQueue()).toHaveLength(0)
  })

  it("is safe to call after it has already cleared the queue", async () => {
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))
    await enqueueIngest(TEST_ID, "only.md")
    await flushMicrotasks(2)

    await cancelAllTasks()
    const secondCall = await cancelAllTasks()
    expect(secondCall).toBe(0)
  })
})

describe("ingest-queue — clearCompletedTasks & summary", () => {
  it("getQueueSummary returns accurate counts", async () => {
    mockAutoIngest.mockRejectedValue(new Error("fail"))
    await enqueueIngest(TEST_ID, "fail.md")
    await flushMicrotasks(20)

    const summary = getQueueSummary()
    expect(summary.failed).toBe(1)
    expect(summary.completed).toBe(0)
    expect(summary.pending).toBe(0)
    expect(summary.total).toBe(1)
  })

  it("tracks successful completions until a new idle queue starts", async () => {
    mockAutoIngest.mockResolvedValue(["wiki/sources/foo.md"])
    await enqueueBatch(TEST_ID, [
      { sourcePath: "a.md", folderContext: "" },
      { sourcePath: "b.md", folderContext: "" },
    ])
    await flushMicrotasks(40)

    expect(getQueueSummary()).toMatchObject({ completed: 2, failed: 0, total: 2 })

    await enqueueIngest(TEST_ID, "c.md")
    await flushMicrotasks(20)

    expect(getQueueSummary()).toMatchObject({ completed: 1, failed: 0, total: 1 })
  })

  it("clearCompletedTasks drops failed tasks", async () => {
    mockAutoIngest.mockRejectedValue(new Error("fail"))
    await enqueueIngest(TEST_ID, "f.md")
    await flushMicrotasks(20)

    expect(getQueue()).toHaveLength(1)
    await clearCompletedTasks()
    expect(getQueue()).toHaveLength(0)
  })
})

describe("ingest-queue — queue-drain triggers review sweep", () => {
  it("calls sweepResolvedReviews once after a successful task drains the queue", async () => {
    mockAutoIngest.mockResolvedValue(["wiki/sources/foo.md"])

    await enqueueIngest(TEST_ID, "ok.md")
    await flushMicrotasks(30)

    expect(mockSweep).toHaveBeenCalledOnce()
    expect(mockSweep).toHaveBeenCalledWith("/project", expect.any(AbortSignal))
  })

  it("does NOT trigger sweep when no task has been processed since the last drain", async () => {
    // No tasks enqueued — processedSinceDrain flag stays false
    // (We simulate an idle condition by enqueueing, processing, draining once)
    mockAutoIngest.mockResolvedValue(["wiki/sources/foo.md"])
    await enqueueIngest(TEST_ID, "a.md")
    await waitFor(() => mockSweep.mock.calls.length === 1)
    expect(mockSweep).toHaveBeenCalledTimes(1)

    // Now the queue is empty. Calling cancelTask on a nonexistent id is a
    // no-op but internally may call processNext → no drain fire (nothing
    // was processed since the last drain).
    await cancelTask("nonexistent")
    await flushMicrotasks(5)
    expect(mockSweep).toHaveBeenCalledTimes(1)
  })

  it("does NOT trigger sweep when all tasks fail (nothing was successfully ingested)", async () => {
    mockAutoIngest.mockRejectedValue(new Error("always fails"))

    await enqueueIngest(TEST_ID, "bad.md")
    await flushMicrotasks(30)

    expect(mockSweep).not.toHaveBeenCalled()
  })
})

describe("ingest-queue — clearQueueState", () => {
  it("clears pending tasks and resets processing flag", async () => {
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))
    await enqueueBatch(TEST_ID, [
      { sourcePath: "a.md", folderContext: "" },
      { sourcePath: "b.md", folderContext: "" },
    ])
    await flushMicrotasks(2)

    expect(getQueue().length).toBeGreaterThan(0)

    clearQueueState()
    expect(getQueue()).toHaveLength(0)
  })

  it("processedSinceDrain flag resets so a post-switch no-op won't trigger sweep", async () => {
    mockAutoIngest.mockResolvedValue(["wiki/sources/foo.md"])
    await enqueueIngest(TEST_ID, "x.md")
    await flushMicrotasks(20)
    mockSweep.mockClear()

    clearQueueState()
    // Simulate new drain trigger on an empty queue — no sweep.
    await flushMicrotasks(5)
    expect(mockSweep).not.toHaveBeenCalled()
  })
})

describe("ingest-queue — restoreQueue", () => {
  it("resets in-memory state before loading, preventing cross-project bleed", async () => {
    // Seed in-memory state from project A
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))
    await enqueueIngest(TEST_ID, "a.md")
    await flushMicrotasks(2)
    expect(getQueue().length).toBeGreaterThan(0)

    // Now restore project B — should reset and load B's saved queue (empty)
    mockReadFile.mockRejectedValue(new Error("ENOENT"))
    await restoreQueue(TEST_ID_B, TEST_PATH_B)
    expect(getQueue()).toHaveLength(0)
  })

  it("restarts an interrupted processing task on restore", async () => {
    const saved = [
      {
        id: "ingest-abc",
        sourcePath: "a.md",
        folderContext: "",
        status: "processing",
        addedAt: 0,
        error: null,
        retryCount: 0,
      },
    ]
    mockReadFile.mockResolvedValue(JSON.stringify(saved))
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))
    await restoreQueue(TEST_ID, TEST_PATH)
    await flushMicrotasks(2)

    const queue = getQueue()
    expect(queue).toHaveLength(1)
    expect(queue[0].status).toBe("processing")
    expect(getQueueSummary().paused).toBe(false)
    expect(mockAutoIngest).toHaveBeenCalledTimes(1)
  })

  it("leaves 'failed' tasks as failed on restore", async () => {
    const saved = [
      {
        id: "ingest-x",
        sourcePath: "x.md",
        folderContext: "",
        status: "failed",
        addedAt: 0,
        error: "prior failure",
        retryCount: 3,
      },
    ]
    mockReadFile.mockResolvedValue(JSON.stringify(saved))

    await restoreQueue(TEST_ID, TEST_PATH)
    const queue = getQueue()
    expect(queue).toHaveLength(1)
    expect(queue[0].status).toBe("failed")
    expect(queue[0].error).toBe("prior failure")
  })

  it("backfills projectId on older task files that predate the field", async () => {
    // Disk written before projectId was part of the schema.
    const savedLegacy = [
      {
        id: "ingest-legacy",
        sourcePath: "legacy.md",
        folderContext: "",
        status: "pending",
        addedAt: 0,
        error: null,
        retryCount: 0,
      },
    ]
    mockReadFile.mockResolvedValue(JSON.stringify(savedLegacy))
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))

    await restoreQueue(TEST_ID, TEST_PATH)
    await flushMicrotasks(2)
    const queue = getQueue()
    expect(queue).toHaveLength(1)
    expect(queue[0].projectId).toBe(TEST_ID)
    expect(queue[0].status).toBe("processing")
    expect(mockAutoIngest).toHaveBeenCalledTimes(1)
  })

  it("automatically resumes restored pending tasks", async () => {
    const saved = [
      {
        id: "ingest-restored",
        sourcePath: "restored.md",
        folderContext: "",
        status: "pending",
        addedAt: 0,
        error: null,
        retryCount: 0,
      },
    ]
    mockReadFile.mockResolvedValue(JSON.stringify(saved))
    mockAutoIngest.mockResolvedValue(["wiki/sources/restored.md"])

    await restoreQueue(TEST_ID, TEST_PATH)
    await flushMicrotasks(10)

    expect(mockAutoIngest).toHaveBeenCalledTimes(1)
    expect(getQueue()).toHaveLength(0)
    expect(getQueueSummary().paused).toBe(false)
  })

  it("keeps restored tasks pending when the ingest model is not configured", async () => {
    const { useWikiStore } = await import("@/stores/wiki-store")
    useWikiStore.getState().setLlmConfig({
      provider: "openai",
      apiKey: "",
      model: "",
      ollamaUrl: "",
      customEndpoint: "",
      maxContextSize: 128000,
    })
    mockReadFile.mockResolvedValue(JSON.stringify([
      {
        id: "pending-a",
        sourcePath: "a.md",
        folderContext: "",
        status: "pending",
        addedAt: 0,
        error: null,
        retryCount: 0,
      },
      {
        id: "pending-b",
        sourcePath: "b.md",
        folderContext: "",
        status: "pending",
        addedAt: 0,
        error: null,
        retryCount: 0,
      },
    ]))

    await restoreQueue(TEST_ID, TEST_PATH)
    await flushMicrotasks(4)

    expect(getQueue().map((task) => task.status)).toEqual(["pending", "pending"])
    expect(getQueueSummary().blockedOnLlmConfig).toBe(true)
    expect(mockAutoIngest).not.toHaveBeenCalled()

    useWikiStore.getState().setLlmConfig({
      provider: "openai",
      apiKey: "configured",
      model: "model",
      ollamaUrl: "",
      customEndpoint: "",
      maxContextSize: 128000,
    })
    mockAutoIngest.mockResolvedValue(["wiki/sources/restored.md"])
    resumeProcessing()
    await flushMicrotasks(20)

    expect(mockAutoIngest).toHaveBeenCalledTimes(2)
    expect(getQueue()).toHaveLength(0)
    expect(getQueueSummary().blockedOnLlmConfig).toBe(false)
  })

  it("finishes restored backlog before accepting a new live task", async () => {
    const saved = [
      {
        id: "ingest-restored",
        sourcePath: "restored.md",
        folderContext: "",
        status: "pending",
        addedAt: 0,
        error: null,
        retryCount: 0,
      },
    ]
    mockReadFile.mockResolvedValue(JSON.stringify(saved))
    mockAutoIngest.mockImplementation(async (_projectPath, sourcePath) => [
      `wiki/sources/${String(sourcePath).replace(/\.md$/, "")}.md`,
    ])

    await restoreQueue(TEST_ID, TEST_PATH)
    await flushMicrotasks(2)
    await enqueueIngest(TEST_ID, "live.md")
    await flushMicrotasks(10)

    expect(mockAutoIngest).toHaveBeenCalledTimes(2)
    expect(mockAutoIngest.mock.calls[0][1]).toBe(`${TEST_PATH}/restored.md`)
    expect(mockAutoIngest.mock.calls[1][1]).toBe(`${TEST_PATH}/live.md`)
    expect(getQueue()).toHaveLength(0)
    expect(getQueueSummary().paused).toBe(false)
  })

  it("reports an automatically restored task as active processing", async () => {
    const saved = [
      {
        id: "ingest-restored",
        sourcePath: "restored.md",
        folderContext: "",
        status: "pending",
        addedAt: 0,
        error: null,
        retryCount: 0,
      },
    ]
    mockReadFile.mockResolvedValue(JSON.stringify(saved))
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))

    await restoreQueue(TEST_ID, TEST_PATH)
    await flushMicrotasks(2)
    expect(getQueueSummary()).toMatchObject({
      processing: 1,
      paused: false,
      userPaused: false,
    })
  })

  it("queues a rerun when a live event touches a restored task already processing", async () => {
    const saved = [
      {
        id: "ingest-restored",
        sourcePath: "same.md",
        folderContext: "",
        status: "pending",
        addedAt: 0,
        error: null,
        retryCount: 0,
      },
    ]
    mockReadFile.mockResolvedValue(JSON.stringify(saved))
    const firstRun = createDeferred<string[]>()
    mockAutoIngest
      .mockImplementationOnce(() => firstRun.promise)
      .mockResolvedValueOnce(["wiki/sources/same.md"])

    await restoreQueue(TEST_ID, TEST_PATH)
    await flushMicrotasks(2)
    await enqueueIngest(TEST_ID, "same.md")
    await flushMicrotasks(2)

    expect(mockAutoIngest).toHaveBeenCalledTimes(1)
    expect(getQueue().filter((task) => task.status === "pending")).toHaveLength(1)

    firstRun.resolve(["wiki/sources/same.md"])
    await flushMicrotasks(10)

    expect(mockAutoIngest).toHaveBeenCalledTimes(2)
    expect(mockAutoIngest.mock.calls[0][1]).toBe(`${TEST_PATH}/same.md`)
    expect(getQueue()).toHaveLength(0)
    expect(getQueueSummary().paused).toBe(false)
  })
})

import { pauseQueue } from "./ingest-queue"

describe("ingest-queue — pauseQueue & switch-project survival", () => {
  it("waits for an active commit before completing a project switch", async () => {
    const commit = createDeferred<void>()
    let commitStarted = false
    mockAutoIngest.mockImplementation(
      async (_projectPath, _sourcePath, _config, _signal, _folder, _onFileWritten, options) => {
        await options?.runCommit?.(async () => {
          commitStarted = true
          await commit.promise
        })
        return ["wiki/sources/committed.md"]
      },
    )

    await enqueueIngest(TEST_ID, "committing.md")
    await waitFor(() => commitStarted)
    let pauseFinished = false
    const pause = pauseQueue().then(() => { pauseFinished = true })
    await flushMicrotasks(5)
    expect(pauseFinished).toBe(false)

    commit.resolve()
    await pause
    expect(pauseFinished).toBe(true)
  })

  it("pauseQueue persists pending/processing tasks to the paused project's disk", async () => {
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))
    await enqueueBatch(TEST_ID, [
      { sourcePath: "a.md", folderContext: "" },
      { sourcePath: "b.md", folderContext: "" },
    ])
    await flushMicrotasks(2)
    mockWriteFile.mockClear()

    await pauseQueue()

    // The last write call should contain BOTH tasks, with the processing
    // one demoted back to pending for resume-on-return.
    const writes = mockWriteFile.mock.calls
    expect(writes.length).toBeGreaterThan(0)
    const [pathArg, contentArg] = writes[writes.length - 1]
    expect(String(pathArg)).toContain("/project/.llm-wiki/ingest-queue.json")
    const persisted = JSON.parse(String(contentArg)) as Array<{ status: string }>
    expect(persisted).toHaveLength(2)
    for (const t of persisted) expect(t.status).toBe("pending")
  })

  it("pauseQueue then restoreQueue of SAME project brings tasks back", async () => {
    mockAutoIngest.mockImplementation(() => new Promise(() => {}))
    await enqueueIngest(TEST_ID, "first.md")
    await flushMicrotasks(2)

    // Capture what pauseQueue writes so restore can read it back.
    let lastWrittenContent = ""
    mockWriteFile.mockImplementation(async (_path: string, content: string) => {
      lastWrittenContent = content
    })
    await pauseQueue()

    // Simulate reloading that same project: disk returns what we just wrote.
    mockReadFile.mockResolvedValue(lastWrittenContent)
    await restoreQueue(TEST_ID, TEST_PATH)

    const queue = getQueue()
    expect(queue).toHaveLength(1)
    expect(queue[0].sourcePath).toBe("first.md")
  })

  it("processNext bails if currentProjectId changes mid-ingest (no cross-project writes)", async () => {
    // Block autoIngest so we can pause mid-flight. Then resolve it
    // AFTER pauseQueue completes to simulate the delayed return.
    let resolveAutoIngest: (files: string[]) => void = () => {}
    mockAutoIngest.mockImplementation(
      () => new Promise<string[]>((resolve) => { resolveAutoIngest = resolve }),
    )

    await enqueueIngest(TEST_ID, "long-running.md")
    await flushMicrotasks(2)
    // Ensure the task is processing
    expect(getQueue().find((t) => t.status === "processing")).toBeTruthy()

    // Switch projects: pause then restore a different one.
    mockWriteFile.mockClear()
    await pauseQueue()
    await restoreQueue(TEST_ID_B, TEST_PATH_B)

    // Now the orphaned autoIngest for TEST_ID returns late.
    resolveAutoIngest(["wiki/sources/foo.md"])
    await flushMicrotasks(10)

    // The orphan must not have written to the ACTIVE (B) project's file.
    // Inspect every post-pause write — the path should never contain the
    // project-B queue file getting mutated by the orphan's filter result.
    const writes = mockWriteFile.mock.calls
    // Confirm no write touched project B's queue from orphan completion.
    // (The only writes should be pauseQueue's flush to /project and
    // restoreQueue's initial save of B's empty queue.)
    const bWrites = writes.filter(([p]) => String(p).includes("/project-b/"))
    // B's queue should only have been written once (during restore), and
    // that write should show an empty array — not the orphan's filtered
    // result leaking in.
    for (const [, content] of bWrites) {
      const parsed = JSON.parse(String(content))
      expect(parsed).toEqual([])
    }
  })
})

describe("ingest-queue — pause/resume processing", () => {
  it("aborts the in-flight task and does not start the next while paused", async () => {
    mockAutoIngest.mockImplementationOnce(
      (_projectPath, _sourcePath, _llmConfig, signal) =>
        new Promise<string[]>((_resolve, reject) => {
          signal?.addEventListener("abort", () => reject(new Error("aborted")))
        }),
    )
    mockAutoIngest.mockResolvedValue(["wiki/sources/foo.md"])

    await enqueueBatch(TEST_ID, [
      { sourcePath: "a.md", folderContext: "" },
      { sourcePath: "b.md", folderContext: "" },
    ])
    await flushMicrotasks(2)
    expect(getQueue().find((t) => t.sourcePath === "a.md")?.status).toBe("processing")

    // Pause while a.md is in flight — it should be aborted and returned
    // to pending; no other task starts while paused.
    pauseProcessing()
    expect(isQueuePaused()).toBe(true)
    await flushMicrotasks(10)

    expect(mockAutoIngest).toHaveBeenCalledTimes(1)
    expect(getQueue().find((t) => t.sourcePath === "a.md")?.status).toBe("pending")
    expect(getQueue().find((t) => t.sourcePath === "a.md")?.retryCount).toBe(0)
    expect(getQueue().find((t) => t.sourcePath === "a.md")?.error).toBeNull()
    expect(getQueue().find((t) => t.sourcePath === "b.md")?.status).toBe("pending")
    expect(getQueueSummary().paused).toBe(true)
  })

  it("resumeProcessing restarts the queue and processes the pending task", async () => {
    mockAutoIngest.mockImplementationOnce(
      (_projectPath, _sourcePath, _llmConfig, signal) =>
        new Promise<string[]>((_resolve, reject) => {
          signal?.addEventListener("abort", () => reject(new Error("aborted")))
        }),
    )
    mockAutoIngest.mockResolvedValue(["wiki/sources/foo.md"])

    await enqueueBatch(TEST_ID, [
      { sourcePath: "a.md", folderContext: "" },
      { sourcePath: "b.md", folderContext: "" },
    ])
    await flushMicrotasks(2)
    pauseProcessing()
    await flushMicrotasks(10)
    expect(mockAutoIngest).toHaveBeenCalledTimes(1)
    expect(getQueue().find((t) => t.sourcePath === "a.md")?.status).toBe("pending")
    expect(getQueue().find((t) => t.sourcePath === "b.md")?.status).toBe("pending")

    // Resume → aborted a.md restarts first, then b.md drains.
    resumeProcessing()
    await waitFor(() => mockAutoIngest.mock.calls.length === 3)
    expect(mockAutoIngest).toHaveBeenCalledTimes(3)
    expect(getQueue()).toHaveLength(0)
    expect(isQueuePaused()).toBe(false)
  })

  it("does not run the drain-sweep while paused (no token spend)", async () => {
    mockAutoIngest.mockImplementationOnce(
      (_projectPath, _sourcePath, _llmConfig, signal) =>
        new Promise<string[]>((_resolve, reject) => {
          signal?.addEventListener("abort", () => reject(new Error("aborted")))
        }),
    )

    await enqueueIngest(TEST_ID, "only.md")
    await flushMicrotasks(2)
    pauseProcessing()
    await flushMicrotasks(10)

    // The task is back to pending and no drain sweep runs while paused.
    expect(getQueue().find((t) => t.sourcePath === "only.md")?.status).toBe("pending")
    expect(mockSweep).not.toHaveBeenCalled()
    expect(isQueuePaused()).toBe(true)
  })

  it("does not start a duplicate runner if resumed before the abort settles", async () => {
    let rejectFirst: (err: Error) => void = () => {}
    mockAutoIngest.mockImplementationOnce(
      (_projectPath, _sourcePath, _llmConfig, signal) =>
        new Promise<string[]>((_resolve, reject) => {
          rejectFirst = reject
          signal?.addEventListener("abort", () => {})
        }),
    )
    mockAutoIngest.mockResolvedValue(["wiki/sources/next.md"])

    await enqueueIngest(TEST_ID, "only.md")
    await flushMicrotasks(2)
    pauseProcessing()
    expect(isQueuePaused()).toBe(true)
    expect(getQueue().find((t) => t.sourcePath === "only.md")?.status).toBe("pending")

    resumeProcessing()
    await flushMicrotasks(5)
    expect(mockAutoIngest).toHaveBeenCalledTimes(1)

    rejectFirst(new Error("aborted"))
    await flushMicrotasks(10)
    expect(isQueuePaused()).toBe(false)
    expect(mockAutoIngest).toHaveBeenCalledTimes(2)
    expect(getQueue()).toHaveLength(0)
  })

  it("clears pause when the only paused task is cancelled so future imports can run", async () => {
    mockAutoIngest.mockImplementationOnce(
      (_projectPath, _sourcePath, _llmConfig, signal) =>
        new Promise<string[]>((_resolve, reject) => {
          signal?.addEventListener("abort", () => reject(new Error("aborted")))
        }),
    )
    mockAutoIngest.mockResolvedValue(["wiki/sources/fresh.md"])

    await enqueueIngest(TEST_ID, "only.md")
    await flushMicrotasks(2)
    pauseProcessing()
    await flushMicrotasks(10)
    const only = getQueue().find((t) => t.sourcePath === "only.md")
    expect(only?.status).toBe("pending")
    expect(getQueueSummary().paused).toBe(true)

    await cancelTask(only!.id)
    expect(getQueueSummary().paused).toBe(false)

    await enqueueIngest(TEST_ID, "fresh.md")
    await flushMicrotasks(10)
    expect(mockAutoIngest).toHaveBeenCalledTimes(2)
    expect(mockAutoIngest.mock.calls[1][1]).toBe(`${TEST_PATH}/fresh.md`)
    expect(getQueue()).toHaveLength(1)
    expect(getQueue()[0]).toMatchObject({ sourcePath: "only.md", status: "cancelled" })
  })

  it("restoreQueue resets the paused flag — every project loads un-paused", async () => {
    pauseProcessing()
    expect(isQueuePaused()).toBe(true)

    mockReadFile.mockRejectedValue(new Error("ENOENT"))
    await restoreQueue(TEST_ID, TEST_PATH)
    expect(isQueuePaused()).toBe(false)
  })

  it("clearQueueState resets the paused flag", async () => {
    pauseProcessing()
    expect(isQueuePaused()).toBe(true)
    clearQueueState()
    expect(isQueuePaused()).toBe(false)
  })

  it("auto-pauses on provider usage limits and resumes later without burning retries", async () => {
    vi.useFakeTimers()
    try {
      mockAutoIngest
        .mockRejectedValueOnce(new Error("429 rate limit exceeded"))
        .mockResolvedValueOnce(["wiki/sources/only.md"])

      await enqueueIngest(TEST_ID, "only.md")
      await flushMicrotasks(10)

      const pausedTask = getQueue().find((t) => t.sourcePath === "only.md")
      expect(pausedTask?.status).toBe("pending")
      expect(pausedTask?.retryCount).toBe(0)
      expect(pausedTask?.error).toContain("Paused after provider usage limit")
      expect(getQueueSummary().paused).toBe(true)
      expect(mockAutoIngest).toHaveBeenCalledTimes(1)

      await vi.advanceTimersByTimeAsync(15 * 60 * 1000)
      await flushMicrotasks(10)

      expect(mockAutoIngest).toHaveBeenCalledTimes(2)
      expect(getQueue()).toHaveLength(0)
      expect(getQueueSummary().paused).toBe(false)
    } finally {
      vi.useRealTimers()
    }
  })
})

// ── cleanupWrittenFiles — centralized page cascade ─────────────────
describe("cleanupWrittenFiles — page cascade", () => {
  it("deletes each file AND drops its embedding chunks (relative paths)", async () => {
    const { deleteFile } = await import("@/commands/fs")
    const mockDeleteFile = vi.mocked(deleteFile)
    mockDeleteFile.mockReset()
    mockDeleteFile.mockResolvedValue(undefined)

    await cleanupWrittenFiles("/proj", [
      "wiki/concepts/rope.md",
      "wiki/entities/transformer.md",
    ])

    // File deletes use joined absolute paths.
    expect(mockDeleteFile).toHaveBeenCalledTimes(2)
    expect(mockDeleteFile).toHaveBeenNthCalledWith(1, "/proj/wiki/concepts/rope.md")
    expect(mockDeleteFile).toHaveBeenNthCalledWith(2, "/proj/wiki/entities/transformer.md")

    expect(cascadeDeleteWikiPageMock).toHaveBeenCalledTimes(2)
    expect(cascadeDeleteWikiPageMock).toHaveBeenNthCalledWith(1, "/proj", "/proj/wiki/concepts/rope.md")
    expect(cascadeDeleteWikiPageMock).toHaveBeenNthCalledWith(2, "/proj", "/proj/wiki/entities/transformer.md")
  })

  it("uses absolute paths verbatim (doesn't double-prefix the project path)", async () => {
    const { deleteFile } = await import("@/commands/fs")
    const mockDeleteFile = vi.mocked(deleteFile)
    mockDeleteFile.mockReset()
    mockDeleteFile.mockResolvedValue(undefined)

    await cleanupWrittenFiles("/proj", ["/abs/elsewhere/wiki/concepts/foo.md"])

    expect(mockDeleteFile).toHaveBeenCalledWith("/abs/elsewhere/wiki/concepts/foo.md")
    expect(cascadeDeleteWikiPageMock).toHaveBeenCalledWith(
      "/proj",
      "/abs/elsewhere/wiki/concepts/foo.md",
    )
  })

  it("continues to subsequent files when one delete throws", async () => {
    const { deleteFile } = await import("@/commands/fs")
    const mockDeleteFile = vi.mocked(deleteFile)
    mockDeleteFile.mockReset()
    // First file fails (e.g. already gone), second succeeds.
    mockDeleteFile
      .mockRejectedValueOnce(new Error("ENOENT"))
      .mockResolvedValueOnce(undefined)

    await cleanupWrittenFiles("/proj", [
      "wiki/concepts/missing.md",
      "wiki/concepts/present.md",
    ])

    // Both deleteFile attempts happened — the helper kept going.
    expect(mockDeleteFile).toHaveBeenCalledTimes(2)
    // Both cascades were attempted even though the first delete failed.
    expect(cascadeDeleteWikiPageMock).toHaveBeenCalledTimes(2)
    expect(cascadeDeleteWikiPageMock).toHaveBeenNthCalledWith(
      2,
      "/proj",
      "/proj/wiki/concepts/present.md",
    )
  })

  it("swallows page cascade errors so a LanceDB issue doesn't abort cleanup", async () => {
    const { deleteFile } = await import("@/commands/fs")
    const mockDeleteFile = vi.mocked(deleteFile)
    mockDeleteFile.mockReset()
    mockDeleteFile.mockResolvedValue(undefined)

    // First page cascade throws; second succeeds.
    cascadeDeleteWikiPageMock
      .mockImplementationOnce(async (_projectPath, filePath) => {
        await mockDeleteFile(filePath)
        throw new Error("lancedb unavailable")
      })
      .mockImplementationOnce(async (_projectPath, filePath) => {
        await mockDeleteFile(filePath)
      })

    await cleanupWrittenFiles("/proj", [
      "wiki/concepts/a.md",
      "wiki/concepts/b.md",
    ])

    // Second cascade still attempted despite first throwing.
    expect(cascadeDeleteWikiPageMock).toHaveBeenCalledTimes(2)
  })

  it("passes Windows backslash paths to the centralized cascade", async () => {
    const { deleteFile } = await import("@/commands/fs")
    const mockDeleteFile = vi.mocked(deleteFile)
    mockDeleteFile.mockReset()
    mockDeleteFile.mockResolvedValue(undefined)

    // The centralized cascade owns path normalization and page-id derivation.
    await cleanupWrittenFiles("C:/proj", ["wiki\\concepts\\rope.md"])

    expect(cascadeDeleteWikiPageMock).toHaveBeenCalledWith(
      "C:/proj",
      "C:/proj/wiki\\concepts\\rope.md",
    )
  })
})