@fs/mycroft 0.2.0 → 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));
@@ -623,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;
 };
 
@@ -639,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 () => {
@@ -715,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);
@@ -729,6 +677,16 @@ 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);
@@ -822,6 +780,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 +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();
@@ -858,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);
@@ -886,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
@@ -983,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
@@ -1016,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}`);
   }
 };
@@ -1059,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]" : "";
@@ -1251,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();
@@ -1265,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);
@@ -1281,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}`);
 };
 
@@ -1311,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;
@@ -1339,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(
       {
@@ -1394,8 +1852,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();
 };
@@ -1661,8 +2118,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 +2137,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);