@fs/mycroft 0.1.1 → 0.3.0

package/dist/cli.js

@@ -1,154 +1,43 @@
 #!/usr/bin/env node
+import {
+  submitBatchEmbeddings
+} from "./chunk-XXO66RCF.js";
+import {
+  submitBatchSummaries
+} from "./chunk-7DUQNGEK.js";
+import {
+  CHUNK_OVERLAP,
+  CHUNK_SIZE,
+  SEPARATORS,
+  SUMMARY_CONCURRENCY,
+  SUMMARY_MAX_TOKENS,
+  SUMMARY_TARGET_WORDS,
+  configPath,
+  ensureConfigDirs,
+  ensureDataDirs,
+  getModels,
+  handleSigint,
+  isAskEnabled,
+  isInteractive,
+  loadConfig,
+  logInfo,
+  logWarn,
+  printError,
+  requireOpenAIKey,
+  resolvePaths,
+  setConfigOverrides,
+  stdout
+} from "./chunk-KGG7WEYE.js";
 
 // src/cli.ts
 import { Command } from "commander";
-
-// src/config.ts
-import { mkdir, readFile } from "fs/promises";
-import { homedir } from "os";
-import { dirname, join, resolve } from "path";
-var DEFAULT_CONFIG = {
-  dataDir: "~/.local/share/mycroft",
-  askEnabled: true,
-  models: {
-    embedding: "text-embedding-3-small",
-    summary: "gpt-5-nano",
-    chat: "gpt-5.1"
-  }
-};
-var expandHome = (input) => {
-  if (!input.startsWith("~")) return input;
-  return join(homedir(), input.slice(1));
-};
-var resolvePath = (input) => resolve(expandHome(input));
-var getConfigPath = () => {
-  const override = process.env.MYCROFT_CONFIG;
-  if (override) return resolvePath(override);
-  return resolvePath("~/.config/mycroft/config.json");
-};
-var normalizeModels = (models) => ({
-  embedding: models?.embedding || DEFAULT_CONFIG.models.embedding,
-  summary: models?.summary || DEFAULT_CONFIG.models.summary,
-  chat: models?.chat || DEFAULT_CONFIG.models.chat
-});
-var overrides = {};
-var setConfigOverrides = (next) => {
-  overrides = { ...overrides, ...next };
-};
-var normalizeConfig = (input) => {
-  const dataDirEnv = process.env.MYCROFT_DATA_DIR;
-  const dataDir = overrides.dataDir || dataDirEnv || input?.dataDir || DEFAULT_CONFIG.dataDir;
-  return {
-    dataDir,
-    askEnabled: input?.askEnabled ?? DEFAULT_CONFIG.askEnabled,
-    models: normalizeModels(input?.models)
-  };
-};
-var readConfigFile = async (path) => {
-  try {
-    const contents = await readFile(path, "utf-8");
-    return JSON.parse(contents);
-  } catch {
-    return null;
-  }
-};
-var loadConfig = async () => {
-  const configPath2 = getConfigPath();
-  const data = await readConfigFile(configPath2);
-  const normalized = normalizeConfig(data);
-  return {
-    ...normalized,
-    dataDir: resolvePath(normalized.dataDir)
-  };
-};
-var ensureConfigDirs = async (configPath2) => {
-  const path = configPath2 || getConfigPath();
-  await mkdir(dirname(path), { recursive: true });
-};
-var configPath = () => getConfigPath();
-
-// src/commands/io.ts
-import chalk from "chalk";
-var isTTY = () => Boolean(process.stdout.isTTY);
-var isInteractive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
-var formatError = (text) => isTTY() ? chalk.red(text) : text;
-var formatWarn = (text) => isTTY() ? chalk.yellow(text) : text;
-var stdout = (message) => {
-  process.stdout.write(message.endsWith("\n") ? message : `${message}
-`);
-};
-var stderr = (message) => {
-  process.stderr.write(message.endsWith("\n") ? message : `${message}
-`);
-};
-var printError = (message) => {
-  stderr(formatError(`Error: ${message}`));
-};
-var logInfo = (message) => {
-  stderr(message);
-};
-var logWarn = (message) => {
-  stderr(formatWarn(message));
-};
-var handleSigint = (onCancel) => {
-  const handler = () => {
-    if (onCancel) onCancel();
-    stderr("\nCancelled.");
-    process.exit(130);
-  };
-  process.once("SIGINT", handler);
-  return () => process.off("SIGINT", handler);
-};
-
-// src/cli.ts
 import { readFile as readFile2 } from "fs/promises";
-import { dirname as dirname2, resolve as resolve2 } from "path";
+import { dirname, resolve } from "path";
 import { fileURLToPath } from "url";
 
 // src/services/epub-parser.ts
 import { initEpubFile } from "@lingo-reader/epub-parser";
 import { basename } from "path";
-
-// src/services/constants.ts
-import { mkdir as mkdir2 } from "fs/promises";
-var CHUNK_SIZE = 1e3;
-var CHUNK_OVERLAP = 100;
-var SEPARATORS = ["\n\n", "\n", ". ", " ", ""];
-var SUMMARY_MAX_TOKENS = 3e4;
-var SUMMARY_CONCURRENCY = 3;
-var SUMMARY_TARGET_WORDS = 250;
-var resolvePaths = async () => {
-  const config = await loadConfig();
-  const dataDir = config.dataDir;
-  return {
-    dataDir,
-    booksDir: `${dataDir}/books`,
-    vectorsDir: `${dataDir}/vectors`,
-    dbPath: `${dataDir}/metadata.db`
-  };
-};
-var ensureDataDirs = async () => {
-  const paths = await resolvePaths();
-  await mkdir2(paths.dataDir, { recursive: true });
-  await mkdir2(paths.booksDir, { recursive: true });
-  await mkdir2(paths.vectorsDir, { recursive: true });
-  return paths;
-};
-var getModels = async () => {
-  const config = await loadConfig();
-  return config.models;
-};
-var isAskEnabled = async () => {
-  const config = await loadConfig();
-  return config.askEnabled;
-};
-var requireOpenAIKey = () => {
-  if (!process.env.OPENAI_API_KEY) {
-    throw new Error("OPENAI_API_KEY is not set. Export it to use embeddings and chat.");
-  }
-};
-
-// src/services/epub-parser.ts
 var detectNarrativeBoundaries = (chapterTitles) => {
   const frontMatterPattern = /^(about|contents|table of contents|dedication|preface|foreword|title|half.?title|copyright|epigraph|frontispiece|map)/i;
   const backMatterPattern = /^(acknowledgment|afterword|appendix|glossary|index|bibliography|about the author|also by|praise|copyright page|notes|bonus|preview|excerpt|major characters|locations)/i;
@@ -264,7 +153,7 @@ var parseEpub = async (epubPath, resourceSaveDir) => {
 
 // src/services/ingest.ts
 import { randomUUID } from "crypto";
-import { mkdir as mkdir3, unlink, copyFile } from "fs/promises";
+import { mkdir, unlink, copyFile, readFile, writeFile } from "fs/promises";
 
 // src/services/chunker.ts
 var splitRecursive = (text, separators) => {
@@ -338,7 +227,7 @@ import { embedMany } from "ai";
 import { openai } from "@ai-sdk/openai";
 var MAX_TOKENS_PER_BATCH = 25e4;
 var CHARS_PER_TOKEN = 4;
-var embedChunks = async (chunks) => {
+var embedChunks = async (chunks, options) => {
   if (chunks.length === 0) return [];
   const batches = [];
   let currentBatch = [];
@@ -367,10 +256,23 @@ var embedChunks = async (chunks) => {
       model: openai.embeddingModel(models.embedding),
       values: batch.map((chunk) => chunk.content)
     });
+    const embeddedBatch = [];
     for (let j = 0; j < batch.length; j++) {
-      allEmbedded.push({
+      const embeddedChunk = {
         ...batch[j],
         vector: embeddings[j] ?? []
+      };
+      embeddedBatch.push(embeddedChunk);
+      allEmbedded.push({
+        ...embeddedChunk
+      });
+    }
+    if (options?.onBatch) {
+      await options.onBatch(embeddedBatch, {
+        batchIndex: i + 1,
+        batchCount: batches.length,
+        completed: allEmbedded.length,
+        total: chunks.length
       });
     }
   }
@@ -485,8 +387,7 @@ var summarizeSection = async (text, title, sectionNum) => {
     model: openai2(models.summary),
     prompt: `Summarize this section from chapter "${title}" (Part ${sectionNum}). Focus on key events, characters, and revelations. Keep it concise (100-150 words):
 
-${text}`,
-    temperature: 0.3
+${text}`
   });
   return summary;
 };
@@ -495,8 +396,7 @@ var generateStructuredSummary = async (content, title, chapterIndex) => {
     const models = await getModels();
     const { text } = await generateText({
       model: openai2(models.summary),
-      prompt: SUMMARY_PROMPT(title, chapterIndex + 1, content),
-      temperature: 0.3
+      prompt: SUMMARY_PROMPT(title, chapterIndex + 1, content)
     });
     let jsonText = text.trim();
     if (jsonText.startsWith("```json")) {
@@ -550,7 +450,9 @@ var summarizeChapter = async (chapter, chapterIndex) => {
 };
 var summarizeAllChapters = async (chapters) => {
   const summaries = [];
-  logInfo(`[Summarizer] Starting summarization of ${chapters.length} chapters (concurrency: ${SUMMARY_CONCURRENCY})`);
+  logInfo(
+    `[Summarizer] Starting summarization of ${chapters.length} chapters (concurrency: ${SUMMARY_CONCURRENCY})`
+  );
   for (let i = 0; i < chapters.length; i += SUMMARY_CONCURRENCY) {
     const batch = chapters.slice(i, i + SUMMARY_CONCURRENCY);
     const batchPromises = batch.map((chapter, batchIndex) => summarizeChapter(chapter, i + batchIndex));
@@ -566,6 +468,9 @@ var summarizeAllChapters = async (chapters) => {
   return summaries;
 };
 
+// src/db/queries.ts
+import "better-sqlite3";
+
 // src/db/schema.ts
 import Database from "better-sqlite3";
 var resolveDbPath = async () => {
@@ -588,6 +493,27 @@ var createDb = async () => {
       progress_chapter INTEGER
     );
   `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS chat_sessions (
+      id TEXT PRIMARY KEY,
+      book_id TEXT NOT NULL,
+      title TEXT,
+      summary TEXT,
+      created_at INTEGER DEFAULT (strftime('%s','now')),
+      updated_at INTEGER DEFAULT (strftime('%s','now'))
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS chat_messages (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      token_count INTEGER,
+      created_at INTEGER DEFAULT (strftime('%s','now'))
+    );
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS chat_messages_session_idx ON chat_messages(session_id, created_at)");
   const columns = db.prepare("PRAGMA table_info(books)").all().map((col) => col.name);
   const ensureColumn = (name, definition) => {
     if (!columns.includes(name)) {
@@ -599,6 +525,14 @@ var createDb = async () => {
   ensureColumn("summaries", "summaries TEXT");
   ensureColumn("narrative_start_index", "narrative_start_index INTEGER DEFAULT 0");
   ensureColumn("narrative_end_index", "narrative_end_index INTEGER");
+  ensureColumn("batch_id", "batch_id TEXT");
+  ensureColumn("batch_file_id", "batch_file_id TEXT");
+  ensureColumn("batch_chunks", "batch_chunks TEXT");
+  ensureColumn("ingest_state", "ingest_state TEXT");
+  ensureColumn("ingest_resume_path", "ingest_resume_path TEXT");
+  ensureColumn("summary_batch_id", "summary_batch_id TEXT");
+  ensureColumn("summary_batch_file_id", "summary_batch_file_id TEXT");
+  ensureColumn("summary_batch_chapters", "summary_batch_chapters TEXT");
   return db;
 };
 
@@ -615,7 +549,13 @@ var mapRow = (row) => ({
   chapters: row.chapters ? JSON.parse(row.chapters) : [],
   progressChapter: row.progress_chapter ?? null,
   narrativeStartIndex: row.narrative_start_index ?? null,
-  narrativeEndIndex: row.narrative_end_index ?? null
+  narrativeEndIndex: row.narrative_end_index ?? null,
+  batchId: row.batch_id ?? null,
+  batchFileId: row.batch_file_id ?? null,
+  ingestState: row.ingest_state ?? null,
+  ingestResumePath: row.ingest_resume_path ?? null,
+  summaryBatchId: row.summary_batch_id ?? null,
+  summaryBatchFileId: row.summary_batch_file_id ?? null
 });
 var dbPromise = null;
 var getDb = async () => {
@@ -691,6 +631,38 @@ var updateBook = async (id, updates) => {
     fields.push("narrative_end_index = @narrativeEndIndex");
     params.narrativeEndIndex = updates.narrativeEndIndex;
   }
+  if (updates.batchId !== void 0) {
+    fields.push("batch_id = @batchId");
+    params.batchId = updates.batchId;
+  }
+  if (updates.batchFileId !== void 0) {
+    fields.push("batch_file_id = @batchFileId");
+    params.batchFileId = updates.batchFileId;
+  }
+  if (updates.batchChunks !== void 0) {
+    fields.push("batch_chunks = @batchChunks");
+    params.batchChunks = updates.batchChunks;
+  }
+  if (updates.ingestState !== void 0) {
+    fields.push("ingest_state = @ingestState");
+    params.ingestState = updates.ingestState;
+  }
+  if (updates.ingestResumePath !== void 0) {
+    fields.push("ingest_resume_path = @ingestResumePath");
+    params.ingestResumePath = updates.ingestResumePath;
+  }
+  if (updates.summaryBatchId !== void 0) {
+    fields.push("summary_batch_id = @summaryBatchId");
+    params.summaryBatchId = updates.summaryBatchId;
+  }
+  if (updates.summaryBatchFileId !== void 0) {
+    fields.push("summary_batch_file_id = @summaryBatchFileId");
+    params.summaryBatchFileId = updates.summaryBatchFileId;
+  }
+  if (updates.summaryBatchChapters !== void 0) {
+    fields.push("summary_batch_chapters = @summaryBatchChapters");
+    params.summaryBatchChapters = updates.summaryBatchChapters;
+  }
   if (fields.length === 0) return;
   const db = await getDb();
   db.prepare(`UPDATE books SET ${fields.join(", ")} WHERE id = @id`).run(params);
@@ -705,12 +677,135 @@ var getBook = async (id) => {
   const row = db.prepare("SELECT * FROM books WHERE id = ?").get(id);
   return row ? mapRow(row) : null;
 };
+var getBookBatchChunks = async (id) => {
+  const db = await getDb();
+  const row = db.prepare("SELECT batch_chunks FROM books WHERE id = ?").get(id);
+  return row?.batch_chunks ?? null;
+};
+var getBookSummaryBatchChapters = async (id) => {
+  const db = await getDb();
+  const row = db.prepare("SELECT summary_batch_chapters FROM books WHERE id = ?").get(id);
+  return row?.summary_batch_chapters ?? null;
+};
 var deleteBook = async (id) => {
   const db = await getDb();
+  db.prepare("DELETE FROM chat_messages WHERE session_id IN (SELECT id FROM chat_sessions WHERE book_id = ?)").run(id);
+  db.prepare("DELETE FROM chat_sessions WHERE book_id = ?").run(id);
   db.prepare("DELETE FROM books WHERE id = ?").run(id);
 };
+var mapSession = (row) => ({
+  id: row.id,
+  bookId: row.book_id,
+  title: row.title ?? null,
+  summary: row.summary ?? null,
+  createdAt: row.created_at ?? 0,
+  updatedAt: row.updated_at ?? 0
+});
+var mapSessionSummary = (row) => ({
+  ...mapSession(row),
+  bookTitle: row.book_title ?? null
+});
+var mapMessage = (row) => ({
+  id: row.id,
+  sessionId: row.session_id,
+  role: row.role,
+  content: row.content,
+  tokenCount: row.token_count ?? null,
+  createdAt: row.created_at ?? 0
+});
+var insertChatSession = async (session) => {
+  const db = await getDb();
+  db.prepare(
+    "INSERT INTO chat_sessions (id, book_id, title, summary, created_at, updated_at) VALUES (@id, @bookId, @title, @summary, @createdAt, @updatedAt)"
+  ).run({
+    id: session.id,
+    bookId: session.bookId,
+    title: session.title ?? null,
+    summary: session.summary ?? null,
+    createdAt: session.createdAt ?? Date.now(),
+    updatedAt: session.updatedAt ?? Date.now()
+  });
+  return session.id;
+};
+var updateChatSession = async (id, updates) => {
+  const fields = [];
+  const params = { id };
+  if (updates.title !== void 0) {
+    fields.push("title = @title");
+    params.title = updates.title;
+  }
+  if (updates.summary !== void 0) {
+    fields.push("summary = @summary");
+    params.summary = updates.summary;
+  }
+  if (updates.updatedAt !== void 0) {
+    fields.push("updated_at = @updatedAt");
+    params.updatedAt = updates.updatedAt;
+  }
+  if (fields.length === 0) return;
+  const db = await getDb();
+  db.prepare(`UPDATE chat_sessions SET ${fields.join(", ")} WHERE id = @id`).run(params);
+};
+var getChatSession = async (id) => {
+  const db = await getDb();
+  const row = db.prepare("SELECT * FROM chat_sessions WHERE id = ?").get(id);
+  return row ? mapSession(row) : null;
+};
+var listChatSessions = async () => {
+  const db = await getDb();
+  const rows = db.prepare(
+    "SELECT chat_sessions.*, books.title as book_title FROM chat_sessions LEFT JOIN books ON books.id = chat_sessions.book_id ORDER BY chat_sessions.updated_at DESC"
+  ).all();
+  return rows.map(mapSessionSummary);
+};
+var insertChatMessage = async (message) => {
+  const db = await getDb();
+  db.prepare(
+    "INSERT INTO chat_messages (id, session_id, role, content, token_count, created_at) VALUES (@id, @sessionId, @role, @content, @tokenCount, @createdAt)"
+  ).run({
+    id: message.id,
+    sessionId: message.sessionId,
+    role: message.role,
+    content: message.content,
+    tokenCount: message.tokenCount ?? null,
+    createdAt: message.createdAt ?? Date.now()
+  });
+  return message.id;
+};
+var getChatMessages = async (sessionId, limit) => {
+  const db = await getDb();
+  const rows = limit !== void 0 ? db.prepare("SELECT * FROM chat_messages WHERE session_id = ? ORDER BY created_at DESC LIMIT ?").all(sessionId, limit) : db.prepare("SELECT * FROM chat_messages WHERE session_id = ? ORDER BY created_at ASC").all(sessionId);
+  const mapped = rows.map(mapMessage);
+  return limit !== void 0 ? mapped.reverse() : mapped;
+};
 
 // src/services/ingest.ts
+var resumePathForBook = async (bookId) => {
+  const paths = await ensureDataDirs();
+  return `${paths.ingestDir}/${bookId}.json`;
+};
+var loadResumeState = async (bookId, resumePath) => {
+  const raw = await readFile(resumePath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed.chunks) || typeof parsed.resumeIndex !== "number") {
+    throw new Error(`Invalid resume state for book ${bookId}. Re-ingest to start over.`);
+  }
+  return parsed;
+};
+var persistResumeState = async (bookId, state) => {
+  const resumePath = await resumePathForBook(bookId);
+  await writeFile(resumePath, JSON.stringify(state));
+  await updateBook(bookId, {
+    ingestState: "pending",
+    ingestResumePath: resumePath
+  });
+  return resumePath;
+};
+var finalizeResumeState = async (bookId, resumePath) => {
+  const path = resumePath || await resumePathForBook(bookId);
+  await unlink(path).catch(() => void 0);
+  await updateBook(bookId, { ingestState: null, ingestResumePath: null });
+};
 var formatDuration = (ms) => {
   const seconds = Math.round(ms / 100) / 10;
   return `${seconds}s`;
@@ -720,8 +815,9 @@ var ingestEpub = async (filePath, selectedChapterIndices, options) => {
   const paths = await ensureDataDirs();
   const fileName = `${bookId}.epub`;
   const bookPath = `${paths.booksDir}/${fileName}`;
+  let resumePath = null;
   logInfo(`[Ingest] Starting ingestion for book ${bookId}`);
-  await mkdir3(paths.booksDir, { recursive: true });
+  await mkdir(paths.booksDir, { recursive: true });
   await copyFile(filePath, bookPath);
   logInfo(`[Ingest] EPUB file saved to ${bookPath}`);
   const parseStart = Date.now();
@@ -747,7 +843,7 @@ var ingestEpub = async (filePath, selectedChapterIndices, options) => {
     );
     logInfo(`[Ingest] Processing ${chaptersToProcess.length} selected chapters (indices: ${selectedIndices.join(", ")})`);
     let adjustedSummaries = [];
-    if (options?.summarize !== false) {
+    if (options?.summarize !== false && !options?.batch) {
       logInfo(`[Ingest] Generating summaries for ${chaptersToProcess.length} chapters...`);
       const summarizeStart = Date.now();
       const summaries = await summarizeAllChapters(chaptersToProcess);
@@ -775,23 +871,251 @@ var ingestEpub = async (filePath, selectedChapterIndices, options) => {
     );
     const chunks = chunkChapters(bookId, chunksToProcess).filter((chunk) => chunk.content.length > 0);
     logInfo(`[Ingest] Created ${chunks.length} chunks from selected chapters`);
-    const allChunks = [...chunks, ...adjustedSummaries];
-    const embedStart = Date.now();
-    const embedded = await embedChunks(allChunks);
-    logInfo(`[Ingest] Embedded ${embedded.length} total chunks (${formatDuration(Date.now() - embedStart)})`);
-    await addChunksToIndex(bookId, embedded);
-    logInfo(`[Ingest] Added chunks to vector index`);
-    await updateBook(bookId, { chunkCount: embedded.length, indexedAt: Date.now() });
-    logInfo(`[Ingest] Updated book record with chunk count: ${embedded.length}`);
+    if (options?.batch) {
+      if (options?.summarize !== false) {
+        logInfo(`[Ingest] Submitting ${chaptersToProcess.length} chapters for batch summarization`);
+        const { batchId: summaryBatchId, inputFileId: summaryFileId, metadata } = await submitBatchSummaries(chaptersToProcess);
+        await updateBook(bookId, {
+          summaryBatchId,
+          summaryBatchFileId: summaryFileId,
+          summaryBatchChapters: JSON.stringify({ chapters: chaptersToProcess, metadata, selectedIndices, textChunks: chunks })
+        });
+        logInfo(`[Ingest] Summary batch submitted (${summaryBatchId}). Use "mycroft book ingest status ${bookId.slice(0, 8)}" or "mycroft book ingest resume ${bookId.slice(0, 8)}".`);
+      } else {
+        logInfo(`[Ingest] Submitting ${chunks.length} chunks to OpenAI Batch API`);
+        const { batchId, inputFileId } = await submitBatchEmbeddings(chunks);
+        await updateBook(bookId, {
+          batchId,
+          batchFileId: inputFileId,
+          batchChunks: JSON.stringify(chunks)
+        });
+        logInfo(`[Ingest] Batch submitted (${batchId}). Use "mycroft book ingest status ${bookId.slice(0, 8)}" or "mycroft book ingest resume ${bookId.slice(0, 8)}".`);
+      }
+    } else {
+      const allChunks = [...chunks, ...adjustedSummaries];
+      const embedStart = Date.now();
+      resumePath = await persistResumeState(bookId, { chunks: allChunks, resumeIndex: 0 });
+      const embedded = await embedChunks(allChunks, {
+        onBatch: async (embeddedBatch, progress) => {
+          await addChunksToIndex(bookId, embeddedBatch);
+          await updateBook(bookId, { chunkCount: progress.completed });
+          if (!resumePath) return;
+          await writeFile(
+            resumePath,
+            JSON.stringify({ chunks: allChunks, resumeIndex: progress.completed })
+          );
+        }
+      });
+      logInfo(`[Ingest] Embedded ${embedded.length} total chunks (${formatDuration(Date.now() - embedStart)})`);
+      await updateBook(bookId, { chunkCount: embedded.length, indexedAt: Date.now() });
+      logInfo(`[Ingest] Updated book record with chunk count: ${embedded.length}`);
+      await finalizeResumeState(bookId, resumePath);
+    }
   } catch (error) {
     logWarn(`[Ingest] Error during chunking/embedding: ${error instanceof Error ? error.message : String(error)}`);
-    await deleteBookIndex(bookId);
-    await unlink(bookPath).catch(() => void 0);
-    await deleteBook(bookId).catch(() => void 0);
+    if (resumePath) {
+      logWarn(`[Ingest] Partial progress saved. Use "mycroft book ingest status ${bookId.slice(0, 8)}" or "mycroft book ingest resume ${bookId.slice(0, 8)}".`);
+      return { id: bookId, status: "interrupted" };
+    } else {
+      await deleteBookIndex(bookId);
+      await unlink(bookPath).catch(() => void 0);
+      await deleteBook(bookId).catch(() => void 0);
+    }
     throw error;
   }
   logInfo(`[Ingest] Ingestion complete for ${bookId}`);
-  return { id: bookId };
+  return { id: bookId, status: "completed" };
+};
+var resumeIngest = async (bookId, storedChunks, batchId, batchFileId) => {
+  const { checkBatchStatus, downloadBatchResults, cleanupBatchFiles } = await import("./batch-embedder-ZJZLNLOK.js");
+  logInfo(`[Resume] Checking embedding batch ${batchId} for book ${bookId}`);
+  const status = await checkBatchStatus(batchId);
+  logInfo(`[Resume] Batch status: ${status.status} (completed: ${status.completed}/${status.total})`);
+  if (["validating", "in_progress", "finalizing"].includes(status.status)) {
+    return { status: status.status, completed: status.completed, total: status.total };
+  }
+  if (status.status === "failed" || status.status === "expired" || status.status === "cancelled") {
+    logWarn(`[Resume] Batch ${batchId} ended with status "${status.status}". Re-submitting...`);
+    await cleanupBatchFiles(batchFileId, status.outputFileId);
+    const { submitBatchEmbeddings: submitBatchEmbeddings2 } = await import("./batch-embedder-ZJZLNLOK.js");
+    const { batchId: newBatchId, inputFileId: newFileId } = await submitBatchEmbeddings2(storedChunks);
+    await updateBook(bookId, { batchId: newBatchId, batchFileId: newFileId });
+    logInfo(`[Resume] New batch submitted (${newBatchId}). Run resume again later.`);
+    return { status: "resubmitted", batchId: newBatchId };
+  }
+  if (status.status !== "completed") {
+    throw new Error(`Unexpected batch status: ${status.status}`);
+  }
+  if (!status.outputFileId) {
+    logWarn(`[Resume] Batch ${batchId} completed but produced no output (${status.failed}/${status.total} failed). Re-submitting...`);
+    await cleanupBatchFiles(batchFileId, null);
+    const { submitBatchEmbeddings: submitBatchEmbeddings2 } = await import("./batch-embedder-ZJZLNLOK.js");
+    const { batchId: newBatchId, inputFileId: newFileId } = await submitBatchEmbeddings2(storedChunks);
+    await updateBook(bookId, { batchId: newBatchId, batchFileId: newFileId });
+    logInfo(`[Resume] New batch submitted (${newBatchId}). Run resume again later.`);
+    return { status: "resubmitted", batchId: newBatchId };
+  }
+  const embedded = await downloadBatchResults(status.outputFileId, storedChunks);
+  await addChunksToIndex(bookId, embedded);
+  logInfo(`[Resume] Added ${embedded.length} chunks to vector index`);
+  await updateBook(bookId, {
+    chunkCount: embedded.length,
+    indexedAt: Date.now(),
+    batchId: null,
+    batchFileId: null,
+    batchChunks: null
+  });
+  logInfo(`[Resume] Book ${bookId} indexing complete`);
+  await cleanupBatchFiles(batchFileId, status.outputFileId);
+  return { status: "completed" };
+};
+var resumeSummaryBatch = async (bookId, summaryBatchId, summaryBatchFileId, storedData) => {
+  const { checkBatchStatus, cleanupBatchFiles } = await import("./batch-embedder-ZJZLNLOK.js");
+  const { downloadBatchSummaryResults, submitMergePass, downloadMergeResults } = await import("./batch-summarizer-BMIBVFAE.js");
+  logInfo(`[Resume] Checking summary batch ${summaryBatchId} for book ${bookId}`);
+  const status = await checkBatchStatus(summaryBatchId);
+  logInfo(`[Resume] Summary batch status: ${status.status} (completed: ${status.completed}/${status.total})`);
+  if (["validating", "in_progress", "finalizing"].includes(status.status)) {
+    return { status: status.status, completed: status.completed, total: status.total, phase: "summary" };
+  }
+  if (status.status === "failed" || status.status === "expired" || status.status === "cancelled") {
+    logWarn(`[Resume] Summary batch ${summaryBatchId} ended with status "${status.status}". Re-submitting...`);
+    await cleanupBatchFiles(summaryBatchFileId, status.outputFileId);
+    const { submitBatchSummaries: submitBatchSummaries2 } = await import("./batch-summarizer-BMIBVFAE.js");
+    const { batchId: newBatchId, inputFileId: newFileId, metadata: newMetadata } = await submitBatchSummaries2(storedData.chapters);
+    await updateBook(bookId, {
+      summaryBatchId: newBatchId,
+      summaryBatchFileId: newFileId,
+      summaryBatchChapters: JSON.stringify({ ...storedData, metadata: newMetadata })
+    });
+    logInfo(`[Resume] New summary batch submitted (${newBatchId}).`);
+    return { status: "resubmitted", batchId: newBatchId, phase: "summary" };
+  }
+  if (status.status !== "completed") {
+    throw new Error(`Unexpected summary batch status: ${status.status}`);
+  }
+  if (!status.outputFileId) {
+    logWarn(`[Resume] Summary batch ${summaryBatchId} completed but produced no output (${status.failed}/${status.total} failed). Re-submitting...`);
+    await cleanupBatchFiles(summaryBatchFileId, null);
+    const { submitBatchSummaries: submitBatchSummaries2 } = await import("./batch-summarizer-BMIBVFAE.js");
+    const { batchId: newBatchId, inputFileId: newFileId, metadata: newMetadata } = await submitBatchSummaries2(storedData.chapters);
+    await updateBook(bookId, {
+      summaryBatchId: newBatchId,
+      summaryBatchFileId: newFileId,
+      summaryBatchChapters: JSON.stringify({ ...storedData, metadata: newMetadata })
+    });
+    logInfo(`[Resume] New summary batch submitted (${newBatchId}).`);
+    return { status: "resubmitted", batchId: newBatchId, phase: "summary" };
+  }
+  let { summaries, needsMergePass } = await downloadBatchSummaryResults(
+    status.outputFileId,
+    storedData.chapters,
+    storedData.metadata
+  );
+  await cleanupBatchFiles(summaryBatchFileId, status.outputFileId);
+  if (needsMergePass.length > 0) {
+    logInfo(`[Resume] ${needsMergePass.length} chapters need merge pass, submitting merge batch...`);
+    const mergeResult = await submitMergePass(needsMergePass);
+    await updateBook(bookId, {
+      summaryBatchId: mergeResult.batchId,
+      summaryBatchFileId: mergeResult.inputFileId,
+      summaryBatchChapters: JSON.stringify({
+        ...storedData,
+        metadata: mergeResult.metadata,
+        completedSummaries: summaries,
+        isMergePass: true
+      })
+    });
+    return { status: "merge_submitted", batchId: mergeResult.batchId, phase: "summary" };
+  }
+  return await finalizeSummariesAndSubmitEmbeddings(bookId, summaries, storedData);
+};
+var resumeMergeBatch = async (bookId, summaryBatchId, summaryBatchFileId, storedData) => {
+  const { checkBatchStatus, cleanupBatchFiles } = await import("./batch-embedder-ZJZLNLOK.js");
+  const { downloadMergeResults } = await import("./batch-summarizer-BMIBVFAE.js");
+  logInfo(`[Resume] Checking merge batch ${summaryBatchId} for book ${bookId}`);
+  const status = await checkBatchStatus(summaryBatchId);
+  logInfo(`[Resume] Merge batch status: ${status.status} (completed: ${status.completed}/${status.total})`);
+  if (["validating", "in_progress", "finalizing"].includes(status.status)) {
+    return { status: status.status, completed: status.completed, total: status.total, phase: "summary" };
+  }
+  if (status.status !== "completed") {
+    throw new Error(`Unexpected merge batch status: ${status.status}`);
+  }
+  if (!status.outputFileId) {
+    throw new Error(`Merge batch completed but produced no output (${status.failed}/${status.total} failed). Re-ingest to start over.`);
+  }
+  const mergedSummaries = await downloadMergeResults(
+    status.outputFileId,
+    storedData.metadata.map((m) => ({ chapterIndex: m.chapterIndex, title: m.title }))
+  );
+  await cleanupBatchFiles(summaryBatchFileId, status.outputFileId);
+  const allSummaries = [...storedData.completedSummaries || [], ...mergedSummaries];
+  return await finalizeSummariesAndSubmitEmbeddings(bookId, allSummaries, storedData);
+};
+var finalizeSummariesAndSubmitEmbeddings = async (bookId, summaries, storedData) => {
+  const { submitBatchEmbeddings: submitBatchEmbeddings2 } = await import("./batch-embedder-ZJZLNLOK.js");
+  const summaryRecords = summaries.map((s) => ({
+    ...s,
+    chapterIndex: storedData.selectedIndices[s.chapterIndex] ?? s.chapterIndex
+  }));
+  await updateBook(bookId, {
+    summaries: JSON.stringify(summaryRecords)
+  });
+  const summaryChunks = summaryRecords.map((s) => ({
+    id: `${bookId}-summary-${s.chapterIndex}`,
+    bookId,
+    chapterIndex: s.chapterIndex,
+    chapterTitle: s.chapterTitle,
+    chunkIndex: -1,
+    content: s.fullSummary,
+    type: "summary"
+  }));
+  logInfo(`[Resume] Created ${summaryChunks.length} summary chunks from ${summaries.length} summaries`);
+  const allChunks = [...storedData.textChunks, ...summaryChunks];
+  logInfo(`[Resume] Submitting ${allChunks.length} chunks for batch embedding`);
+  const { batchId, inputFileId } = await submitBatchEmbeddings2(allChunks);
+  await updateBook(bookId, {
+    summaryBatchId: null,
+    summaryBatchFileId: null,
+    summaryBatchChapters: null,
+    batchId,
+    batchFileId: inputFileId,
+    batchChunks: JSON.stringify(allChunks)
+  });
+  logInfo(`[Resume] Embedding batch submitted (${batchId}). Run resume again when batch completes.`);
+  return { status: "embeddings_submitted", batchId, phase: "embedding" };
+};
+var resumeLocalIngest = async (bookId, resumePath, currentChunkCount) => {
+  const state = await loadResumeState(bookId, resumePath);
+  const total = state.chunks.length;
+  const startIndex = Math.max(state.resumeIndex, currentChunkCount);
+  if (startIndex >= total) {
+    await finalizeResumeState(bookId, resumePath);
+    throw new Error(`Resume state already completed for book ${bookId}.`);
+  }
+  logInfo(`[Resume] Resuming local embeddings at chunk ${startIndex + 1}/${total}`);
+  const embedStart = Date.now();
+  const remaining = state.chunks.slice(startIndex);
+  const embeddedRemaining = await embedChunks(remaining, {
+    onBatch: async (embeddedBatch, progress) => {
+      const completed = startIndex + progress.completed;
+      await addChunksToIndex(bookId, embeddedBatch);
+      await updateBook(bookId, { chunkCount: completed });
+      await writeFile(
+        resumePath,
+        JSON.stringify({ chunks: state.chunks, resumeIndex: completed })
+      );
+    }
+  });
+  logInfo(`[Resume] Embedded ${embeddedRemaining.length} remaining chunks (${formatDuration(Date.now() - embedStart)})`);
+  const finalCount = startIndex + embeddedRemaining.length;
+  await updateBook(bookId, {
+    chunkCount: finalCount,
+    indexedAt: Date.now()
+  });
+  await finalizeResumeState(bookId, resumePath);
+  return { status: "completed", chunkCount: finalCount };
 };
 
 // src/commands/ingest.ts
@@ -872,17 +1196,51 @@ var ingestCommand = async (filePath, options) => {
       );
     }
   }
-  const result = await ingestEpub(filePath, selectedChapterIndices, { summarize: options.summarize ?? false });
-  stdout(`
+  const result = await ingestEpub(filePath, selectedChapterIndices, { summarize: options.summarize ?? false, batch: options.batch ?? false });
+  const shortId = result.id.slice(0, 8);
+  if (result.status === "interrupted") {
+    stdout(`
+Ingest interrupted.`);
+    stdout(`  mycroft book ingest status ${shortId}   # check progress`);
+    stdout(`  mycroft book ingest resume ${shortId}   # continue ingestion`);
+    return;
+  }
+  if (options.batch) {
+    const batchType = options.summarize ? "Summary batch" : "Embedding batch";
+    stdout(`
+${batchType} submitted. Book registered as ${result.id}`);
+    stdout(`  mycroft book ingest status ${shortId}   # check batch progress`);
+    stdout(`  mycroft book ingest resume ${shortId}   # continue when batch finishes`);
+  } else {
+    stdout(`
 Done. Book indexed as ${result.id}`);
+  }
 };
 
 // src/commands/book/ingest.ts
 var registerBookIngest = (program2) => {
-  program2.command("ingest").description("Ingest an EPUB file").argument("<path>", "Path to the EPUB file").option("--manual", "Interactive chapter selection").option("--summary", "Enable AI chapter summaries").action(async (path, options) => {
+  const ingest = program2.command("ingest").description("Ingest an EPUB file").argument("<path>", "Path to the EPUB file").option("--manual", "Interactive chapter selection").option("--summary", "Enable AI chapter summaries").option("--batch", "Use OpenAI Batch API for embeddings and summaries (50% cost savings, up to 24h)").addHelpText(
+    "after",
+    `
+EXAMPLES
+  mycroft book ingest ./book.epub
+  mycroft book ingest ./book.epub --summary
+  mycroft book ingest ./book.epub --batch --summary
+  mycroft book ingest status 8f2c1a4b
+  mycroft book ingest resume 8f2c1a4b
+
+NOTES
+  --batch submits work to the OpenAI Batch API and returns immediately.
+  When combined with --summary, summaries are batched first, then embeddings.
+  Use "mycroft book ingest status <id>" to check progress.
+  Use "mycroft book ingest resume <id>" to continue when a batch completes.
+  Non-batch ingests can also be resumed if interrupted.
+`
+  ).action(async (path, options) => {
     const summarize = Boolean(options.summary);
-    await ingestCommand(path, { manual: options.manual, summarize });
+    await ingestCommand(path, { manual: options.manual, summarize, batch: options.batch });
   });
+  return ingest;
 };
 
 // src/commands/list.ts
@@ -905,7 +1263,7 @@ var listCommand = async () => {
     const author = book.author || "-";
     const chunks = String(book.chunkCount ?? 0);
     const indexed = formatDate(book.indexedAt);
-    const status = book.indexedAt ? "[indexed]" : "[pending]";
+    const status = book.indexedAt ? "[indexed]" : book.batchId ? "[batch pending]" : book.ingestState === "pending" ? "[resume pending]" : "[pending]";
     stdout(`${shortId} | ${title} | ${author} | ${chunks} | ${indexed} | ${status}`);
   }
 };
@@ -948,6 +1306,7 @@ var showCommand = async (id) => {
   stdout(`Indexed: ${book.indexedAt ? new Date(book.indexedAt).toISOString() : "-"}`);
   stdout(`Narrative range: ${book.narrativeStartIndex ?? 0} to ${book.narrativeEndIndex ?? book.chapters.length - 1}`);
   stdout(`Progress chapter: ${book.progressChapter ?? "-"}`);
+  stdout(`Ingest status: ${book.ingestState ?? "-"}`);
   stdout("\nChapters:");
   book.chapters.forEach((title, index) => {
     const marker = index === book.narrativeStartIndex ? "[start]" : index === book.narrativeEndIndex ? "[end]" : "";
@@ -1035,21 +1394,27 @@ ${context}`
   }
 };
 
+// src/commands/query-options.ts
+var parseQueryOptions = (options) => {
+  const topK = Number(options.topK);
+  if (!Number.isFinite(topK) || topK <= 0) {
+    throw new Error("--top-k must be a positive number.");
+  }
+  let maxChapter;
+  if (options.maxChapter !== void 0) {
+    const parsed = Number(options.maxChapter);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+      throw new Error("--max-chapter must be a non-negative number.");
+    }
+    maxChapter = parsed;
+  }
+  return { topK, maxChapter };
+};
+
 // src/commands/book/ask.ts
 var registerBookAsk = (program2) => {
   program2.command("ask").description("Ask a question about a book").argument("<id>", "Book id or prefix").argument("<question>", "Question to ask").option("--top-k <n>", "Number of passages to retrieve", "5").option("--max-chapter <n>", "Spoiler-free limit (0-based within narrative)").action(async (id, question, options) => {
-    const topK = Number(options.topK);
-    if (!Number.isFinite(topK) || topK <= 0) {
-      throw new Error("--top-k must be a positive number.");
-    }
-    let maxChapter;
-    if (options.maxChapter !== void 0) {
-      const parsed = Number(options.maxChapter);
-      if (!Number.isFinite(parsed) || parsed < 0) {
-        throw new Error("--max-chapter must be a non-negative number.");
-      }
-      maxChapter = parsed;
-    }
+    const { topK, maxChapter } = parseQueryOptions(options);
     await askCommand(id, question, { topK, maxChapter });
   });
 };
@@ -1092,18 +1457,7 @@ var searchCommand = async (id, query, options) => {
 // src/commands/book/search.ts
 var registerBookSearch = (program2) => {
   program2.command("search").description("Vector search without LLM").argument("<id>", "Book id or prefix").argument("<query>", "Search query").option("--top-k <n>", "Number of passages to retrieve", "5").option("--max-chapter <n>", "Spoiler-free limit (0-based within narrative)").action(async (id, query, options) => {
-    const topK = Number(options.topK);
-    if (!Number.isFinite(topK) || topK <= 0) {
-      throw new Error("--top-k must be a positive number.");
-    }
-    let maxChapter;
-    if (options.maxChapter !== void 0) {
-      const parsed = Number(options.maxChapter);
-      if (!Number.isFinite(parsed) || parsed < 0) {
-        throw new Error("--max-chapter must be a non-negative number.");
-      }
-      maxChapter = parsed;
-    }
+    const { topK, maxChapter } = parseQueryOptions(options);
     await searchCommand(id, query, { topK, maxChapter });
   });
 };
@@ -1145,6 +1499,216 @@ var registerBookDelete = (program2) => {
   });
 };
 
+// src/commands/resume.ts
+var resumeCommand = async (id) => {
+  requireOpenAIKey();
+  await ensureDataDirs();
+  const resolvedId = await resolveBookId(id);
+  if (!resolvedId) {
+    throw new Error(`Book not found: ${id}`);
+  }
+  const book = await getBook(resolvedId);
+  if (!book) {
+    throw new Error(`Book not found: ${id}`);
+  }
+  if (book.indexedAt) {
+    stdout(`Book "${book.title}" is already indexed (${book.chunkCount} chunks).`);
+    return;
+  }
+  const shortId = resolvedId.slice(0, 8);
+  if (book.summaryBatchId) {
+    const rawData = await getBookSummaryBatchChapters(resolvedId);
+    if (!rawData) {
+      throw new Error(`No stored summary batch data for book "${book.title}". Re-ingest with "mycroft book ingest --batch --summary".`);
+    }
+    const storedData = JSON.parse(rawData);
+    let result2;
+    if (storedData.isMergePass) {
+      result2 = await resumeMergeBatch(resolvedId, book.summaryBatchId, book.summaryBatchFileId ?? book.summaryBatchId, storedData);
+    } else {
+      result2 = await resumeSummaryBatch(resolvedId, book.summaryBatchId, book.summaryBatchFileId ?? book.summaryBatchId, storedData);
+    }
+    if (result2.status === "embeddings_submitted") {
+      stdout(`
+Summaries complete. Embedding batch submitted (${result2.batchId}).`);
+      stdout(`  mycroft book ingest status ${shortId}   # check embedding batch progress`);
+      stdout(`  mycroft book ingest resume ${shortId}   # complete ingestion once batch finishes`);
+    } else if (result2.status === "merge_submitted") {
+      stdout(`
+Section summaries complete. Merge batch submitted (${result2.batchId}).`);
+      stdout(`  mycroft book ingest status ${shortId}   # check merge batch progress`);
+      stdout(`  mycroft book ingest resume ${shortId}   # continue when batch finishes`);
+    } else if (result2.status === "resubmitted") {
+      stdout(`
+Summary batch failed and was re-submitted (${result2.batchId}).`);
+      stdout(`  mycroft book ingest status ${shortId}   # check batch progress`);
+      stdout(`  mycroft book ingest resume ${shortId}   # continue when batch finishes`);
+    } else {
+      stdout(`
+Summary batch still in progress (${result2.status}: ${result2.completed}/${result2.total}).`);
+      stdout(`  mycroft book ingest status ${shortId}   # check batch progress`);
+      stdout(`  mycroft book ingest resume ${shortId}   # retry when batch finishes`);
+    }
+    return;
+  }
+  if (book.batchId) {
+    const rawChunks = await getBookBatchChunks(resolvedId);
+    if (!rawChunks) {
+      throw new Error(`No stored chunks found for book "${book.title}". Re-ingest with "mycroft book ingest --batch".`);
+    }
+    const chunks = JSON.parse(rawChunks);
+    const result2 = await resumeIngest(resolvedId, chunks, book.batchId, book.batchFileId ?? book.batchId);
+    if (result2.status === "completed") {
+      stdout(`
+Done. Book "${book.title}" indexed as ${book.id}`);
+    } else if (result2.status === "resubmitted") {
+      stdout(`
+Batch failed and was re-submitted (${result2.batchId}).`);
+      stdout(`  mycroft book ingest status ${shortId}   # check batch progress`);
+      stdout(`  mycroft book ingest resume ${shortId}   # complete ingestion once batch finishes`);
+    } else {
+      stdout(`
+Batch still in progress (${result2.status}: ${result2.completed}/${result2.total}).`);
+      stdout(`  mycroft book ingest status ${shortId}   # check batch progress`);
+      stdout(`  mycroft book ingest resume ${shortId}   # retry when batch finishes`);
+    }
+    return;
+  }
+  if (!book.ingestResumePath || book.ingestState !== "pending") {
+    throw new Error(`Book "${book.title}" has no resumable ingest. Re-ingest to start one.`);
+  }
+  const result = await resumeLocalIngest(resolvedId, book.ingestResumePath, book.chunkCount ?? 0);
+  if (result.status === "completed") {
+    stdout(`
+Done. Book "${book.title}" indexed as ${book.id}`);
+  }
+};
+
+// src/commands/book/resume.ts
+var registerBookResume = (program2, ingest) => {
+  const target = ingest ?? program2.command("ingest");
+  target.command("resume").description("Resume a pending ingestion").argument("<id>", "Book id or prefix").addHelpText(
+    "after",
+    `
+EXAMPLES
+  mycroft book ingest resume 8f2c1a4b
+
+NOTES
+  Resumes either batch or non-batch ingests if interrupted.
+`
+  ).action(async (id) => {
+    await resumeCommand(id);
+  });
+};
+
+// src/commands/status.ts
+var statusCommand = async (id) => {
+  await ensureDataDirs();
+  const resolvedId = await resolveBookId(id);
+  if (!resolvedId) {
+    throw new Error(`Book not found: ${id}`);
+  }
+  const book = await getBook(resolvedId);
+  if (!book) {
+    throw new Error(`Book not found: ${id}`);
+  }
+  const shortId = resolvedId.slice(0, 8);
+  stdout(`Book: ${book.title}`);
+  stdout(`ID:   ${book.id}`);
+  if (book.indexedAt) {
+    stdout(`
+Status: completed`);
+    stdout(`Chunks: ${book.chunkCount}`);
+    stdout(`Indexed: ${new Date(book.indexedAt).toLocaleString()}`);
+    return;
+  }
+  if (book.summaryBatchId) {
+    requireOpenAIKey();
+    const { checkBatchStatus } = await import("./batch-embedder-ZJZLNLOK.js");
+    const status = await checkBatchStatus(book.summaryBatchId);
+    stdout(`
+Status: summary batch ${status.status}`);
+    stdout(`Batch:  ${book.summaryBatchId}`);
+    stdout(`Progress: ${status.completed}/${status.total} requests${status.failed > 0 ? ` (${status.failed} failed)` : ""}`);
+    if (status.status === "completed") {
+      if (status.failed > 0 && status.completed === 0) {
+        stdout(`
+All requests failed. Run resume to re-submit.`);
+      } else {
+        stdout(`
+Summary batch is ready.`);
+      }
+      stdout(`  mycroft book ingest resume ${shortId}   # process summaries and submit embedding batch`);
+    } else if (["failed", "expired", "cancelled"].includes(status.status)) {
+      stdout(`
+Summary batch ended with "${status.status}".`);
+      stdout(`  mycroft book ingest resume ${shortId}   # re-submit summary batch`);
+    } else {
+      stdout(`
+Summary batch still processing.`);
+      stdout(`  mycroft book ingest status ${shortId}   # check again later`);
+      stdout(`  mycroft book ingest resume ${shortId}   # resume when ready`);
+    }
+    return;
+  }
+  if (book.batchId) {
+    requireOpenAIKey();
+    const { checkBatchStatus } = await import("./batch-embedder-ZJZLNLOK.js");
+    const status = await checkBatchStatus(book.batchId);
+    stdout(`
+Status: embedding batch ${status.status}`);
+    stdout(`Batch:  ${book.batchId}`);
+    stdout(`Progress: ${status.completed}/${status.total} requests${status.failed > 0 ? ` (${status.failed} failed)` : ""}`);
+    if (status.status === "completed") {
+      if (status.failed > 0 && status.completed === 0) {
+        stdout(`
+All requests failed. Run resume to re-submit.`);
+      } else {
+        stdout(`
+Embedding batch is ready.`);
+      }
+      stdout(`  mycroft book ingest resume ${shortId}   # complete indexing`);
+    } else if (["failed", "expired", "cancelled"].includes(status.status)) {
+      stdout(`
+Embedding batch ended with "${status.status}".`);
+      stdout(`  mycroft book ingest resume ${shortId}   # re-submit embedding batch`);
+    } else {
+      stdout(`
+Embedding batch still processing.`);
+      stdout(`  mycroft book ingest status ${shortId}   # check again later`);
+      stdout(`  mycroft book ingest resume ${shortId}   # resume when ready`);
+    }
+    return;
+  }
+  if (book.ingestResumePath && book.ingestState === "pending") {
+    stdout(`
+Status: interrupted`);
+    stdout(`Chunks completed: ${book.chunkCount}`);
+    stdout(`  mycroft book ingest resume ${shortId}   # continue ingestion`);
+    return;
+  }
+  stdout(`
+Status: no active ingestion`);
+};
+
+// src/commands/book/status.ts
+var registerBookStatus = (program2, ingest) => {
+  const target = ingest ?? program2.command("ingest");
+  target.command("status").description("Check ingestion status for a book").argument("<id>", "Book id or prefix").addHelpText(
+    "after",
+    `
+EXAMPLES
+  mycroft book ingest status 8f2c1a4b
+
+NOTES
+  For batch ingests, queries the OpenAI API for live progress.
+  For local ingests, shows how many chunks have been completed.
+`
+  ).action(async (id) => {
+    await statusCommand(id);
+  });
+};
+
 // src/commands/config.ts
 var configCommand = async () => {
   const path = configPath();
@@ -1159,7 +1723,7 @@ var registerConfigPath = (program2) => {
 };
 
 // src/commands/init-config.ts
-import { mkdir as mkdir4, writeFile, access as access2 } from "fs/promises";
+import { mkdir as mkdir2, writeFile as writeFile2, access as access2 } from "fs/promises";
 var initConfigCommand = async () => {
   const path = configPath();
   await ensureConfigDirs(path);
@@ -1175,8 +1739,8 @@ var initConfigCommand = async () => {
     askEnabled: resolved.askEnabled,
     models: resolved.models
   };
-  await writeFile(path, JSON.stringify(template, null, 2), "utf-8");
-  await mkdir4(resolved.dataDir, { recursive: true });
+  await writeFile2(path, JSON.stringify(template, null, 2), "utf-8");
+  await mkdir2(resolved.dataDir, { recursive: true });
   stdout(`Created config at ${path}`);
 };
 
@@ -1205,7 +1769,7 @@ var registerConfigResolve = (program2) => {
 };
 
 // src/commands/onboard.ts
-import { writeFile as writeFile2 } from "fs/promises";
+import { writeFile as writeFile3 } from "fs/promises";
 var isDefault = (input) => input === "" || input.toLowerCase() === "-y";
 var parseBoolean = (input, fallback) => {
   if (isDefault(input)) return fallback;
@@ -1233,7 +1797,7 @@ var onboardCommand = async () => {
   const chatInput = await prompt(`Chat model [${defaults.models.chat}]: `);
   const chat = isDefault(chatInput) ? defaults.models.chat : chatInput;
   await ensureConfigDirs(path);
-  await writeFile2(
+  await writeFile3(
     path,
     JSON.stringify(
       {
@@ -1269,11 +1833,293 @@ var registerConfigOnboard = (program2) => {
   });
 };
 
+// src/services/chat.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { embed as embed3, generateText as generateText2 } from "ai";
+import { openai as openai5 } from "@ai-sdk/openai";
+var MAX_RECENT_MESSAGES = 12;
+var SUMMARY_TRIGGER_MESSAGES = 24;
+var SUMMARY_TARGET_WORDS2 = 160;
+var formatContext2 = (chunks) => chunks.map(
+  (chunk, index) => `Excerpt [${index + 1}] (${chunk.chapterTitle || `Chapter ${chunk.chapterIndex + 1}`}):
+${chunk.content}`
+).join("\n\n");
+var estimateTokens2 = (text) => Math.ceil(text.length / 4);
+var summarizeMessages = async (messages) => {
+  const transcript = messages.map((message) => `${message.role.toUpperCase()}: ${message.content}`).join("\n\n");
+  const models = await getModels();
+  const { text } = await generateText2({
+    model: openai5(models.summary),
+    prompt: `Summarize this conversation so far in ~${SUMMARY_TARGET_WORDS2} words. Focus on facts, decisions, and unresolved questions.
+
+${transcript}`
+  });
+  return text.trim();
+};
+var buildConversationContext = (session, messages) => {
+  const summary = session.summary ? `Conversation summary:
+${session.summary}` : "";
+  const recent = messages.slice(-MAX_RECENT_MESSAGES).map((message) => `${message.role.toUpperCase()}: ${message.content}`).join("\n\n");
+  return [summary, recent].filter(Boolean).join("\n\n");
+};
+var maybeSummarizeSession = async (session, messages, updatedAt) => {
+  if (messages.length < SUMMARY_TRIGGER_MESSAGES) return;
+  const summary = await summarizeMessages(messages.slice(0, -MAX_RECENT_MESSAGES));
+  await updateChatSession(session.id, { summary, updatedAt });
+};
+var listSessions = async () => listChatSessions();
+var getSession = async (id) => getChatSession(id);
+var getSessionMessages = async (sessionId, limit) => getChatMessages(sessionId, limit);
+var startSession = async (bookId, title) => {
+  await ensureDataDirs();
+  const resolvedId = await resolveBookId(bookId);
+  if (!resolvedId) {
+    throw new Error(`Book not found: ${bookId}`);
+  }
+  const sessionId = randomUUID2();
+  await insertChatSession({
+    id: sessionId,
+    bookId: resolvedId,
+    title: title ?? null,
+    summary: null
+  });
+  const session = await getChatSession(sessionId);
+  if (!session) {
+    throw new Error("Failed to create chat session.");
+  }
+  return session;
+};
+var chatAsk = async (sessionId, question, options) => {
+  if (!await isAskEnabled()) {
+    throw new Error("Ask is disabled in config (askEnabled: false). Enable it to use this command.");
+  }
+  requireOpenAIKey();
+  await ensureDataDirs();
+  const session = await getChatSession(sessionId);
+  if (!session) {
+    throw new Error(`Chat session not found: ${sessionId}`);
+  }
+  const book = await getBook(session.bookId);
+  if (!book) {
+    throw new Error(`Book not found: ${session.bookId}`);
+  }
+  const models = await getModels();
+  const { embedding } = await embed3({
+    model: openai5.embeddingModel(models.embedding),
+    value: question
+  });
+  const narrativeStart = book.narrativeStartIndex ?? 0;
+  const userProgress = book.progressChapter ?? null;
+  const maxChapterIndex = options.maxChapter !== void 0 ? narrativeStart + options.maxChapter : userProgress !== null ? narrativeStart + userProgress : void 0;
+  const retrievalLimit = options.topK * 3;
+  const allMatches = await queryBookIndex(session.bookId, embedding, question, retrievalLimit, maxChapterIndex);
+  const summaries = allMatches.filter((m) => m.type === "summary");
+  const chunks = allMatches.filter((m) => m.type !== "summary");
+  const topSummaries = summaries.slice(0, 2);
+  const topChunks = chunks.slice(0, Math.max(0, options.topK - topSummaries.length));
+  const selectedMatches = [...topSummaries, ...topChunks];
+  const context = formatContext2(selectedMatches);
+  const messages = await getChatMessages(sessionId);
+  const conversation = buildConversationContext(session, messages);
+  const now = Date.now();
+  const userMessage = {
+    id: randomUUID2(),
+    sessionId,
+    role: "user",
+    content: question,
+    tokenCount: estimateTokens2(question),
+    createdAt: now
+  };
+  await insertChatMessage(userMessage);
+  const prompt2 = [
+    conversation ? `Conversation:
+${conversation}` : "",
+    `Question: ${question}`,
+    context
+  ].filter(Boolean).join("\n\n");
+  const { text } = await generateText2({
+    model: openai5(models.chat),
+    system: `You are a reading companion helping readers understand this book.
+
+Guidelines:
+- Use the provided chapter summaries and excerpts to answer questions
+- Chapter summaries provide high-level context about characters, events, and plot
+- Excerpts provide specific details and quotes
+- When asked for recaps or "what happened", synthesize from summaries
+- Don't cite table of contents, front matter, or structural elements
+- If truly unsure, briefly say so - but try to answer from available context first
+- Cite sources using [1], [2], etc. at the end of relevant sentences
+- The context may be limited to earlier chapters only - don't infer beyond what's provided`,
+    prompt: prompt2
+  });
+  const assistantMessage = {
+    id: randomUUID2(),
+    sessionId,
+    role: "assistant",
+    content: text,
+    tokenCount: estimateTokens2(text),
+    createdAt: now
+  };
+  await insertChatMessage(assistantMessage);
+  const updatedAt = Date.now();
+  await updateChatSession(sessionId, { updatedAt });
+  await maybeSummarizeSession(session, [...messages, userMessage, assistantMessage], updatedAt);
+  return { answer: text, sources: selectedMatches };
+};
+
+// src/commands/chat/start.ts
+var registerChatStart = (program2) => {
+  program2.command("start").description("Start a chat session for a book").argument("<id>", "Book id or prefix").option("--title <title>", "Session title").action(async (id, options) => {
+    const session = await startSession(id, options.title);
+    stdout(`Started chat session ${session.id} for book ${session.bookId}`);
+  });
+};
+
+// src/commands/chat/utils.ts
+var resolveChatSessionId = async (input) => {
+  const sessions = await listChatSessions();
+  const exact = sessions.find((session) => session.id === input);
+  if (exact) return exact.id;
+  const matches = sessions.filter((session) => session.id.startsWith(input));
+  if (matches.length === 1) return matches[0].id;
+  if (matches.length > 1) {
+    throw new Error(`Ambiguous session id prefix "${input}" (${matches.length} matches)`);
+  }
+  return null;
+};
+
+// src/commands/chat/ask.ts
+var registerChatAsk = (program2) => {
+  program2.command("ask").description("Ask a question in a chat session").argument("<session>", "Chat session id or prefix").argument("<question>", "Question to ask").option("--top-k <n>", "Number of passages to retrieve", "5").option("--max-chapter <n>", "Spoiler-free limit (0-based within narrative)").action(async (sessionId, question, options) => {
+    const { topK, maxChapter } = parseQueryOptions(options);
+    const resolvedId = await resolveChatSessionId(sessionId);
+    if (!resolvedId) {
+      throw new Error(`Chat session not found: ${sessionId}`);
+    }
+    const { answer, sources } = await chatAsk(resolvedId, question, { topK, maxChapter });
+    stdout(answer);
+    if (sources.length > 0) {
+      stdout("\nSources:");
+      sources.forEach((match, index) => {
+        const title = match.chapterTitle || `Chapter ${match.chapterIndex + 1}`;
+        const excerpt = match.content.slice(0, 120).replace(/\s+/g, " ");
+        stdout(`[${index + 1}] ${title}: ${excerpt}`);
+      });
+    }
+  });
+};
+
+// src/commands/chat/list.ts
+var formatDate2 = (timestamp) => {
+  if (!timestamp) return "-";
+  return new Date(timestamp).toISOString().slice(0, 10);
+};
+var registerChatList = (program2) => {
+  program2.command("list").description("List chat sessions").action(async () => {
+    const sessions = await listSessions();
+    if (sessions.length === 0) {
+      stdout("No chat sessions yet.");
+      return;
+    }
+    stdout("ID       | Book | Updated | Title");
+    stdout("---------|------|---------|------");
+    for (const session of sessions) {
+      const shortId = session.id.slice(0, 8);
+      const book = session.bookTitle || session.bookId.slice(0, 8);
+      const updated = formatDate2(session.updatedAt);
+      const title = session.title || "-";
+      stdout(`${shortId} | ${book} | ${updated} | ${title}`);
+    }
+  });
+};
+
+// src/commands/chat/show.ts
+var registerChatShow = (program2) => {
+  program2.command("show").description("Show chat session details").argument("<session>", "Chat session id or prefix").option("--tail <n>", "Show last N messages", "10").action(async (sessionId, options) => {
+    const tail = Number(options.tail);
+    if (!Number.isFinite(tail) || tail <= 0) {
+      throw new Error("--tail must be a positive number.");
+    }
+    const resolvedId = await resolveChatSessionId(sessionId);
+    if (!resolvedId) {
+      throw new Error(`Chat session not found: ${sessionId}`);
+    }
+    const session = await getSession(resolvedId);
+    if (!session) {
+      throw new Error(`Chat session not found: ${sessionId}`);
+    }
+    stdout(`ID: ${session.id}`);
+    stdout(`Book ID: ${session.bookId}`);
+    stdout(`Title: ${session.title ?? "-"}`);
+    const updated = session.updatedAt ? new Date(session.updatedAt).toISOString() : "-";
+    stdout(`Updated: ${updated}`);
+    const messages = await getSessionMessages(resolvedId, tail);
+    if (messages.length === 0) {
+      stdout("\nNo messages yet.");
+      return;
+    }
+    stdout("\nMessages:");
+    messages.forEach((message) => {
+      stdout(`[${message.role}] ${message.content}`);
+    });
+  });
+};
+
+// src/commands/chat/repl.ts
+var shouldExit = (input) => {
+  const normalized = input.trim().toLowerCase();
+  return normalized === "exit" || normalized === "quit" || normalized === ":q";
+};
+var registerChatRepl = (program2) => {
+  program2.command("repl").description("Start interactive chat session").argument("<session>", "Chat session id or prefix").option("--top-k <n>", "Number of passages to retrieve", "5").option("--max-chapter <n>", "Spoiler-free limit (0-based within narrative)").action(async (sessionId, options) => {
+    if (!isInteractive()) {
+      throw new Error("Chat repl requires an interactive terminal.");
+    }
+    const { topK, maxChapter } = parseQueryOptions(options);
+    const resolvedId = await resolveChatSessionId(sessionId);
+    if (!resolvedId) {
+      throw new Error(`Chat session not found: ${sessionId}`);
+    }
+    const session = await getSession(resolvedId);
+    if (!session) {
+      throw new Error(`Chat session not found: ${sessionId}`);
+    }
+    stdout(`Chatting in session ${session.id}. Type 'exit' to quit.`);
+    while (true) {
+      const question = await prompt("You: ");
+      if (!question.trim()) continue;
+      if (shouldExit(question)) break;
+      const { answer, sources } = await chatAsk(session.id, question, { topK, maxChapter });
+      stdout(`
+${answer}`);
+      if (sources.length > 0) {
+        stdout("\nSources:");
+        sources.forEach((match, index) => {
+          const title = match.chapterTitle || `Chapter ${match.chapterIndex + 1}`;
+          const excerpt = match.content.slice(0, 120).replace(/\s+/g, " ");
+          stdout(`[${index + 1}] ${title}: ${excerpt}`);
+        });
+      }
+      stdout("");
+    }
+  });
+};
+
+// src/commands/chat/index.ts
+var registerChatCommands = (program2) => {
+  const chat = program2.command("chat").description("Run multi-turn chat sessions");
+  registerChatStart(chat);
+  registerChatAsk(chat);
+  registerChatList(chat);
+  registerChatShow(chat);
+  registerChatRepl(chat);
+};
+
 // src/cli.ts
 var resolveVersion = async () => {
   try {
-    const currentDir = dirname2(fileURLToPath(import.meta.url));
-    const pkgPath = resolve2(currentDir, "../package.json");
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = resolve(currentDir, "../package.json");
     const raw = await readFile2(pkgPath, "utf-8");
     return JSON.parse(raw).version || "0.1.0";
   } catch {
@@ -1291,17 +2137,20 @@ var configureProgram = async () => {
 };
 var registerCommands = () => {
   const book = program.command("book").description("Manage books and queries");
-  registerBookIngest(book);
+  const ingest = registerBookIngest(book);
   registerBookList(book);
   registerBookShow(book);
   registerBookAsk(book);
   registerBookSearch(book);
   registerBookDelete(book);
+  registerBookResume(book, ingest);
+  registerBookStatus(book, ingest);
   const config = program.command("config").description("Manage configuration");
   registerConfigPath(config);
   registerConfigInit(config);
   registerConfigResolve(config);
   registerConfigOnboard(config);
+  registerChatCommands(program);
 };
 program.exitOverride((error) => {
   if (error.code === "commander.helpDisplayed") {