@fs/mycroft 0.2.0 → 0.4.0

package/dist/cli.js

@@ -1,154 +1,47 @@
 #!/usr/bin/env node
+import {
+  submitBatchEmbeddings
+} from "./chunk-VBEGUDHG.js";
+import {
+  CHARS_PER_TOKEN,
+  SUMMARY_PROMPT,
+  parseStructuredSummary,
+  splitIntoSections,
+  submitBatchSummaries
+} from "./chunk-T6X7DRBN.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-LV52FEMB.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;
@@ -200,8 +93,9 @@ var createWarnFilter = () => {
 var parseEpub = async (epubPath, resourceSaveDir) => {
   logInfo(`[EPUB Parser] Starting parse for: ${basename(epubPath)}`);
   const suppressedWarnings = createWarnFilter();
+  let epubFile = null;
   try {
-    const epubFile = await initEpubFile(epubPath, resourceSaveDir);
+    epubFile = await initEpubFile(epubPath, resourceSaveDir);
     await epubFile.loadEpub();
     logInfo(`[EPUB Parser] EPUB loaded successfully`);
     await epubFile.parse();
@@ -243,7 +137,6 @@ var parseEpub = async (epubPath, resourceSaveDir) => {
       });
       chapterTitles.push(chapterTitle);
     }
-    epubFile.destroy();
     const author = safeMetadata.creator?.[0]?.contributor ?? null;
     logInfo(`[EPUB Parser] Extracted ${chapters.length} chapters with content`);
     logInfo(`[EPUB Parser] Title: "${safeMetadata.title || fileBaseName || "Untitled"}", Author: "${author || "Unknown"}"`);
@@ -258,13 +151,14 @@ var parseEpub = async (epubPath, resourceSaveDir) => {
       narrativeEndIndex
     };
   } finally {
+    epubFile?.destroy();
     console.warn = originalWarn;
   }
 };
 
 // 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) => {
@@ -337,14 +231,14 @@ var chunkChapters = (bookId, chapters) => {
 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 CHARS_PER_TOKEN2 = 4;
+var embedChunks = async (chunks, options) => {
   if (chunks.length === 0) return [];
   const batches = [];
   let currentBatch = [];
   let currentTokens = 0;
   for (const chunk of chunks) {
-    const estimatedTokens = Math.ceil(chunk.content.length / CHARS_PER_TOKEN);
+    const estimatedTokens = Math.ceil(chunk.content.length / CHARS_PER_TOKEN2);
     if (currentTokens + estimatedTokens > MAX_TOKENS_PER_BATCH && currentBatch.length > 0) {
       batches.push(currentBatch);
       currentBatch = [];
@@ -361,16 +255,33 @@ var embedChunks = async (chunks) => {
   const models = await getModels();
   for (let i = 0; i < batches.length; i++) {
     const batch = batches[i];
-    const estimatedTokens = batch.reduce((sum, c) => sum + Math.ceil(c.content.length / CHARS_PER_TOKEN), 0);
+    const estimatedTokens = batch.reduce((sum, c) => sum + Math.ceil(c.content.length / CHARS_PER_TOKEN2), 0);
     logInfo(`[Embedder] Batch ${i + 1}/${batches.length}: ${batch.length} chunks (~${estimatedTokens.toLocaleString()} tokens)`);
     const { embeddings } = await embedMany({
       model: openai.embeddingModel(models.embedding),
       values: batch.map((chunk) => chunk.content)
     });
+    const embeddedBatch = [];
     for (let j = 0; j < batch.length; j++) {
-      allEmbedded.push({
+      const vector = embeddings[j] ?? [];
+      if (vector.length === 0) {
+        logWarn(`[Embedder] Chunk ${allEmbedded.length + j} has empty embedding`);
+      }
+      const embeddedChunk = {
         ...batch[j],
-        vector: embeddings[j] ?? []
+        vector
+      };
+      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
       });
     }
   }
@@ -380,11 +291,14 @@ var embedChunks = async (chunks) => {
 
 // src/services/vector-store.ts
 import { LocalIndex } from "vectra";
+var indexCache = /* @__PURE__ */ new Map();
 var indexPathForBook = async (bookId) => {
   const paths = await ensureDataDirs();
   return `${paths.vectorsDir}/${bookId}`;
 };
 var createBookIndex = async (bookId) => {
+  const cached = indexCache.get(bookId);
+  if (cached) return cached;
   const index = new LocalIndex(await indexPathForBook(bookId));
   const exists = await index.isIndexCreated();
   if (!exists) {
@@ -395,6 +309,7 @@ var createBookIndex = async (bookId) => {
       }
     });
   }
+  indexCache.set(bookId, index);
   return index;
 };
 var addChunksToIndex = async (bookId, chunks) => {
@@ -434,6 +349,7 @@ var queryBookIndex = async (bookId, queryVector, queryText, topK, maxChapterInde
   return mapped.filter((item) => item.chapterIndex <= maxChapterIndex).slice(0, topK);
 };
 var deleteBookIndex = async (bookId) => {
+  indexCache.delete(bookId);
   const index = new LocalIndex(await indexPathForBook(bookId));
   const exists = await index.isIndexCreated();
   if (!exists) return;
@@ -443,50 +359,14 @@ var deleteBookIndex = async (bookId) => {
 // src/services/summarizer.ts
 import { generateText } from "ai";
 import { openai as openai2 } from "@ai-sdk/openai";
-var CHARS_PER_TOKEN2 = 4;
-var estimateTokens = (text) => Math.ceil(text.length / CHARS_PER_TOKEN2);
-var SUMMARY_PROMPT = (title, chapterNum, content) => `You are analyzing a chapter from a book (fiction or nonfiction). Extract key information to help readers understand the chapter's content.
-
-Chapter Title: ${title}
-Chapter Number: ${chapterNum}
-
----
-${content}
----
-
-Extract the following information and respond ONLY with valid JSON (no markdown, no code blocks):
-
-{
-  "characters": ["Name - brief description (role, traits, first appearance)", ...],
-  "events": "What happens in this chapter? (2-3 sentences)",
-  "setting": "Where does this chapter take place?",
-  "revelations": "Any important information revealed? (secrets, backstory, foreshadowing)"
-}
-
-Keep the total response around ${SUMMARY_TARGET_WORDS} words.`;
-var splitIntoSections = (text, maxTokens) => {
-  const estimatedTokens = estimateTokens(text);
-  if (estimatedTokens <= maxTokens) {
-    return [text];
-  }
-  const numSections = Math.ceil(estimatedTokens / maxTokens);
-  const charsPerSection = Math.floor(text.length / numSections);
-  const sections = [];
-  for (let i = 0; i < numSections; i++) {
-    const start = i * charsPerSection;
-    const end = i === numSections - 1 ? text.length : (i + 1) * charsPerSection;
-    sections.push(text.slice(start, end));
-  }
-  return sections;
-};
+var estimateTokens = (text) => Math.ceil(text.length / CHARS_PER_TOKEN);
 var summarizeSection = async (text, title, sectionNum) => {
   const models = await getModels();
   const { text: summary } = await generateText({
     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,34 +375,9 @@ 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, SUMMARY_TARGET_WORDS)
     });
-    let jsonText = text.trim();
-    if (jsonText.startsWith("```json")) {
-      jsonText = jsonText.slice(7, -3).trim();
-    } else if (jsonText.startsWith("```")) {
-      jsonText = jsonText.slice(3, -3).trim();
-    }
-    const parsed = JSON.parse(jsonText);
-    const fullSummary = `Chapter ${chapterIndex + 1}: ${title}
-
-Characters: ${parsed.characters.join(", ")}
-
-Events: ${parsed.events}
-
-Setting: ${parsed.setting}
-
-Revelations: ${parsed.revelations}`;
-    return {
-      chapterIndex,
-      chapterTitle: title,
-      characters: parsed.characters,
-      events: parsed.events,
-      setting: parsed.setting,
-      revelations: parsed.revelations,
-      fullSummary
-    };
+    return parseStructuredSummary(text, chapterIndex, title);
   } catch (error) {
     logWarn(`[Summarizer] Failed to parse summary JSON for "${title}": ${error instanceof Error ? error.message : String(error)}`);
     return null;
@@ -550,7 +405,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));
@@ -577,6 +434,7 @@ var resolveDbPath = async () => {
 };
 var createDb = async () => {
   const db = new Database(await resolveDbPath());
+  db.pragma("foreign_keys = ON");
   db.exec(`
     CREATE TABLE IF NOT EXISTS books (
       id TEXT PRIMARY KEY,
@@ -594,7 +452,7 @@ var createDb = async () => {
   db.exec(`
     CREATE TABLE IF NOT EXISTS chat_sessions (
       id TEXT PRIMARY KEY,
-      book_id TEXT NOT NULL,
+      book_id TEXT NOT NULL REFERENCES books(id) ON DELETE CASCADE,
       title TEXT,
       summary TEXT,
       created_at INTEGER DEFAULT (strftime('%s','now')),
@@ -604,7 +462,7 @@ var createDb = async () => {
   db.exec(`
     CREATE TABLE IF NOT EXISTS chat_messages (
       id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL,
+      session_id TEXT NOT NULL REFERENCES chat_sessions(id) ON DELETE CASCADE,
       role TEXT NOT NULL,
       content TEXT NOT NULL,
       token_count INTEGER,
@@ -623,6 +481,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;
 };
 
@@ -639,7 +505,16 @@ 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,
+  summaryBatchChapters: row.summary_batch_chapters ?? null,
+  summaries: row.summaries ?? null,
+  batchChunks: row.batch_chunks ?? null
 });
 var dbPromise = null;
 var getDb = async () => {
@@ -715,6 +590,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);
@@ -729,11 +636,24 @@ 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);
+  const deleteAll = db.transaction((bookId) => {
+    db.prepare("DELETE FROM chat_messages WHERE session_id IN (SELECT id FROM chat_sessions WHERE book_id = ?)").run(bookId);
+    db.prepare("DELETE FROM chat_sessions WHERE book_id = ?").run(bookId);
+    db.prepare("DELETE FROM books WHERE id = ?").run(bookId);
+  });
+  deleteAll(id);
 };
 var mapSession = (row) => ({
   id: row.id,
@@ -764,8 +684,8 @@ var insertChatSession = async (session) => {
     bookId: session.bookId,
     title: session.title ?? null,
     summary: session.summary ?? null,
-    createdAt: session.createdAt ?? Date.now(),
-    updatedAt: session.updatedAt ?? Date.now()
+    createdAt: session.createdAt ?? Math.floor(Date.now() / 1e3),
+    updatedAt: session.updatedAt ?? Math.floor(Date.now() / 1e3)
   });
   return session.id;
 };
@@ -810,7 +730,7 @@ var insertChatMessage = async (message) => {
     role: message.role,
     content: message.content,
     tokenCount: message.tokenCount ?? null,
-    createdAt: message.createdAt ?? Date.now()
+    createdAt: message.createdAt ?? Math.floor(Date.now() / 1e3)
   });
   return message.id;
 };
@@ -822,6 +742,32 @@ var getChatMessages = async (sessionId, limit) => {
 };
 
 // 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`;
@@ -831,8 +777,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();
@@ -858,7 +805,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);
@@ -886,23 +833,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-C2E6OHBQ.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-C2E6OHBQ.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-C2E6OHBQ.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-C2E6OHBQ.js");
+  const { downloadBatchSummaryResults, submitMergePass, downloadMergeResults } = await import("./batch-summarizer-CM3NO7TK.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-CM3NO7TK.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-CM3NO7TK.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-C2E6OHBQ.js");
+  const { downloadMergeResults } = await import("./batch-summarizer-CM3NO7TK.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-C2E6OHBQ.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
@@ -983,23 +1158,57 @@ 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
 var formatDate = (timestamp) => {
   if (!timestamp) return "-";
-  return new Date(timestamp).toISOString().slice(0, 10);
+  return new Date(timestamp * 1e3).toISOString().slice(0, 10);
 };
 var listCommand = async () => {
   await ensureDataDirs();
@@ -1008,15 +1217,15 @@ var listCommand = async () => {
     stdout("No books indexed yet.");
     return;
   }
-  stdout("ID       | Title | Author | Chunks | Indexed | Status");
-  stdout("---------|-------|--------|--------|--------|-------");
+  stdout("ID       | Title | Author | Chunks | Indexed    | Status");
+  stdout("---------|-------|--------|--------|------------|-------");
   for (const book of books) {
     const shortId = book.id.slice(0, 8);
     const title = book.title;
     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}`);
   }
 };
@@ -1059,6 +1268,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]" : "";
@@ -1076,10 +1286,38 @@ var registerBookShow = (program2) => {
 // src/commands/ask.ts
 import { embed, streamText } from "ai";
 import { openai as openai3 } from "@ai-sdk/openai";
+
+// src/shared/utils.ts
+var CHARS_PER_TOKEN3 = 4;
+var estimateTokens2 = (text) => Math.ceil(text.length / CHARS_PER_TOKEN3);
+var renderSources = (sources) => {
+  if (sources.length === 0) return "";
+  const lines = sources.map((match, index) => {
+    const title = match.chapterTitle || `Chapter ${match.chapterIndex + 1}`;
+    const excerpt = match.content.slice(0, 120).replace(/\s+/g, " ");
+    return `[${index + 1}] ${title}: ${excerpt}`;
+  });
+  return `
+Sources:
+${lines.join("\n")}`;
+};
+var resolveMaxChapter = (book, maxChapterOption) => {
+  const narrativeStart = book.narrativeStartIndex ?? 0;
+  const userProgress = book.progressChapter ?? null;
+  if (maxChapterOption !== void 0) {
+    return narrativeStart + maxChapterOption;
+  }
+  if (userProgress !== null) {
+    return narrativeStart + userProgress;
+  }
+  return void 0;
+};
 var formatContext = (chunks) => chunks.map(
   (chunk, index) => `Excerpt [${index + 1}] (${chunk.chapterTitle || `Chapter ${chunk.chapterIndex + 1}`}):
 ${chunk.content}`
 ).join("\n\n");
+
+// src/commands/ask.ts
 var askCommand = async (id, question, options) => {
   if (!await isAskEnabled()) {
     throw new Error("Ask is disabled in config (askEnabled: false). Enable it to use this command.");
@@ -1099,9 +1337,7 @@ var askCommand = async (id, question, options) => {
     model: openai3.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 maxChapterIndex = resolveMaxChapter(book, options.maxChapter);
   const retrievalLimit = options.topK * 3;
   const allMatches = await queryBookIndex(resolvedId, embedding, question, retrievalLimit, maxChapterIndex);
   const summaries = allMatches.filter((m) => m.type === "summary");
@@ -1135,28 +1371,20 @@ ${context}`
   } finally {
     releaseSigint();
   }
-  if (selectedMatches.length > 0) {
-    process.stdout.write("\n\nSources:\n");
-    selectedMatches.forEach((match, index) => {
-      const title = match.chapterTitle || `Chapter ${match.chapterIndex + 1}`;
-      const excerpt = match.content.slice(0, 120).replace(/\s+/g, " ");
-      process.stdout.write(`[${index + 1}] ${title}: ${excerpt}
-`);
-    });
-  }
+  stdout(renderSources(selectedMatches));
 };
 
 // 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.");
+  if (!Number.isFinite(topK) || topK <= 0 || !Number.isInteger(topK)) {
+    throw new Error("--top-k must be a positive integer.");
   }
   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.");
+    if (!Number.isFinite(parsed) || parsed < 0 || !Number.isInteger(parsed)) {
+      throw new Error("--max-chapter must be a non-negative integer.");
     }
     maxChapter = parsed;
   }
@@ -1165,7 +1393,14 @@ var parseQueryOptions = (options) => {
 
 // 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) => {
+  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)").addHelpText(
+    "after",
+    `
+EXAMPLES
+  mycroft book ask 8f2c1a4b "Who is the main character?"
+  mycroft book ask 8f2c1a4b "What happened in chapter 3?" --max-chapter 3
+`
+  ).action(async (id, question, options) => {
     const { topK, maxChapter } = parseQueryOptions(options);
     await askCommand(id, question, { topK, maxChapter });
   });
@@ -1190,7 +1425,7 @@ var searchCommand = async (id, query, options) => {
     model: openai4.embeddingModel(models.embedding),
     value: query
   });
-  const maxChapterIndex = options.maxChapter !== void 0 ? (book.narrativeStartIndex ?? 0) + options.maxChapter : book.progressChapter !== null ? (book.narrativeStartIndex ?? 0) + (book.progressChapter ?? 0) : void 0;
+  const maxChapterIndex = resolveMaxChapter(book, options.maxChapter);
   const results = await queryBookIndex(resolvedId, embedding, query, options.topK, maxChapterIndex);
   if (results.length === 0) {
     stdout("No results.");
@@ -1208,7 +1443,14 @@ 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) => {
+  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)").addHelpText(
+    "after",
+    `
+EXAMPLES
+  mycroft book search 8f2c1a4b "the storm scene"
+  mycroft book search 8f2c1a4b "betrayal" --top-k 10
+`
+  ).action(async (id, query, options) => {
     const { topK, maxChapter } = parseQueryOptions(options);
     await searchCommand(id, query, { topK, maxChapter });
   });
@@ -1239,18 +1481,247 @@ var deleteCommand = async (id, options) => {
   await deleteBook(resolvedId);
   await deleteBookIndex(resolvedId);
   if (book.epubPath) {
-    await unlink2(book.epubPath).catch(() => void 0);
+    await unlink2(book.epubPath).catch((err) => {
+      if (err.code !== "ENOENT") throw err;
+    });
   }
   stdout(`Deleted book ${book.id}`);
 };
 
 // src/commands/book/delete.ts
 var registerBookDelete = (program2) => {
-  program2.command("delete").description("Remove book, EPUB, and vectors").argument("<id>", "Book id or prefix").option("--force", "Skip confirmation").action(async (id, options) => {
+  program2.command("delete").description("Remove book, EPUB, and vectors").argument("<id>", "Book id or prefix").option("--force", "Skip confirmation").addHelpText(
+    "after",
+    `
+EXAMPLES
+  mycroft book delete 8f2c1a4b
+  mycroft book delete 8f2c1a4b --force
+`
+  ).action(async (id, options) => {
     await deleteCommand(id, { force: options.force });
   });
 };
 
+// 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".`);
+    }
+    let storedData;
+    try {
+      storedData = JSON.parse(rawData);
+    } catch {
+      throw new Error(`Corrupt summary batch data for book "${book.title}". Re-ingest with "mycroft book ingest --batch --summary".`);
+    }
+    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".`);
+    }
+    let chunks;
+    try {
+      chunks = JSON.parse(rawChunks);
+    } catch {
+      throw new Error(`Corrupt chunk data for book "${book.title}". Re-ingest with "mycroft book ingest --batch".`);
+    }
+    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-C2E6OHBQ.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-C2E6OHBQ.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();
@@ -1265,7 +1736,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);
@@ -1281,8 +1752,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}`);
 };
 
@@ -1311,7 +1782,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;
@@ -1339,7 +1810,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(
       {
@@ -1377,16 +1848,11 @@ var registerConfigOnboard = (program2) => {
 
 // src/services/chat.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { embed as embed3, generateText as generateText2 } from "ai";
+import { embed as embed3, generateText as generateText2, streamText as streamText2 } 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();
@@ -1394,8 +1860,7 @@ var summarizeMessages = async (messages) => {
     model: openai5(models.summary),
     prompt: `Summarize this conversation so far in ~${SUMMARY_TARGET_WORDS2} words. Focus on facts, decisions, and unresolved questions.
 
-${transcript}`,
-    temperature: 0.3
+${transcript}`
   });
   return text.trim();
 };
@@ -1451,9 +1916,7 @@ var chatAsk = async (sessionId, question, options) => {
     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 maxChapterIndex = resolveMaxChapter(book, options.maxChapter);
   const retrievalLimit = options.topK * 3;
   const allMatches = await queryBookIndex(session.bookId, embedding, question, retrievalLimit, maxChapterIndex);
   const summaries = allMatches.filter((m) => m.type === "summary");
@@ -1461,26 +1924,17 @@ var chatAsk = async (sessionId, question, options) => {
   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 context = formatContext(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 now = Math.floor(Date.now() / 1e3);
   const prompt2 = [
     conversation ? `Conversation:
 ${conversation}` : "",
     `Question: ${question}`,
     context
   ].filter(Boolean).join("\n\n");
-  const { text } = await generateText2({
+  const stream = streamText2({
     model: openai5(models.chat),
     system: `You are a reading companion helping readers understand this book.
 
@@ -1495,6 +1949,16 @@ Guidelines:
 - The context may be limited to earlier chapters only - don't infer beyond what's provided`,
     prompt: prompt2
   });
+  const text = await stream.text;
+  const userMessage = {
+    id: randomUUID2(),
+    sessionId,
+    role: "user",
+    content: question,
+    tokenCount: estimateTokens2(question),
+    createdAt: now
+  };
+  await insertChatMessage(userMessage);
   const assistantMessage = {
     id: randomUUID2(),
     sessionId,
@@ -1504,7 +1968,7 @@ Guidelines:
     createdAt: now
   };
   await insertChatMessage(assistantMessage);
-  const updatedAt = Date.now();
+  const updatedAt = Math.floor(Date.now() / 1e3);
   await updateChatSession(sessionId, { updatedAt });
   await maybeSummarizeSession(session, [...messages, userMessage, assistantMessage], updatedAt);
   return { answer: text, sources: selectedMatches };
@@ -1541,21 +2005,14 @@ var registerChatAsk = (program2) => {
     }
     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}`);
-      });
-    }
+    stdout(renderSources(sources));
   });
 };
 
 // src/commands/chat/list.ts
 var formatDate2 = (timestamp) => {
   if (!timestamp) return "-";
-  return new Date(timestamp).toISOString().slice(0, 10);
+  return new Date(timestamp * 1e3).toISOString().slice(0, 10);
 };
 var registerChatList = (program2) => {
   program2.command("list").description("List chat sessions").action(async () => {
@@ -1635,14 +2092,7 @@ var registerChatRepl = (program2) => {
       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(renderSources(sources));
       stdout("");
     }
   });
@@ -1661,8 +2111,8 @@ var registerChatCommands = (program2) => {
 // 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 {
@@ -1680,12 +2130,14 @@ 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);