wiki-graph-sdk 0.7.0 → 0.8.0

package/dist/index.cjs

@@ -32,22 +32,23 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   DANGEROUS_RUNTIME_ENV_NAMES: () => DANGEROUS_RUNTIME_ENV_NAMES,
-  DEFAULT_EXTRACTION_PROMPT: () => import_wiki_graph_core8.DEFAULT_EXTRACTION_PROMPT,
+  DEFAULT_EXTRACTION_PROMPT: () => import_wiki_graph_core10.DEFAULT_EXTRACTION_PROMPT,
   DEFAULT_GENERATION_JOB_CONCURRENCY: () => DEFAULT_GENERATION_JOB_CONCURRENCY,
   DEFAULT_GENERATION_REQUEST_CONCURRENCY: () => DEFAULT_GENERATION_REQUEST_CONCURRENCY,
-  DEFAULT_KNOWLEDGE_GRAPH_RECALL_PROMPT: () => import_wiki_graph_core8.DEFAULT_KNOWLEDGE_GRAPH_RECALL_PROMPT,
-  LLMPaymentRequiredError: () => import_wiki_graph_core16.LLMPaymentRequiredError,
+  DEFAULT_KNOWLEDGE_GRAPH_RECALL_PROMPT: () => import_wiki_graph_core10.DEFAULT_KNOWLEDGE_GRAPH_RECALL_PROMPT,
+  LLMPaymentRequiredError: () => import_wiki_graph_core19.LLMPaymentRequiredError,
   LOCAL_CONFIG_SECTIONS: () => LOCAL_CONFIG_SECTIONS,
   NodeDirectory: () => NodeDirectory,
   NodeFile: () => NodeFile,
-  WIKI_GRAPH_URI_PREFIX: () => import_wiki_graph_core16.WIKI_GRAPH_URI_PREFIX,
+  WIKI_GRAPH_URI_PREFIX: () => import_wiki_graph_core19.WIKI_GRAPH_URI_PREFIX,
   WikiGraphArchiveExistsError: () => WikiGraphArchiveExistsError,
   WikiGraphArchiveHandle: () => WikiGraphArchiveHandle,
   WikiGraphArchiveManager: () => WikiGraphArchiveManager,
+  WikiGraphArchiveOwnershipError: () => WikiGraphArchiveOwnershipError,
   WikiGraphConfigManager: () => WikiGraphConfigManager,
   WikiGraphContinuationManager: () => WikiGraphContinuationManager,
   WikiGraphConversionManager: () => WikiGraphConversionManager,
-  WikiGraphError: () => import_wiki_graph_core16.WikiGraphError,
+  WikiGraphError: () => import_wiki_graph_core19.WikiGraphError,
   WikiGraphJob: () => WikiGraphJob,
   WikiGraphJobManager: () => WikiGraphJobManager,
   WikiGraphLibrary: () => WikiGraphLibrary,
@@ -62,51 +63,50 @@ __export(src_exports, {
   createNodeTemplateEnvironment: () => createNodeTemplateEnvironment,
   createNodeWikiGraphStorage: () => createNodeWikiGraphStorage,
   createStageLLM: () => createStageLLM,
-  createWikiGraphArchiveInspectReport: () => createWikiGraphArchiveInspectReport,
   createWikiGraphSDK: () => createWikiGraphSDK,
   deleteLocalConfigValue: () => deleteLocalConfigValue,
   embedQueryText: () => embedQueryText,
   embedQueryTextWithLocalConfig: () => embedQueryTextWithLocalConfig,
   ensureNodeWikiGraphPlatform: () => ensureNodeWikiGraphPlatform,
-  formatError: () => import_wiki_graph_core16.formatError,
+  formatError: () => import_wiki_graph_core19.formatError,
   formatGenerationPlanningDuration: () => formatGenerationPlanningDuration,
   formatGenerationPlanningModel: () => formatGenerationPlanningModel,
-  formatLocatedChapterResourceUri: () => import_wiki_graph_core16.formatLocatedChapterResourceUri,
-  formatLocatedChapterSourceCollectionUri: () => import_wiki_graph_core16.formatLocatedChapterSourceCollectionUri,
-  formatLocatedChapterUri: () => import_wiki_graph_core16.formatLocatedChapterUri,
-  formatLocatedWikiGraphUri: () => import_wiki_graph_core16.formatLocatedWikiGraphUri,
-  formatWikiGraphCommandUri: () => import_wiki_graph_core16.formatWikiGraphCommandUri,
-  formatWikiGraphLibraryUri: () => import_wiki_graph_core16.formatWikiGraphLibraryUri,
+  formatLocatedChapterResourceUri: () => import_wiki_graph_core19.formatLocatedChapterResourceUri,
+  formatLocatedChapterSourceCollectionUri: () => import_wiki_graph_core19.formatLocatedChapterSourceCollectionUri,
+  formatLocatedChapterUri: () => import_wiki_graph_core19.formatLocatedChapterUri,
+  formatLocatedWikiGraphUri: () => import_wiki_graph_core19.formatLocatedWikiGraphUri,
+  formatWikiGraphCommandUri: () => import_wiki_graph_core19.formatWikiGraphCommandUri,
+  formatWikiGraphLibraryUri: () => import_wiki_graph_core19.formatWikiGraphLibraryUri,
   getNodeResourcePath: () => getNodeResourcePath,
   getWikiGraphSDKRuntimeContext: () => getWikiGraphSDKRuntimeContext,
   getWikiGraphSDKStateDir: () => getWikiGraphSDKStateDir,
+  inspectWikiGraphArchive: () => inspectWikiGraphArchive,
   installNodeWikiGraphPlatform: () => installNodeWikiGraphPlatform,
-  isSourceLocatorScopeUri: () => import_wiki_graph_core16.isSourceLocatorScopeUri,
-  isWikiGraphLibraryUri: () => import_wiki_graph_core16.isWikiGraphLibraryUri,
+  isSourceLocatorScopeUri: () => import_wiki_graph_core19.isSourceLocatorScopeUri,
+  isWikiGraphLibraryUri: () => import_wiki_graph_core19.isWikiGraphLibraryUri,
   loadRequiredStageConfig: () => loadRequiredStageConfig,
   loadWikiGraphRuntimeConfig: () => loadWikiGraphRuntimeConfig,
   maskLocalConfigSection: () => maskLocalConfigSection,
   nodeWikiGraphPlatform: () => nodeWikiGraphPlatform,
   nodeWikispineCommandRunner: () => nodeWikispineCommandRunner,
   normalizeLocalConfigKey: () => normalizeLocalConfigKey,
-  parseChapterPath: () => import_wiki_graph_core16.parseChapterPath,
-  parseChapterTreeInput: () => import_wiki_graph_core16.parseChapterTreeInput,
-  parseChapterUriPath: () => import_wiki_graph_core16.parseChapterUriPath,
+  parseChapterPath: () => import_wiki_graph_core19.parseChapterPath,
+  parseChapterTreeInput: () => import_wiki_graph_core19.parseChapterTreeInput,
+  parseChapterUriPath: () => import_wiki_graph_core19.parseChapterUriPath,
   parseLocalConfigSection: () => parseLocalConfigSection,
-  parseLocatedWikiGraphUri: () => import_wiki_graph_core16.parseLocatedWikiGraphUri,
-  parseSourceTextJsonl: () => import_wiki_graph_core16.parseSourceTextJsonl,
-  parseWikiGraphLibraryUri: () => import_wiki_graph_core16.parseWikiGraphLibraryUri,
-  parseWikiGraphUriSyntax: () => import_wiki_graph_core16.parseWikiGraphUriSyntax,
+  parseLocatedWikiGraphUri: () => import_wiki_graph_core19.parseLocatedWikiGraphUri,
+  parseSourceTextJsonl: () => import_wiki_graph_core19.parseSourceTextJsonl,
+  parseWikiGraphLibraryUri: () => import_wiki_graph_core19.parseWikiGraphLibraryUri,
+  parseWikiGraphUriSyntax: () => import_wiki_graph_core19.parseWikiGraphUriSyntax,
   planGenerationTask: () => planGenerationTask,
   putLocalConfigValue: () => putLocalConfigValue,
   readLocalConfigSection: () => readLocalConfigSection,
   readWikiGraphEmbeddingConfig: () => readWikiGraphEmbeddingConfig,
   replaceLocalConfigSection: () => replaceLocalConfigSection,
   requireKnowledgeGraphWikispineConfig: () => requireKnowledgeGraphWikispineConfig,
-  resolveExtractionPrompt: () => import_wiki_graph_core8.resolveExtractionPrompt,
+  resolveExtractionPrompt: () => import_wiki_graph_core10.resolveExtractionPrompt,
   resolveHostedProviderEndpoint: () => resolveHostedProviderEndpoint,
-  resolveKnowledgeGraphRecallPrompt: () => import_wiki_graph_core8.resolveKnowledgeGraphRecallPrompt,
-  resolveWikiGraphArchiveLocation: () => resolveWikiGraphArchiveLocation,
+  resolveKnowledgeGraphRecallPrompt: () => import_wiki_graph_core10.resolveKnowledgeGraphRecallPrompt,
   resolveWikispineConfig: () => resolveWikispineConfig,
   runWikiGraphQueueWorker: () => runWikiGraphQueueWorker,
   validateLocalConfigSection: () => validateLocalConfigSection,
@@ -117,16 +117,19 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/archive/archive.ts
-var import_crypto = require("crypto");
-var import_promises3 = require("fs/promises");
+var import_crypto2 = require("crypto");
+var import_promises4 = require("fs/promises");
 var import_os3 = require("os");
-var import_path3 = require("path");
+var import_path5 = require("path");
 var import_stream = require("stream");
-var import_wiki_graph_core5 = require("wiki-graph-core");
+var import_wiki_graph_core7 = require("wiki-graph-core");
 
 // src/conversions.ts
-var import_promises2 = require("fs/promises");
-var import_wiki_graph_core2 = require("wiki-graph-core");
+var import_crypto = require("crypto");
+var import_fs = require("fs");
+var import_promises3 = require("fs/promises");
+var import_path4 = require("path");
+var import_wiki_graph_core3 = require("wiki-graph-core");
 
 // src/llm.ts
 var import_anthropic = require("@ai-sdk/anthropic");
@@ -446,42 +449,42 @@ var NodeDatabaseConnection = class {
   }
   database;
   async close() {
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       this.database.close((error) => {
         if (error) reject(error);
-        else resolve3();
+        else resolve4();
       });
     });
   }
   async execute(sql) {
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       this.database.exec(sql, (error) => {
         if (error) reject(error);
-        else resolve3();
+        else resolve4();
       });
     });
   }
   async queryAll(sql, params = []) {
-    return await new Promise((resolve3, reject) => {
+    return await new Promise((resolve4, reject) => {
       this.database.all(sql, [...params], (error, rows) => {
         if (error) reject(error);
-        else resolve3(rows);
+        else resolve4(rows);
       });
     });
   }
   async queryOne(sql, params = []) {
-    return await new Promise((resolve3, reject) => {
+    return await new Promise((resolve4, reject) => {
       this.database.get(sql, [...params], (error, row) => {
         if (error) reject(error);
-        else resolve3(row);
+        else resolve4(row);
       });
     });
   }
   async run(sql, params = []) {
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       this.database.run(sql, [...params], (error) => {
         if (error) reject(error);
-        else resolve3();
+        else resolve4();
       });
     });
   }
@@ -495,10 +498,10 @@ async function openNativeNodeDatabase(file, flags) {
   if (path === void 0) {
     throw new TypeError("The Node database adapter requires a NodeFile");
   }
-  return await new Promise((resolve3, reject) => {
+  return await new Promise((resolve4, reject) => {
     const database = new nodeSqlite3.Database(path, flags, (error) => {
       if (error) reject(error);
-      else resolve3(database);
+      else resolve4(database);
     });
   });
 }
@@ -507,19 +510,19 @@ async function openNodeZip(file) {
   if (path === void 0) {
     throw new TypeError("The Node ZIP adapter requires a NodeFile");
   }
-  const zipFile = await new Promise((resolve3, reject) => {
+  const zipFile = await new Promise((resolve4, reject) => {
     yauzl.open(
       path,
       { autoClose: false, lazyEntries: true },
       (error, opened) => {
         if (error || opened === void 0)
           reject(error ?? new Error("Cannot open ZIP"));
-        else resolve3(opened);
+        else resolve4(opened);
       }
     );
   });
   const entries = await new Promise(
-    (resolve3, reject) => {
+    (resolve4, reject) => {
       const discovered = /* @__PURE__ */ new Map();
       const rejectAndClose = (error) => {
         zipFile.close();
@@ -529,7 +532,7 @@ async function openNodeZip(file) {
       };
       const resolveEntries = () => {
         zipFile.off("error", rejectAndClose);
-        resolve3(discovered);
+        resolve4(discovered);
       };
       zipFile.on("entry", (entry) => {
         if (!entry.fileName.endsWith("/")) {
@@ -639,12 +642,12 @@ async function collectDecodedNodeStreamRange(input, offset, length) {
   return Buffer.concat(chunks, collected);
 }
 async function openNodeZipEntryStream(zipFile, entry, options) {
-  return await new Promise((resolve3, reject) => {
+  return await new Promise((resolve4, reject) => {
     const callback = (error, opened) => {
       if (error || opened === void 0) {
         reject(error ?? new Error(`Cannot read ZIP entry: ${entry.fileName}`));
       } else {
-        resolve3(opened);
+        resolve4(opened);
       }
     };
     if (options === void 0) zipFile.openReadStream(entry, callback);
@@ -775,11 +778,11 @@ async function writeNodeStream(input, writer) {
   );
 }
 async function collectNodeStream(input) {
-  return await new Promise((resolve3, reject) => {
+  return await new Promise((resolve4, reject) => {
     const chunks = [];
     input.on("data", (chunk) => chunks.push(chunk));
     input.once("error", reject);
-    input.once("end", () => resolve3(Buffer.concat(chunks)));
+    input.once("end", () => resolve4(Buffer.concat(chunks)));
   });
 }
 var nodeWikiGraphPlatform = {
@@ -1448,6 +1451,194 @@ function resolveWikiGraphRuntimePath(path) {
   return (0, import_path2.isAbsolute)(path) ? path : (0, import_path2.resolve)(context.cwd, path);
 }
 
+// src/archive/target.ts
+var import_promises2 = require("fs/promises");
+var import_path3 = require("path");
+var import_wiki_graph_core2 = require("wiki-graph-core");
+var WikiGraphArchiveOwnershipError = class extends Error {
+  code = "WIKI_GRAPH_ARCHIVE_OWNERSHIP_MISMATCH";
+  constructor(message) {
+    super(message);
+    this.name = "WikiGraphArchiveOwnershipError";
+  }
+};
+async function resolveWikiGraphArchiveLocation(target) {
+  if (target.kind === "standalone") {
+    return await resolveStandaloneLocation(target);
+  }
+  return await resolveLibraryLocation(target);
+}
+async function assertStandaloneWikiGraphArchivePath(inputPath) {
+  const path = resolveWikiGraphRuntimePath(inputPath);
+  const candidate = await canonicalPath(path);
+  const candidateIdentity = await readFileIdentity(path);
+  const libraries = await (0, import_wiki_graph_core2.listWikiGraphLibraries)();
+  const matches = await findMatchingMembers(
+    libraries,
+    candidate,
+    candidateIdentity
+  );
+  if (matches.length > 0) {
+    const match = requireUnambiguousManagedMatch(path, matches);
+    throw new WikiGraphArchiveOwnershipError(
+      `Standalone archive path belongs to registered library ${(0, import_wiki_graph_core2.formatWikiGraphLibraryUri)(
+        match.library.isDefault ? void 0 : match.library.publicId
+      )}: ${path}. Use the library UUID URI ${match.archive.uri} instead.`
+    );
+  }
+  for (const library of libraries) {
+    const rootPath = getNodeResourcePath(library.folder);
+    const root = await canonicalPath(rootPath);
+    if (!isWithin(root, candidate)) continue;
+    throw new WikiGraphArchiveOwnershipError(
+      `Standalone archive path belongs to registered library ${(0, import_wiki_graph_core2.formatWikiGraphLibraryUri)(
+        library.isDefault ? void 0 : library.publicId
+      )}: ${path}. Scan the library, then address the archive by its library UUID URI.`
+    );
+  }
+  return path;
+}
+function archiveTargetFromLogicalLocator(locator, objectUri) {
+  if (locator.startsWith("wikg://lib/")) {
+    return { kind: "library", uri: withObjectUri(locator, objectUri) };
+  }
+  return {
+    kind: "standalone",
+    path: locator,
+    ...objectUri === void 0 ? {} : { objectUri }
+  };
+}
+async function resolveWikiGraphArchiveTarget(file) {
+  const path = getNodeResourcePath(file);
+  const candidate = await canonicalPath(path);
+  const candidateIdentity = await readFileIdentity(path);
+  const matches = await findMatchingMembers(
+    await (0, import_wiki_graph_core2.listWikiGraphLibraries)(),
+    candidate,
+    candidateIdentity
+  );
+  if (matches.length > 0) {
+    const match = requireUnambiguousManagedMatch(path, matches);
+    return { kind: "library", uri: match.archive.uri };
+  }
+  return { kind: "standalone", path: getNodeResourcePath(file) };
+}
+async function resolveStandaloneLocation(target) {
+  if (target.path.startsWith("wikg://lib/")) {
+    throw new WikiGraphArchiveOwnershipError(
+      `A library archive URI cannot be used as a standalone path: ${target.path}`
+    );
+  }
+  const path = await assertStandaloneWikiGraphArchivePath(target.path);
+  const normalized = {
+    kind: "standalone",
+    path,
+    ...target.objectUri === void 0 ? {} : { objectUri: target.objectUri }
+  };
+  return {
+    archiveFile: new NodeFile(path),
+    archiveKey: path,
+    archivePath: path,
+    indexScope: { archiveKey: path, archivePath: path, kind: "archive-index" },
+    locatedUri: (0, import_wiki_graph_core2.formatLocatedWikiGraphUri)(path, target.objectUri),
+    target: normalized
+  };
+}
+async function resolveLibraryLocation(target) {
+  const parsedLocated = (0, import_wiki_graph_core2.parseLocatedWikiGraphUri)(target.uri);
+  const archiveUri = parsedLocated.archivePath ?? target.uri;
+  const parsed = (0, import_wiki_graph_core2.parseWikiGraphLibraryUri)(archiveUri);
+  if (parsed?.kind !== "archive") {
+    throw new WikiGraphArchiveOwnershipError(
+      `Library archive target must be a UUID archive URI: ${target.uri}`
+    );
+  }
+  await (0, import_wiki_graph_core2.resolveWikiGraphLibrary)(parsed);
+  const archiveFile = await (0, import_wiki_graph_core2.resolveWikiGraphLibraryArchiveFile)(archiveUri);
+  const normalized = {
+    kind: "library",
+    uri: target.uri
+  };
+  return {
+    archiveFile,
+    archiveKey: archiveUri,
+    archivePath: archiveUri,
+    indexScope: {
+      archiveKey: archiveUri,
+      archivePath: archiveUri,
+      kind: "archive-index"
+    },
+    libraryArchiveTarget: parsed,
+    locatedUri: target.uri,
+    publicArchiveUri: archiveUri,
+    target: normalized
+  };
+}
+function withObjectUri(archiveLocator, objectUri) {
+  if (objectUri === void 0) return archiveLocator;
+  const path = objectUri.replace(/^wikg:\/\//u, "");
+  return `${archiveLocator.replace(/\/$/u, "")}/${path}`;
+}
+async function canonicalPath(path) {
+  try {
+    return await (0, import_promises2.realpath)(path);
+  } catch {
+    const absolute = (0, import_path3.resolve)(path);
+    const parent = (0, import_path3.dirname)(absolute);
+    return parent === absolute ? absolute : (0, import_path3.join)(await canonicalPath(parent), (0, import_path3.basename)(absolute));
+  }
+}
+function isWithin(root, candidate) {
+  const child = (0, import_path3.relative)(root, candidate);
+  return child === "" || !child.startsWith("..") && !(0, import_path3.isAbsolute)(child);
+}
+async function findMatchingMembers(libraries, candidate, candidateIdentity) {
+  const members = [];
+  for (const library of libraries) {
+    const archives = await (0, import_wiki_graph_core2.listWikiGraphLibraryArchives)({
+      isDefault: library.isDefault,
+      kind: "scope",
+      ...library.isDefault ? {} : { publicId: library.publicId }
+    });
+    for (const archive of archives) {
+      if (archive.file === void 0) continue;
+      members.push({
+        archive,
+        library,
+        memberPath: getNodeResourcePath(archive.file)
+      });
+    }
+  }
+  const exact = [];
+  for (const member of members) {
+    if (await canonicalPath(member.memberPath) === candidate) {
+      exact.push(member);
+    }
+  }
+  if (exact.length > 0 || candidateIdentity === void 0) return exact;
+  const identityMatches = [];
+  for (const member of members) {
+    if (await readFileIdentity(member.memberPath) === candidateIdentity) {
+      identityMatches.push(member);
+    }
+  }
+  return identityMatches;
+}
+function requireUnambiguousManagedMatch(path, matches) {
+  if (matches.length === 1) return matches[0];
+  throw new WikiGraphArchiveOwnershipError(
+    `Archive file identity is ambiguous across managed archives: ${path}. Use an explicit library UUID URI (${matches.map((match) => match.archive.uri).join(", ")}).`
+  );
+}
+async function readFileIdentity(path) {
+  try {
+    const value = await (0, import_promises2.stat)(path);
+    return `${value.dev}:${value.ino}`;
+  } catch {
+    return void 0;
+  }
+}
+
 // src/conversions.ts
 var WikiGraphConversionManager = class {
   #runtime;
@@ -1462,6 +1653,9 @@ var WikiGraphConversionManager = class {
     if (options.targetStage !== void 0 && options.output.format !== "wikg") {
       throw new Error("targetStage is only supported for wikg output.");
     }
+    if (options.output.format === "pcex") {
+      throw new Error("pcex is supported only as a conversion input.");
+    }
     if (options.targetStage !== void 0 && options.input.format === "wikg") {
       throw new Error(
         "targetStage is only supported when creating a wikg archive."
@@ -1472,7 +1666,7 @@ var WikiGraphConversionManager = class {
     const config = await loadWikiGraphRuntimeConfig({
       ...options.llmJSON === void 0 ? {} : { llmJSON: options.llmJSON }
     });
-    const app = new import_wiki_graph_core2.WikiGraph({
+    const app = new import_wiki_graph_core3.WikiGraph({
       ...options.verbose === true ? { verbose: true } : {},
       ...requiresLLM ? { llm: buildWikiGraphLLMOptions(config) } : {}
     });
@@ -1480,7 +1674,17 @@ var WikiGraphConversionManager = class {
       options.digestDirectory,
       requiresDigest
     );
+    let chapterCount;
+    let chapterPaths;
     const write = async (archive) => {
+      if (requiresDigest) await options.onSourceImported?.();
+      if (typeof archive.readToc === "function") {
+        const toc = await archive.readToc();
+        chapterCount = toc === void 0 ? void 0 : countTocChapters(toc.items);
+        if (options.output.format === "wikg") {
+          chapterPaths = toc === void 0 ? [] : collectTocChapterPaths(toc.items);
+        }
+      }
       await writeArchive(archive, options.output.path, options.output.format);
     };
     if (options.input.format === "wikg") {
@@ -1488,7 +1692,9 @@ var WikiGraphConversionManager = class {
         throw new Error("wikg input requires a file path.");
       }
       await app.openSession(
-        new NodeFile(resolveWikiGraphRuntimePath(options.input.path)),
+        new NodeFile(
+          await assertStandaloneWikiGraphArchivePath(options.input.path)
+        ),
         write
       );
     } else if ("stream" in options.input) {
@@ -1513,16 +1719,29 @@ var WikiGraphConversionManager = class {
       };
       if (options.input.format === "epub") {
         await app.digestEpubSession(digestOptions, write);
+      } else if (options.input.format === "pcex") {
+        await app.digestPcexSession(
+          {
+            ...digestOptions,
+            pdfDigest: options.input.sourcePdf.digest,
+            ...options.input.sourcePdf.name === void 0 ? {} : { pdfName: options.input.sourcePdf.name }
+          },
+          write
+        );
       } else if (options.input.format === "markdown") {
         await app.digestMarkdownSession(digestOptions, write);
       } else {
         await app.digestTxtSession(digestOptions, write);
       }
     }
+    const sourceArtifact = await resolveSourceArtifact(options.input);
     return {
+      ...chapterCount === void 0 ? {} : { chapterCount },
+      ...chapterPaths === void 0 ? {} : { chapterPaths },
       inputFormat: options.input.format,
       outputFormat: options.output.format,
-      outputPath: options.output.path
+      outputPath: options.output.path,
+      ...sourceArtifact === void 0 ? {} : { sourceArtifact }
     };
   }
 };
@@ -1531,18 +1750,74 @@ async function prepareDigestDirectory(path, required) {
   if (!required || normalized === void 0 || normalized === "")
     return void 0;
   const resolved = resolveWikiGraphRuntimePath(normalized);
-  await (0, import_promises2.rm)(resolved, { force: true, recursive: true });
+  await (0, import_promises3.rm)(resolved, { force: true, recursive: true });
   return new NodeDirectory(resolved);
 }
 async function writeArchive(archive, path, format) {
-  const file = new NodeFile(resolveWikiGraphRuntimePath(path));
+  const outputPath = format === "wikg" ? await assertStandaloneWikiGraphArchivePath(path) : resolveWikiGraphRuntimePath(path);
+  const file = new NodeFile(outputPath);
   if (format === "epub") await archive.exportEpub(file);
   else if (format === "wikg") await archive.saveAs(file);
+  else if (format === "pcex") throw new Error("pcex output is not supported.");
   else await archive.exportText(file);
 }
+async function resolveSourceArtifact(input) {
+  if (!("path" in input) || input.format === "wikg") return void 0;
+  if (input.format === "pcex") {
+    return {
+      digest: input.sourcePdf.digest.trim().toLowerCase(),
+      mediaType: "application/pdf",
+      ...input.sourcePdf.name === void 0 ? {} : { name: input.sourcePdf.name }
+    };
+  }
+  if (input.format !== "epub") return void 0;
+  const path = resolveWikiGraphRuntimePath(input.path);
+  const hash = (0, import_crypto.createHash)("sha256");
+  try {
+    for await (const chunk of (0, import_fs.createReadStream)(path)) {
+      hash.update(chunk);
+    }
+  } catch (error) {
+    if (isNodeErrorCode(error, "ENOENT")) return void 0;
+    throw error;
+  }
+  return {
+    digest: hash.digest("hex"),
+    mediaType: "application/epub+zip",
+    name: (0, import_path4.basename)(path)
+  };
+}
+function isNodeErrorCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function countTocChapters(items) {
+  let count = 0;
+  for (const item of items) {
+    if (item.serialId !== void 0) count += 1;
+    count += countTocChapters(
+      item.children
+    );
+  }
+  return count;
+}
+function collectTocChapterPaths(items, ancestorKeys = []) {
+  const paths = [];
+  for (const item of items) {
+    const key = item.key ?? `chapter-${item.serialId ?? "group"}`;
+    const chapterPath = [...ancestorKeys, key];
+    if (item.serialId !== void 0) paths.push(chapterPath.join("/"));
+    paths.push(
+      ...collectTocChapterPaths(
+        item.children,
+        chapterPath
+      )
+    );
+  }
+  return paths;
+}
 
 // src/query-runtime.ts
-var import_wiki_graph_core3 = require("wiki-graph-core");
+var import_wiki_graph_core4 = require("wiki-graph-core");
 
 // src/embedding.ts
 var import_ai = require("ai");
@@ -1715,7 +1990,7 @@ async function createConfiguredEmbeddingProvider() {
 async function withConfiguredWikimediaResolver(objectUri, operation) {
   if (!objectUri.endsWith("/wikipage")) return await operation({});
   const config = await loadWikiGraphRuntimeConfig();
-  const resolver = await (0, import_wiki_graph_core3.openWikimediaResolver)(
+  const resolver = await (0, import_wiki_graph_core4.openWikimediaResolver)(
     config.wikimedia === void 0 ? { kind: "local" } : {
       endpoint: config.wikimedia.endpoint,
       kind: "remote",
@@ -1730,500 +2005,128 @@ async function withConfiguredWikimediaResolver(objectUri, operation) {
 }
 
 // src/archive/inspect.ts
-var import_wiki_graph_core4 = require("wiki-graph-core");
-
-// src/planning.ts
-var DEFAULT_GENERATION_JOB_CONCURRENCY = 3;
-var DEFAULT_GENERATION_REQUEST_CONCURRENCY = 6;
-function planGenerationTask(task, words, chapters, concurrent, model) {
-  const profile = getGenerationPlanningProfile(task);
-  const calls = Math.max(chapters, Math.ceil(words / profile.wordsPerCall));
-  const effectiveConcurrency = Math.max(
-    1,
-    task === "reading-graph" ? 1 : concurrent.request
+var import_wiki_graph_core5 = require("wiki-graph-core");
+async function inspectWikiGraphArchive(document, options) {
+  const [allChapters, indexCacheCurrent, summaryWords, ...coverage] = await Promise.all([
+    (0, import_wiki_graph_core5.listChapters)(document),
+    (0, import_wiki_graph_core5.isArchiveSearchIndexCurrent)(document),
+    readSummaryWords(document),
+    document.indexArtifacts.listCoverage("fts"),
+    document.indexArtifacts.listCoverage("embedding-source"),
+    document.indexArtifacts.listCoverage("embedding-summary")
+  ]);
+  const chapters = selectChapters(allChapters, options.chapterId);
+  const coverageByKind = {
+    fts: byChapterId(coverage[0]),
+    sourceEmbedding: byChapterId(coverage[1]),
+    summaryEmbedding: byChapterId(coverage[2])
+  };
+  const inspections = await Promise.all(
+    chapters.map(async (chapter) => {
+      const serial = await document.serials.getById(chapter.chapterId);
+      return {
+        capabilities: {
+          knowledgeGraph: {
+            completed: serial?.knowledgeGraphReady === true
+          },
+          readingGraph: { completed: serial?.topologyReady === true },
+          readingSummary: { completed: chapter.stage === "summarized" }
+        },
+        chapter,
+        indexes: {
+          fts: inspectArtifact(
+            "fts",
+            coverageByKind.fts.get(chapter.chapterId)
+          ),
+          sourceEmbedding: inspectArtifact(
+            "embedding-source",
+            coverageByKind.sourceEmbedding.get(chapter.chapterId)
+          ),
+          summaryEmbedding: inspectArtifact(
+            "embedding-summary",
+            coverageByKind.summaryEmbedding.get(chapter.chapterId)
+          )
+        },
+        revision: serial?.revision ?? 0,
+        summaryWords: summaryWords.get(chapter.chapterId) ?? 0
+      };
+    })
   );
-  const callBatches = Math.ceil(calls / effectiveConcurrency);
-  const wordSeconds = words * profile.secondsPerWord;
+  const selected = inspections[0];
   return {
-    model,
-    timeSeconds: {
-      max: Math.ceil(callBatches * profile.maxSecondsPerCall + wordSeconds),
-      min: Math.ceil(callBatches * profile.minSecondsPerCall + wordSeconds)
-    },
-    tokens: {
-      cacheableInput: Math.ceil(words * profile.cacheableInputTokenPerWord),
-      input: Math.ceil(words * profile.inputTokenPerWord),
-      output: Math.ceil(words * profile.outputTokenPerWord)
-    }
+    archiveUri: options.archiveUri,
+    chapters: inspections,
+    localIndexCache: { current: indexCacheCurrent },
+    scope: options.chapterId === void 0 ? { type: "archive" } : { chapterId: options.chapterId, type: "chapter" },
+    uri: selected === void 0 || options.chapterId === void 0 ? options.archiveUri : formatLocatedChapterUri(options.archiveUri, selected.chapter)
   };
 }
-function createGenerationPerformanceHints(input) {
-  if (!input.hasJobWork) {
-    return [];
-  }
-  const hints = [];
-  const recommendedRequest = input.concurrent.request < 4 ? DEFAULT_GENERATION_REQUEST_CONCURRENCY : input.concurrent.request < 8 ? 8 : void 0;
-  if (input.hasRequestWork && recommendedRequest !== void 0) {
-    hints.push({
-      configKey: "request",
-      configValue: recommendedRequest,
-      current: input.concurrent.request,
-      kind: "request",
-      message: "LLM request concurrency can often be higher. Use at least 4; 6-8 is usually faster when the provider allows it.",
-      recommended: recommendedRequest
-    });
-  }
-  if (input.concurrent.job < 4 && input.chapters > 1) {
-    hints.push({
-      configKey: "job",
-      configValue: 4,
-      current: input.concurrent.job,
-      kind: "job",
-      message: "Multiple chapters need work and job concurrency is below 4. Raising it lets chapter jobs run in parallel.",
-      recommended: 4
-    });
+function selectChapters(chapters, chapterId) {
+  if (chapterId === void 0) return chapters;
+  const selected = chapters.filter(
+    (chapter) => chapter.chapterId === chapterId
+  );
+  if (selected.length === 0) {
+    throw new Error(`Chapter ${chapterId} does not exist.`);
   }
-  return hints;
+  return selected;
 }
-function formatGenerationPlanningModel(llm) {
-  if (llm?.model === void 0) {
-    return "not configured";
-  }
-  return llm.provider === void 0 ? llm.model : `${llm.provider}/${llm.model}`;
+function byChapterId(coverage) {
+  return new Map(coverage.map((item) => [item.serialId, item]));
 }
-function formatGenerationPlanningDuration(seconds) {
-  if (seconds < 60) {
-    return `${seconds}s`;
-  }
-  const minutes = Math.round(seconds / 60);
-  if (minutes < 60) {
-    return `${minutes}m`;
-  }
-  return `${Math.round(minutes / 60)}h`;
+function inspectArtifact(kind, coverage) {
+  return {
+    current: coverage?.current === true,
+    exists: coverage?.sourceRevision !== void 0,
+    kind,
+    ...coverage?.sourceRevision === void 0 ? {} : { sourceRevision: coverage.sourceRevision }
+  };
 }
-function getGenerationPlanningProfile(task) {
-  switch (task) {
-    case "index-fts":
-      return {
-        cacheableInputTokenPerWord: 0,
-        inputTokenPerWord: 0,
-        maxSecondsPerCall: 1,
-        minSecondsPerCall: 0,
-        outputTokenPerWord: 0,
-        secondsPerWord: 5e-4,
-        wordsPerCall: 1e5
-      };
-    case "index-embedding-source":
-    case "index-embedding-summary":
-      return {
-        cacheableInputTokenPerWord: 0,
-        inputTokenPerWord: 0,
-        maxSecondsPerCall: 10,
-        minSecondsPerCall: 1,
-        outputTokenPerWord: 0,
-        secondsPerWord: 2e-3,
-        wordsPerCall: 1e4
-      };
-    case "knowledge-graph":
-      return {
-        cacheableInputTokenPerWord: 60,
-        inputTokenPerWord: 80,
-        maxSecondsPerCall: 35,
-        minSecondsPerCall: 15,
-        outputTokenPerWord: 25,
-        secondsPerWord: 0.02,
-        wordsPerCall: 35
-      };
-    case "reading-graph":
-      return {
-        cacheableInputTokenPerWord: 20,
-        inputTokenPerWord: 25,
-        maxSecondsPerCall: 45,
-        minSecondsPerCall: 15,
-        outputTokenPerWord: 4,
-        secondsPerWord: 0.01,
-        wordsPerCall: 160
-      };
-    case "reading-summary":
-      return {
-        cacheableInputTokenPerWord: 45,
-        inputTokenPerWord: 55,
-        maxSecondsPerCall: 25,
-        minSecondsPerCall: 10,
-        outputTokenPerWord: 4,
-        secondsPerWord: 0.01,
-        wordsPerCall: 110
-      };
-  }
+async function readSummaryWords(document) {
+  const rows = await document.readDatabase(
+    async (database) => await database.queryAll(
+      `
+        SELECT chapter_id, COALESCE(SUM(words_count), 0) AS words
+        FROM text_sentence_records
+        WHERE kind = 2
+        GROUP BY chapter_id
+      `,
+      void 0,
+      (row) => ({
+        chapterId: Number(row.chapter_id),
+        words: Number(row.words)
+      })
+    )
+  );
+  return new Map(rows.map((row) => [row.chapterId, row.words]));
+}
+function formatLocatedChapterUri(archiveUri, chapter) {
+  return `${archiveUri.replace(/\/+$/u, "")}/${chapter.uri.replace(/^wikg:\/\//u, "")}`;
 }
 
-// src/archive/inspect.ts
-async function createWikiGraphArchiveInspectReport(document, options) {
-  const { archiveUri } = options;
-  const [
-    chapters,
-    summaryWords,
-    indexCacheCurrent,
-    config,
-    ftsArtifactCoverage,
-    sourceEmbeddingArtifactCoverage,
-    summaryEmbeddingArtifactCoverage
-  ] = await Promise.all([
-    readInspectChapters(document, options.chapterId),
-    readSummaryWords(document, options.chapterId),
-    (0, import_wiki_graph_core4.isArchiveSearchIndexCurrent)(document),
-    loadWikiGraphRuntimeConfig(),
-    readIndexArtifactCoverage(document, "fts", options.chapterId),
-    readIndexArtifactCoverage(document, "embedding-source", options.chapterId),
-    readIndexArtifactCoverage(document, "embedding-summary", options.chapterId)
-  ]);
-  const selectedChapter = options.chapterId === void 0 ? void 0 : chapters[0];
-  const scopeUri = selectedChapter === void 0 ? archiveUri : formatInspectLocatedChapterUri(archiveUri, selectedChapter);
-  const concurrent = {
-    job: config.concurrent?.job ?? DEFAULT_GENERATION_JOB_CONCURRENCY,
-    request: config.concurrent?.request ?? DEFAULT_GENERATION_REQUEST_CONCURRENCY
-  };
-  const planningModel = formatGenerationPlanningModel(config.llm);
-  const contentChapters = chapters.filter(
-    (chapter) => chapter.stage !== "planned"
-  );
-  const sourceWords = sumWords(contentChapters);
-  const readingGraphCovered = contentChapters.filter(
-    (chapter) => chapter.readingGraphReady
-  );
-  const knowledgeGraphCovered = contentChapters.filter(
-    (chapter) => chapter.knowledgeGraphReady
-  );
-  const summaryCovered = contentChapters.filter(
-    (chapter) => chapter.summaryReady
-  );
-  const ftsArtifactCovered = filterChaptersByCurrentIndexArtifact(
-    contentChapters,
-    ftsArtifactCoverage
-  );
-  const sourceEmbeddingArtifactCovered = filterChaptersByCurrentIndexArtifact(
-    contentChapters,
-    sourceEmbeddingArtifactCoverage
-  );
-  const summaryEmbeddingArtifactCovered = filterChaptersByCurrentIndexArtifact(
-    contentChapters,
-    summaryEmbeddingArtifactCoverage
-  );
-  const queryBlockedContentChapters = contentChapters.filter(
-    (chapter) => !ftsArtifactCovered.includes(chapter) && !sourceEmbeddingArtifactCovered.includes(chapter)
-  );
-  const queryBlockedChapters = queryBlockedContentChapters.map(
-    (chapter) => createInspectChapterReference(archiveUri, chapter)
-  );
-  const queryReady = queryBlockedChapters.length === 0;
-  const improvements = createInspectImprovements({
-    concurrent,
-    contentChapters,
-    indexCacheCurrent,
-    planningModel,
-    queryBlockedChapters: queryBlockedContentChapters,
-    summaryCovered,
-    knowledgeGraphCovered,
-    readingGraphCovered
+// src/archive/write.ts
+var import_wiki_graph_core6 = require("wiki-graph-core");
+async function writeWikiGraphArchiveLocation(location, operation, options = {}) {
+  const cacheOnly = options.searchIndexWritebackPolicy === "cache";
+  const write = async (archiveFile = location.archiveFile) => await new import_wiki_graph_core6.WikiGraphArchiveFile(archiveFile).write(operation, {
+    ...cacheOnly ? {} : { derivedStateKeys: [location.archiveKey, location.archivePath] },
+    ...options.invalidateContinuationCursors === void 0 ? {} : {
+      invalidateContinuationCursors: options.invalidateContinuationCursors
+    },
+    ...options.searchIndexWritebackPolicy === void 0 ? {} : { searchIndexWritebackPolicy: options.searchIndexWritebackPolicy }
   });
-  const performanceHints = createGenerationPerformanceHints({
-    chapters: Math.max(
-      0,
-      ...improvements.map((improvement) => improvement.missingChapters ?? 0)
-    ),
-    concurrent,
-    hasJobWork: improvements.some(
-      (improvement) => improvement.planning !== void 0
-    ),
-    hasRequestWork: improvements.some(
-      (improvement) => improvement.planning !== void 0
-    )
-  });
-  return {
-    archiveUri,
-    uri: scopeUri,
-    scope: options.chapterId === void 0 ? { type: "archive" } : { chapterId: options.chapterId, type: "chapter" },
-    content: {
-      chapters: {
-        content: contentChapters.length,
-        planned: chapters.length - contentChapters.length,
-        total: chapters.length
-      },
-      sourceWords,
-      summaryWords
-    },
-    localIndexCache: {
-      current: indexCacheCurrent,
-      ...!queryReady ? {
-        blockedBy: "missing-search-artifacts",
-        impact: "The cache cannot be built until every content chapter has a current FTS or source embedding artifact."
-      } : indexCacheCurrent ? {} : {
-        impact: "The next archive query may need to sync index cache first.",
-        resource: "local CPU/disk time only; no provider calls."
-      },
-      status: !queryReady ? "blocked" : indexCacheCurrent ? "current" : "missing-or-outdated",
-      syncAvailable: queryReady && !indexCacheCurrent
-    },
-    coverage: {
-      ftsIndexArtifact: createInspectCoverage(
-        ftsArtifactCovered,
-        contentChapters
-      ),
-      knowledgeGraph: createInspectCoverage(
-        knowledgeGraphCovered,
-        contentChapters
-      ),
-      readingGraph: createInspectCoverage(readingGraphCovered, contentChapters),
-      summary: createInspectCoverage(summaryCovered, contentChapters),
-      sourceEmbeddingIndexArtifact: createInspectCoverage(
-        sourceEmbeddingArtifactCovered,
-        contentChapters
-      ),
-      summaryEmbeddingIndexArtifact: createInspectCoverage(
-        summaryEmbeddingArtifactCovered,
-        contentChapters
-      )
-    },
-    query: {
-      ready: queryReady
-    },
-    searchArtifacts: {
-      blockedChapters: queryBlockedChapters,
-      ...!queryReady ? {
-        resource: "local CPU/disk time only; no provider calls."
-      } : {},
-      ready: queryReady,
-      status: queryReady ? "ready" : "incomplete"
-    },
-    retrievalGuidance: formatRetrievalGuidance({
-      indexCacheCurrent,
-      knowledgeGraphCovered,
-      readingGraphCovered,
-      contentChapters,
-      queryReady,
-      sourceWords
-    }),
-    improvements,
-    performanceHints,
-    summaryCoverageNote: "Summary coverage means a current summary artifact exists for the chapter; it does not guarantee that every source topic is represented in the summary text."
-  };
-}
-function createInspectChapterReference(archiveUri, chapter) {
-  return {
-    chapterId: chapter.chapterId,
-    locatedUri: formatInspectLocatedChapterUri(archiveUri, chapter),
-    title: chapter.title,
-    uri: chapter.uri
-  };
-}
-function formatInspectLocatedChapterUri(archiveUri, chapter) {
-  return `${archiveUri.replace(/\/+$/u, "")}/${chapter.uri.replace(/^wikg:\/\//u, "")}`;
-}
-async function readInspectChapters(document, chapterId) {
-  const chapters = chapterId === void 0 ? await (0, import_wiki_graph_core4.listChapters)(document) : (await (0, import_wiki_graph_core4.listChapters)(document)).filter(
-    (chapter) => chapter.chapterId === chapterId
-  );
-  if (chapterId !== void 0 && chapters.length === 0) {
-    throw new Error(`Chapter ${chapterId} does not exist.`);
+  if (location.libraryArchiveTarget === void 0 || cacheOnly || options.refreshLibraryIndex === false) {
+    return await write();
   }
-  return await Promise.all(
-    chapters.map(async (chapter) => {
-      const serial = await document.serials.getById(chapter.chapterId);
-      return {
-        ...chapter,
-        knowledgeGraphReady: serial?.knowledgeGraphReady === true,
-        readingGraphReady: serial?.topologyReady === true,
-        summaryReady: chapter.stage === "summarized"
-      };
-    })
-  );
-}
-async function readSummaryWords(document, chapterId) {
-  return await document.readDatabase(
-    async (database) => await database.queryOne(
-      `
-          SELECT COALESCE(SUM(words_count), 0) AS words
-          FROM text_sentence_records
-          WHERE kind = 2
-            ${chapterId === void 0 ? "" : "AND chapter_id = ?"}
-        `,
-      chapterId === void 0 ? void 0 : [chapterId],
-      (row) => Number(row.words)
-    ) ?? 0
-  );
-}
-async function readIndexArtifactCoverage(document, kind, chapterId) {
-  const coverage = await document.indexArtifacts.listCoverage(kind);
-  return chapterId === void 0 ? coverage : coverage.filter((item) => item.serialId === chapterId);
-}
-function filterChaptersByCurrentIndexArtifact(chapters, coverage) {
-  const currentChapterIds = new Set(
-    coverage.filter((item) => item.current).map((item) => item.serialId)
-  );
-  return chapters.filter((chapter) => currentChapterIds.has(chapter.chapterId));
-}
-function createInspectCoverage(covered, total) {
-  const coveredWords = sumWords(covered);
-  const totalWords = sumWords(total);
-  return {
-    coveredChapters: covered.length,
-    coveredWords,
-    percent: formatPercent(coveredWords, totalWords),
-    totalChapters: total.length,
-    totalWords
-  };
-}
-function formatRetrievalGuidance(input) {
-  if (input.sourceWords === 0 || input.contentChapters.length === 0) {
-    return [
-      "Source content: empty.",
-      "Add source text before using query coverage or graph-based retrieval."
-    ];
-  }
-  const lines = [
-    input.queryReady ? `Query: available; local index cache is ${input.indexCacheCurrent ? "current" : "missing or outdated and can be synced from artifacts"}.` : "Query: unavailable until every content chapter has a current FTS or source embedding artifact."
-  ];
-  lines.push(
-    formatObjectSearchGuidance(
-      "Reading Graph object retrieval",
-      input.readingGraphCovered,
-      input.contentChapters
-    )
-  );
-  lines.push(
-    formatObjectSearchGuidance(
-      "Entity/triple retrieval",
-      input.knowledgeGraphCovered,
-      input.contentChapters
-    )
-  );
-  return lines;
-}
-function formatObjectSearchGuidance(label, covered, total) {
-  const coveredWords = sumWords(covered);
-  const totalWords = sumWords(total);
-  const ratio = totalWords === 0 ? 0 : coveredWords / totalWords;
-  const coverage = formatPercent(coveredWords, totalWords);
-  if (ratio >= 1) {
-    return `${label}: covers all source content; it can represent the full scope for object retrieval.`;
-  }
-  if (ratio >= 0.9) {
-    return `${label}: covers ${coverage}; use it as the main path, but source --query is needed for uncovered content.`;
-  }
-  if (ratio >= 0.5) {
-    return `${label}: covers ${coverage}; use it as leads, not as a full-scope substitute for source --query.`;
-  }
-  return `${label}: covers ${coverage}; build missing graph coverage before relying on object retrieval.`;
-}
-function createInspectImprovements(input) {
-  const improvements = [];
-  if (input.contentChapters.length === 0) {
-    improvements.push({
-      kind: "add-source",
-      recommendation: "No source content is available yet; add or import source text before graph or summary generation.",
-      title: "Add source content"
-    });
-    return improvements;
-  }
-  if (input.queryBlockedChapters.length > 0) {
-    improvements.push({
-      kind: "build",
-      missingChapters: input.queryBlockedChapters.length,
-      missingWords: sumWords(input.queryBlockedChapters),
-      recommendation: "Build local FTS artifacts to make this scope queryable. This does not call a provider.",
-      task: "index-fts",
-      title: "Enable query with local FTS"
-    });
-  } else if (!input.indexCacheCurrent) {
-    improvements.push({
-      kind: "sync-index",
-      recommendation: "Sync the index cache from chapter index artifacts so query starts without a lazy cache rebuild.",
-      title: "Sync index cache"
-    });
-  }
-  improvements.push(
-    ...createGraphImprovement({
-      concurrent: input.concurrent,
-      covered: input.readingGraphCovered,
-      planningModel: input.planningModel,
-      task: "reading-graph",
-      title: "Complete Reading Graph coverage",
-      total: input.contentChapters
-    })
-  );
-  improvements.push(
-    ...createGraphImprovement({
-      concurrent: input.concurrent,
-      covered: input.knowledgeGraphCovered,
-      planningModel: input.planningModel,
-      task: "knowledge-graph",
-      title: "Complete Knowledge Graph coverage",
-      total: input.contentChapters
-    })
-  );
-  improvements.push(
-    ...createGraphImprovement({
-      concurrent: input.concurrent,
-      covered: input.summaryCovered,
-      planningModel: input.planningModel,
-      task: "reading-summary",
-      title: "Complete Summary coverage",
-      total: input.contentChapters
-    })
-  );
-  return improvements;
-}
-function createGraphImprovement(input) {
-  const coveredIds = new Set(input.covered.map((chapter) => chapter.chapterId));
-  const missing = input.total.filter(
-    (chapter) => !coveredIds.has(chapter.chapterId)
-  );
-  if (missing.length === 0) {
-    return [];
-  }
-  const missingWords = sumWords(missing);
-  return [
-    {
-      kind: "build",
-      missingChapters: missing.length,
-      missingWords,
-      planning: planGenerationTask(
-        input.task,
-        missingWords,
-        missing.length,
-        input.concurrent,
-        input.planningModel
-      ),
-      recommendation: formatImprovementRecommendation(
-        input.covered,
-        input.total,
-        missingWords
-      ),
-      task: input.task,
-      title: input.title
-    }
-  ];
-}
-function formatImprovementRecommendation(covered, total, missingWords) {
-  const totalWords = sumWords(total);
-  const coveredWords = sumWords(covered);
-  if (totalWords === 0) {
-    return "No source content is available.";
-  }
-  if (total.length === 1 || coveredWords / totalWords >= 0.9 || missingWords <= 1e3) {
-    return "Queue the full scope to finish the remaining gap.";
-  }
-  return "Queue selected chapters first if only part of the scope matters.";
-}
-function sumWords(chapters) {
-  return chapters.reduce((total, chapter) => total + chapter.words, 0);
-}
-function formatPercent(numerator, denominator) {
-  if (denominator === 0) {
-    return "n/a";
-  }
-  const percent = numerator / denominator * 100;
-  return `${Number.isInteger(percent) ? percent.toFixed(0) : percent.toFixed(1)}%`;
+  return await (0, import_wiki_graph_core6.writeWikiGraphLibraryArchive)({
+    additionalDerivedStateKeys: [location.archiveKey, location.archivePath],
+    ...options.invalidateContinuationCursors === void 0 ? {} : {
+      invalidateContinuationCursors: options.invalidateContinuationCursors
+    },
+    ...options.onIndexSyncError === void 0 ? {} : { onIndexSyncError: options.onIndexSyncError },
+    operation: async (archiveFile) => await write(archiveFile),
+    target: location.libraryArchiveTarget
+  });
 }
 
 // src/archive/archive.ts
@@ -2243,13 +2146,13 @@ var WikiGraphArchiveManager = class {
   }
   async create(options) {
     return await this.#runtime.run(async () => {
-      const path = resolveWikiGraphRuntimePath(options.path);
+      const path = await assertStandaloneWikiGraphArchivePath(options.path);
       if (options.replace !== true && await nodePathExists(path)) {
         throw new WikiGraphArchiveExistsError(path);
       }
-      const outputPath = (0, import_path3.join)(
-        (0, import_path3.dirname)(path),
-        `.${(0, import_path3.basename)(path)}.${(0, import_crypto.randomUUID)()}.tmp.wikg`
+      const outputPath = (0, import_path5.join)(
+        (0, import_path5.dirname)(path),
+        `.${(0, import_path5.basename)(path)}.${(0, import_crypto2.randomUUID)()}.tmp.wikg`
       );
       try {
         if (options.importPath === void 0) {
@@ -2263,10 +2166,10 @@ var WikiGraphArchiveManager = class {
           });
         }
         if (options.replace === true) {
-          await (0, import_promises3.rename)(outputPath, path);
+          await (0, import_promises4.rename)(outputPath, path);
         } else {
           try {
-            await (0, import_promises3.link)(outputPath, path);
+            await (0, import_promises4.link)(outputPath, path);
           } catch (error) {
             if (isNodeEEXISTError(error)) {
               throw new WikiGraphArchiveExistsError(path);
@@ -2274,15 +2177,15 @@ var WikiGraphArchiveManager = class {
             throw error;
           }
         }
-        return { locatedUri: (0, import_wiki_graph_core5.formatLocatedWikiGraphUri)(path), path };
+        return { locatedUri: (0, import_wiki_graph_core7.formatLocatedWikiGraphUri)(path), path };
       } finally {
-        await (0, import_promises3.rm)(outputPath, { force: true, recursive: true });
+        await (0, import_promises4.rm)(outputPath, { force: true, recursive: true });
       }
     }, options.signal);
   }
-  async open(uriOrPath, options = {}) {
+  async open(target, options = {}) {
     const location = await this.#runtime.run(
-      async () => await resolveWikiGraphArchiveLocation(uriOrPath),
+      async () => await resolveWikiGraphArchiveLocation(target),
       options.signal
     );
     return new WikiGraphArchiveHandle(this.#runtime, location);
@@ -2305,14 +2208,17 @@ var WikiGraphArchiveHandle = class {
     return this.#location.locatedUri;
   }
   get objectUri() {
-    return (0, import_wiki_graph_core5.parseLocatedWikiGraphUri)(this.#location.locatedUri).objectUri ?? "wikg://";
+    return (0, import_wiki_graph_core7.parseLocatedWikiGraphUri)(this.#location.locatedUri).objectUri ?? "wikg://";
   }
   get path() {
     return this.#location.archivePath;
   }
+  get target() {
+    return this.#location.target;
+  }
   async inspect(options = {}) {
     return await this.#readDocument(
-      async (document) => await createWikiGraphArchiveInspectReport(document, {
+      async (document) => await inspectWikiGraphArchive(document, {
         archiveUri: this.#location.publicArchiveUri ?? this.locatedUri,
         ...options.chapterId === void 0 ? {} : { chapterId: options.chapterId }
       }),
@@ -2331,7 +2237,7 @@ var WikiGraphArchiveHandle = class {
           ...chapters === void 0 ? {} : { chapters },
           ...embeddingProvider === void 0 ? {} : { embeddingProvider }
         });
-        return await (0, import_wiki_graph_core5.findArchiveObjects)(document, query, {
+        return await (0, import_wiki_graph_core7.findArchiveObjects)(document, query, {
           ...withoutOperationAndScope(options),
           archiveKey: this.archiveKey,
           ...chapters === void 0 ? {} : { chapters },
@@ -2346,14 +2252,14 @@ var WikiGraphArchiveHandle = class {
   }
   async list(options = {}) {
     return await this.#readDocument(async (document) => {
-      if ((0, import_wiki_graph_core5.isSourceLocatorScopeUri)(this.objectUri)) {
-        return await (0, import_wiki_graph_core5.listArchiveSourceLocators)(document, this.objectUri, {
+      if ((0, import_wiki_graph_core7.isSourceLocatorScopeUri)(this.objectUri)) {
+        return await (0, import_wiki_graph_core7.listArchiveSourceLocators)(document, this.objectUri, {
           ...options.cursor === void 0 ? {} : { cursor: options.cursor },
           ...options.limit === void 0 ? {} : { limit: options.limit }
         });
       }
       const chapters = await this.#resolveScope(document, options);
-      return await (0, import_wiki_graph_core5.listArchiveCollection)(document, {
+      return await (0, import_wiki_graph_core7.listArchiveCollection)(document, {
         ...withoutOperationAndScope(options),
         ...chapters === void 0 ? {} : { chapters }
       });
@@ -2381,8 +2287,8 @@ var WikiGraphArchiveHandle = class {
   async getSearchIndexStatus(options = {}) {
     return await this.#readDocument(
       async (document) => ({
-        capabilities: await (0, import_wiki_graph_core5.readSearchIndexCapabilityStatus)(document),
-        current: await (0, import_wiki_graph_core5.isArchiveSearchIndexCurrent)(document)
+        capabilities: await (0, import_wiki_graph_core7.readSearchIndexCapabilityStatus)(document),
+        current: await (0, import_wiki_graph_core7.isArchiveSearchIndexCurrent)(document)
       }),
       options
     );
@@ -2390,14 +2296,14 @@ var WikiGraphArchiveHandle = class {
   async syncSearchIndex(options = {}) {
     const rebuilt = await this.#writeDocument(
       async (document) => {
-        const scope = options.skipUnindexed === true ? { chapters: await (0, import_wiki_graph_core5.listArchiveQueryableChapterIds)(document) } : {};
+        const scope = options.skipUnindexed === true ? { chapters: await (0, import_wiki_graph_core7.listArchiveQueryableChapterIds)(document) } : {};
         if (scope.chapters?.length === 0) {
           throw new Error(
             "Wiki Graph index cache is not ready. No chapters have a current FTS artifact or source embedding artifact."
           );
         }
-        if (await (0, import_wiki_graph_core5.isArchiveSearchIndexCurrent)(document, scope)) return false;
-        await (0, import_wiki_graph_core5.rebuildArchiveSearchIndex)(document, options.onProgress, scope);
+        if (await (0, import_wiki_graph_core7.isArchiveSearchIndexCurrent)(document, scope)) return false;
+        await (0, import_wiki_graph_core7.rebuildArchiveSearchIndex)(document, options.onProgress, scope);
         return true;
       },
       {
@@ -2406,7 +2312,7 @@ var WikiGraphArchiveHandle = class {
       }
     );
     await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core5.deleteArchiveSearchSessions)(this.path),
+      async () => await (0, import_wiki_graph_core7.deleteArchiveSearchSessions)(this.path),
       options.signal
     );
     return { rebuilt };
@@ -2429,21 +2335,21 @@ var WikiGraphArchiveHandle = class {
       }
     );
     await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core5.deleteArchiveSearchSessions)(this.path),
+      async () => await (0, import_wiki_graph_core7.deleteArchiveSearchSessions)(this.path),
       options.signal
     );
     return status;
   }
   async listChapters(options = {}) {
     return await this.#readDocument(
-      async (document) => await (0, import_wiki_graph_core5.listChapters)(document),
+      async (document) => await (0, import_wiki_graph_core7.listChapters)(document),
       options
     );
   }
   async getChapter(path, options = {}) {
     return await this.#readDocument(async (document) => {
-      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
-      return requireChapter(await (0, import_wiki_graph_core5.listChapters)(document), chapterId);
+      const chapterId = await (0, import_wiki_graph_core7.resolveChapterPathReadonly)(document, path);
+      return requireChapter(await (0, import_wiki_graph_core7.listChapters)(document), chapterId);
     }, options);
   }
   async addChapter(options) {
@@ -2452,17 +2358,17 @@ var WikiGraphArchiveHandle = class {
         document,
         options.parentPath
       );
-      await (0, import_wiki_graph_core5.assertNoActiveBuildJobConflicts)({
+      await (0, import_wiki_graph_core7.assertNoActiveBuildJobConflicts)({
         archive: this.#location.archiveFile,
         operation: "Adding chapter",
         scope: { kind: "archive" }
       });
-      let details = await (0, import_wiki_graph_core5.addChapter)(document, {
+      let details = await (0, import_wiki_graph_core7.addChapter)(document, {
         ...parentChapterId === void 0 ? {} : { parentChapterId },
         ...options.title === void 0 ? {} : { title: options.title }
       });
       if (options.source !== void 0) {
-        details = await (0, import_wiki_graph_core5.setChapterSource)(
+        details = await (0, import_wiki_graph_core7.setChapterSource)(
           document,
           details.chapterId,
           asTextStream(options.source)
@@ -2473,7 +2379,7 @@ var WikiGraphArchiveHandle = class {
   }
   async getChapterArtifact(path, kind) {
     return await this.#readDocument(async (document) => {
-      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+      const chapterId = await (0, import_wiki_graph_core7.resolveChapterPathReadonly)(document, path);
       const [artifact, revision] = await Promise.all([
         document.indexArtifacts.get(chapterId, kind),
         document.serials.getRevision(chapterId)
@@ -2496,25 +2402,25 @@ var WikiGraphArchiveHandle = class {
   }
   async deleteChapterArtifact(path, kind) {
     return await this.#writeDocument(async (document) => {
-      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+      const chapterId = await (0, import_wiki_graph_core7.resolveChapterPathReadonly)(document, path);
       await document.indexArtifacts.delete(chapterId, kind);
       return { chapterId, deleted: true, kind };
     });
   }
   async moveChapter(path, options) {
     return await this.#writeDocument(async (document) => {
-      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+      const chapterId = await (0, import_wiki_graph_core7.resolveChapterPathReadonly)(document, path);
       const [afterChapterId, beforeChapterId, parentChapterId] = await Promise.all([
         resolveOptionalChapterPath(document, options.afterPath),
         resolveOptionalChapterPath(document, options.beforePath),
         resolveOptionalChapterPath(document, options.parentPath)
       ]);
-      await (0, import_wiki_graph_core5.assertNoActiveBuildJobConflicts)({
+      await (0, import_wiki_graph_core7.assertNoActiveBuildJobConflicts)({
         archive: this.#location.archiveFile,
         operation: "Moving chapter",
         scope: { kind: "archive" }
       });
-      return await (0, import_wiki_graph_core5.moveChapter)(document, chapterId, {
+      return await (0, import_wiki_graph_core7.moveChapter)(document, chapterId, {
         ...afterChapterId === void 0 ? {} : { afterChapterId },
         ...beforeChapterId === void 0 ? {} : { beforeChapterId },
         ...parentChapterId === void 0 ? {} : { parentChapterId },
@@ -2526,35 +2432,35 @@ var WikiGraphArchiveHandle = class {
   }
   async removeChapter(path, recursive = false) {
     await this.#writeDocument(async (document) => {
-      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
-      await (0, import_wiki_graph_core5.assertNoActiveBuildJobConflicts)({
+      const chapterId = await (0, import_wiki_graph_core7.resolveChapterPathReadonly)(document, path);
+      await (0, import_wiki_graph_core7.assertNoActiveBuildJobConflicts)({
         archive: this.#location.archiveFile,
         operation: "Removing chapter",
         scope: { kind: "archive" }
       });
-      await (0, import_wiki_graph_core5.removeChapter)(document, chapterId, { recursive });
+      await (0, import_wiki_graph_core7.removeChapter)(document, chapterId, { recursive });
     });
   }
   async resetChapter(path, stage) {
     return await this.#writeDocument(async (document) => {
-      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+      const chapterId = await (0, import_wiki_graph_core7.resolveChapterPathReadonly)(document, path);
       await assertChapterResetAllowed(
         this.#location.archiveFile,
         chapterId,
         stage
       );
-      return await (0, import_wiki_graph_core5.resetChapter)(document, chapterId, stage);
+      return await (0, import_wiki_graph_core7.resetChapter)(document, chapterId, stage);
     });
   }
   async setChapterSource(path, source, options = {}) {
     return await this.#writeDocument(async (document) => {
-      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
-      await (0, import_wiki_graph_core5.assertNoActiveBuildJobs)({
+      const chapterId = await (0, import_wiki_graph_core7.resolveChapterPathReadonly)(document, path);
+      await (0, import_wiki_graph_core7.assertNoActiveBuildJobs)({
         archive: this.#location.archiveFile,
         chapterIds: [chapterId],
         operation: "Setting chapter source"
       });
-      return await (0, import_wiki_graph_core5.setChapterSource)(
+      return await (0, import_wiki_graph_core7.setChapterSource)(
         document,
         chapterId,
         asTextStream(source),
@@ -2564,43 +2470,43 @@ var WikiGraphArchiveHandle = class {
   }
   async setChapterSummary(path, summary) {
     return await this.#writeDocument(async (document) => {
-      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
-      await (0, import_wiki_graph_core5.assertNoActiveBuildJobs)({
+      const chapterId = await (0, import_wiki_graph_core7.resolveChapterPathReadonly)(document, path);
+      await (0, import_wiki_graph_core7.assertNoActiveBuildJobs)({
         archive: this.#location.archiveFile,
         chapterIds: [chapterId],
         operation: "Setting chapter summary",
         requiresTarget: "reading-summary"
       });
-      return await (0, import_wiki_graph_core5.setChapterSummary)(document, chapterId, summary);
+      return await (0, import_wiki_graph_core7.setChapterSummary)(document, chapterId, summary);
     });
   }
   async setChapterTitle(path, title) {
     return await this.#writeDocument(async (document) => {
-      const chapterId = await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
-      await (0, import_wiki_graph_core5.assertNoActiveBuildJobs)({
+      const chapterId = await (0, import_wiki_graph_core7.resolveChapterPathReadonly)(document, path);
+      await (0, import_wiki_graph_core7.assertNoActiveBuildJobs)({
         archive: this.#location.archiveFile,
         chapterIds: [chapterId],
         operation: "Setting chapter title"
       });
-      return await (0, import_wiki_graph_core5.setChapterTitle)(document, chapterId, title);
+      return await (0, import_wiki_graph_core7.setChapterTitle)(document, chapterId, title);
     });
   }
   async getChapterTree() {
     return await this.#readDocument(
-      async (document) => await (0, import_wiki_graph_core5.getChapterTree)(document)
+      async (document) => await (0, import_wiki_graph_core7.getChapterTree)(document)
     );
   }
   async applyChapterTree(tree, options = {}) {
     return await this.#writeDocument(
       async (document) => {
         if (options.dryRun !== true) {
-          await (0, import_wiki_graph_core5.assertNoActiveBuildJobConflicts)({
+          await (0, import_wiki_graph_core7.assertNoActiveBuildJobConflicts)({
             archive: this.#location.archiveFile,
             operation: "Changing chapter tree",
             scope: { kind: "archive" }
           });
         }
-        return await (0, import_wiki_graph_core5.applyChapterTree)(document, tree, {
+        return await (0, import_wiki_graph_core7.applyChapterTree)(document, tree, {
           dryRun: options.dryRun ?? false
         });
       },
@@ -2612,8 +2518,8 @@ var WikiGraphArchiveHandle = class {
       async () => await withConfiguredWikimediaResolver(
         objectUri,
         async (wikimediaOptions) => await this.#readDocument(
-          async (document) => await (0, import_wiki_graph_core5.readArchivePage)(document, objectUri, {
-            ...withoutOperation(options),
+          async (document) => await (0, import_wiki_graph_core7.readArchivePage)(document, objectUri, {
+            ...options,
             ...wikimediaOptions
           }),
           options
@@ -2626,7 +2532,7 @@ var WikiGraphArchiveHandle = class {
     if (options.query === void 0) {
       return await this.#readDocument(async (document) => {
         const chapters = await this.#resolveScope(document, {});
-        return await (0, import_wiki_graph_core5.listRelatedArchiveObjects)(document, objectUri, {
+        return await (0, import_wiki_graph_core7.listRelatedArchiveObjects)(document, objectUri, {
           ...withoutOperation(options),
           ...chapters === void 0 ? {} : { chapters }
         });
@@ -2643,7 +2549,7 @@ var WikiGraphArchiveHandle = class {
           ...chapters === void 0 ? {} : { chapters },
           ...embeddingProvider === void 0 ? {} : { embeddingProvider }
         });
-        return await (0, import_wiki_graph_core5.listRelatedArchiveObjects)(document, objectUri, {
+        return await (0, import_wiki_graph_core7.listRelatedArchiveObjects)(document, objectUri, {
           ...withoutOperation(options),
           ...chapters === void 0 ? {} : { chapters }
         });
@@ -2658,7 +2564,7 @@ var WikiGraphArchiveHandle = class {
     if (options.query === void 0) {
       return await this.#readDocument(async (document) => {
         const chapters = await this.#resolveScope(document, {});
-        return await (0, import_wiki_graph_core5.listArchiveEvidence)(document, objectUri, {
+        return await (0, import_wiki_graph_core7.listArchiveEvidence)(document, objectUri, {
           ...withoutOperation(options),
           ...chapters === void 0 ? {} : { chapters }
         });
@@ -2675,7 +2581,7 @@ var WikiGraphArchiveHandle = class {
           ...chapters === void 0 ? {} : { chapters },
           ...embeddingProvider === void 0 ? {} : { embeddingProvider }
         });
-        return await (0, import_wiki_graph_core5.listArchiveEvidence)(document, objectUri, {
+        return await (0, import_wiki_graph_core7.listArchiveEvidence)(document, objectUri, {
           ...withoutOperation(options),
           ...chapters === void 0 ? {} : { chapters }
         });
@@ -2688,7 +2594,7 @@ var WikiGraphArchiveHandle = class {
   }
   async pack(objectUri = this.objectUri, budget = 5e3, options = {}) {
     return await this.#readDocument(
-      async (document) => await (0, import_wiki_graph_core5.packArchiveContext)(document, objectUri, budget),
+      async (document) => await (0, import_wiki_graph_core7.packArchiveContext)(document, objectUri, budget),
       options
     );
   }
@@ -2711,7 +2617,7 @@ var WikiGraphArchiveHandle = class {
     }, options);
   }
   async readCover(options = {}) {
-    const app = new import_wiki_graph_core5.WikiGraph({});
+    const app = new import_wiki_graph_core7.WikiGraph({});
     return await this.#runtime.run(
       async () => await app.openSession(
         this.#location.archiveFile,
@@ -2759,7 +2665,7 @@ var WikiGraphArchiveHandle = class {
   }
   async #readDocument(operation, options = {}) {
     return await this.#runtime.run(
-      async () => await new import_wiki_graph_core5.WikiGraphArchiveFile(this.#location.archiveFile).readDocument(
+      async () => await new import_wiki_graph_core7.WikiGraphArchiveFile(this.#location.archiveFile).readDocument(
         operation
       ),
       options.signal
@@ -2767,17 +2673,13 @@ var WikiGraphArchiveHandle = class {
   }
   async #writeDocument(operation, options = {}) {
     return await this.#runtime.run(async () => {
-      const result = await new import_wiki_graph_core5.WikiGraphArchiveFile(
-        this.#location.archiveFile
-      ).write(operation, {
+      return await writeWikiGraphArchiveLocation(this.#location, operation, {
+        ...options.onIndexSyncError === void 0 ? {} : { onIndexSyncError: options.onIndexSyncError },
+        ...options.refreshLibraryIndex === void 0 ? {} : { refreshLibraryIndex: options.refreshLibraryIndex },
         ...options.searchIndexWritebackPolicy === void 0 ? {} : {
           searchIndexWritebackPolicy: options.searchIndexWritebackPolicy
         }
       });
-      if (options.refreshLibraryIndex !== false) {
-        await this.#refreshLibraryIndex(options.onIndexSyncError);
-      }
-      return result;
     }, options.signal);
   }
   async #resolveScope(document, options) {
@@ -2787,7 +2689,7 @@ var WikiGraphArchiveHandle = class {
   async #resolveQueryChapters(document, options) {
     const chapters = await this.#resolveScope(document, options);
     if (options.skipUnindexed !== true) return chapters;
-    const queryable = await (0, import_wiki_graph_core5.listArchiveQueryableChapterIds)(document, {
+    const queryable = await (0, import_wiki_graph_core7.listArchiveQueryableChapterIds)(document, {
       ...chapters === void 0 ? {} : { chapters }
     });
     if (queryable.length === 0) {
@@ -2797,56 +2699,11 @@ var WikiGraphArchiveHandle = class {
     }
     return queryable;
   }
-  async #refreshLibraryIndex(onError) {
-    if (this.#location.libraryDirtyTarget === void 0) return;
-    if (this.#location.libraryArchiveTarget !== void 0) {
-      await (0, import_wiki_graph_core5.finalizeWikiGraphLibraryArchiveWrite)({
-        target: this.#location.libraryArchiveTarget
-      });
-    }
-    try {
-      const state = await (0, import_wiki_graph_core5.readWikiGraphLibraryIndexState)(
-        this.#location.libraryDirtyTarget
-      );
-      if (state.status !== "missing") {
-        await (0, import_wiki_graph_core5.rebuildWikiGraphLibraryIndex)(this.#location.libraryDirtyTarget);
-      }
-    } catch (error) {
-      onError?.(error);
-    }
-  }
 };
-async function resolveWikiGraphArchiveLocation(uriOrPath) {
-  if (!uriOrPath.startsWith("wikg://")) {
-    return createPathLocation(resolveWikiGraphRuntimePath(uriOrPath));
-  }
-  const parsed = (0, import_wiki_graph_core5.parseLocatedWikiGraphUri)(uriOrPath);
-  const portableArchiveLocator = parsed.archivePath ?? uriOrPath;
-  const archiveLocator = portableArchiveLocator.startsWith("wikg://lib/") ? portableArchiveLocator : resolveWikiGraphRuntimePath(portableArchiveLocator);
-  const libraryArchiveTarget = archiveLocator.startsWith("wikg://lib/") ? (0, import_wiki_graph_core5.parseWikiGraphLibraryUri)(archiveLocator) : void 0;
-  const archiveFile = libraryArchiveTarget?.kind === "archive" ? await (0, import_wiki_graph_core5.resolveWikiGraphLibraryArchiveFile)(archiveLocator) : new NodeFile(archiveLocator);
-  const archivePath = getNodeResourcePath(archiveFile);
-  return {
-    archiveFile,
-    archiveKey: archivePath,
-    archivePath,
-    indexScope: { archiveKey: archivePath, archivePath, kind: "archive-index" },
-    ...libraryArchiveTarget?.kind === "archive" ? {
-      libraryArchiveTarget,
-      libraryDirtyTarget: {
-        isDefault: libraryArchiveTarget.isDefault,
-        kind: "scope",
-        ...libraryArchiveTarget.publicId === void 0 ? {} : { publicId: libraryArchiveTarget.publicId }
-      },
-      publicArchiveUri: portableArchiveLocator
-    } : {},
-    locatedUri: (0, import_wiki_graph_core5.formatLocatedWikiGraphUri)(archivePath, parsed.objectUri)
-  };
-}
 async function ensureArchiveSearchIndex(document, options = {}) {
   const scope = options.chapters === void 0 ? {} : { chapters: options.chapters };
-  if (await (0, import_wiki_graph_core5.isArchiveSearchIndexCurrent)(document, scope)) return;
-  await (0, import_wiki_graph_core5.rebuildArchiveSearchIndex)(document, void 0, {
+  if (await (0, import_wiki_graph_core7.isArchiveSearchIndexCurrent)(document, scope)) return;
+  await (0, import_wiki_graph_core7.rebuildArchiveSearchIndex)(document, void 0, {
     ...scope,
     ...options.embeddingProvider === void 0 ? {} : { embeddingProvider: options.embeddingProvider }
   });
@@ -2856,10 +2713,10 @@ async function resolveArchiveScope(document, objectUri, depth) {
   if (parsed === void 0 || parsed.kind === "collection" && depth === void 0) {
     return void 0;
   }
-  const chapters = await (0, import_wiki_graph_core5.listChapters)(document);
+  const chapters = await (0, import_wiki_graph_core7.listChapters)(document);
   const entries = parsed.kind === "collection" ? chapters.filter((chapter) => chapter.depth <= depth) : selectChapterSubtree(
     chapters,
-    await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, parsed.chapterPath),
+    await (0, import_wiki_graph_core7.resolveChapterPathReadonly)(document, parsed.chapterPath),
     depth
   );
   return { chapterIds: entries.map((entry) => entry.chapterId), entries };
@@ -2881,32 +2738,23 @@ function selectChapterSubtree(chapters, rootChapterId, depth) {
     (chapter) => chapter.chapterId === root.chapterId || chapter.path.startsWith(prefix) && (depth === void 0 || chapter.depth - root.depth <= depth)
   );
 }
-function createPathLocation(path) {
-  return {
-    archiveFile: new NodeFile(path),
-    archiveKey: path,
-    archivePath: path,
-    indexScope: { archiveKey: path, archivePath: path, kind: "archive-index" },
-    locatedUri: (0, import_wiki_graph_core5.formatLocatedWikiGraphUri)(path)
-  };
-}
 async function createEmptyArchiveFile(path) {
-  const directoryPath = await (0, import_promises3.mkdtemp)(
-    (0, import_path3.join)((0, import_os3.tmpdir)(), "wikigraph-archive-write-")
+  const directoryPath = await (0, import_promises4.mkdtemp)(
+    (0, import_path5.join)((0, import_os3.tmpdir)(), "wikigraph-archive-write-")
   );
   try {
     const directory = new NodeDirectory(directoryPath);
-    const document = await import_wiki_graph_core5.DirectoryDocument.open(directory);
+    const document = await import_wiki_graph_core7.DirectoryDocument.open(directory);
     try {
       await document.openSession(async (openedDocument) => {
-        await openedDocument.writeToc({ items: [], version: import_wiki_graph_core5.TOC_FILE_VERSION });
+        await openedDocument.writeToc({ items: [], version: import_wiki_graph_core7.TOC_FILE_VERSION });
       });
     } finally {
       await document.release();
     }
-    await (0, import_wiki_graph_core5.writeWikgArchive)(directory, new NodeFile(path));
+    await (0, import_wiki_graph_core7.writeWikgArchive)(directory, new NodeFile(path));
   } finally {
-    await (0, import_promises3.rm)(directoryPath, { force: true, recursive: true });
+    await (0, import_promises4.rm)(directoryPath, { force: true, recursive: true });
   }
 }
 function isNodeEEXISTError(error) {
@@ -2914,7 +2762,7 @@ function isNodeEEXISTError(error) {
 }
 async function nodePathExists(path) {
   try {
-    await (0, import_promises3.stat)(path);
+    await (0, import_promises4.stat)(path);
     return true;
   } catch (error) {
     if (isNodeENOENTError(error)) return false;
@@ -2926,13 +2774,13 @@ function isNodeENOENTError(error) {
 }
 function parseObjectMetadataTarget(objectPath) {
   if (objectPath === "") {
-    return { kind: import_wiki_graph_core5.ObjectMetadataKind.Archive, objectPath };
+    return { kind: import_wiki_graph_core7.ObjectMetadataKind.Archive, objectPath };
   }
   const chapter = /^chapter\/([1-9][0-9]*)(?:\/.*)?$/u.exec(objectPath);
   if (chapter?.[1] !== void 0) {
     return {
       chapterId: Number(chapter[1]),
-      kind: import_wiki_graph_core5.ObjectMetadataKind.Chapter,
+      kind: import_wiki_graph_core7.ObjectMetadataKind.Chapter,
       objectPath
     };
   }
@@ -2940,7 +2788,7 @@ function parseObjectMetadataTarget(objectPath) {
   if (chunk?.[1] !== void 0) {
     return {
       chunkId: Number(chunk[1]),
-      kind: import_wiki_graph_core5.ObjectMetadataKind.Chunk,
+      kind: import_wiki_graph_core7.ObjectMetadataKind.Chunk,
       objectPath
     };
   }
@@ -2948,7 +2796,7 @@ function parseObjectMetadataTarget(objectPath) {
   if (entity?.[1] !== void 0) {
     return {
       entityQid: entity[1],
-      kind: import_wiki_graph_core5.ObjectMetadataKind.Entity,
+      kind: import_wiki_graph_core7.ObjectMetadataKind.Entity,
       objectPath
     };
   }
@@ -2957,14 +2805,14 @@ function parseObjectMetadataTarget(objectPath) {
   );
   if (triple?.[1] !== void 0) {
     return {
-      kind: import_wiki_graph_core5.ObjectMetadataKind.Triple,
+      kind: import_wiki_graph_core7.ObjectMetadataKind.Triple,
       objectPath,
       tripleObjectQid: triple[3],
       triplePredicate: decodeURIComponent(triple[2]),
       tripleSubjectQid: triple[1]
     };
   }
-  return { kind: import_wiki_graph_core5.ObjectMetadataKind.Object, objectPath };
+  return { kind: import_wiki_graph_core7.ObjectMetadataKind.Object, objectPath };
 }
 function withoutOperation(options) {
   const { signal: _signal, ...rest } = options;
@@ -2980,7 +2828,7 @@ function withoutOperationAndScope(options) {
   return rest;
 }
 async function resolveOptionalChapterPath(document, path) {
-  return path === void 0 ? void 0 : await (0, import_wiki_graph_core5.resolveChapterPathReadonly)(document, path);
+  return path === void 0 ? void 0 : await (0, import_wiki_graph_core7.resolveChapterPathReadonly)(document, path);
 }
 function requireChapter(chapters, chapterId) {
   const chapter = chapters.find((entry) => entry.chapterId === chapterId);
@@ -2994,7 +2842,7 @@ function asTextStream(text) {
 }
 async function assertChapterResetAllowed(archive, chapterId, stage) {
   if (stage === "planned") {
-    await (0, import_wiki_graph_core5.assertNoActiveBuildJobs)({
+    await (0, import_wiki_graph_core7.assertNoActiveBuildJobs)({
       archive,
       chapterIds: [chapterId],
       operation: "Resetting chapter to planned"
@@ -3002,14 +2850,14 @@ async function assertChapterResetAllowed(archive, chapterId, stage) {
     return;
   }
   if (stage === "sourced") {
-    await (0, import_wiki_graph_core5.assertNoActiveBuildJobs)({
+    await (0, import_wiki_graph_core7.assertNoActiveBuildJobs)({
       archive,
       chapterIds: [chapterId],
       operation: "Resetting chapter graph",
       requiresTarget: "reading-graph"
     });
   }
-  await (0, import_wiki_graph_core5.assertNoActiveBuildJobs)({
+  await (0, import_wiki_graph_core7.assertNoActiveBuildJobs)({
     archive,
     chapterIds: [chapterId],
     operation: "Resetting chapter summary",
@@ -3020,12 +2868,13 @@ async function assertChapterResetAllowed(archive, chapterId, stage) {
 // src/wikispine.ts
 var import_child_process = require("child_process");
 var nodeWikispineCommandRunner = {
-  run: async ({ args, command, input, onStdout, signal }) => await new Promise((resolve3, reject) => {
+  run: async ({ args, command, input, onStdout, signal }) => await new Promise((resolve4, reject) => {
     signal?.throwIfAborted();
     const child = (0, import_child_process.spawn)(command, [...args], {
       stdio: ["pipe", "pipe", "pipe"]
     });
     const stderr = [];
+    let stdoutQueue = Promise.resolve();
     let settled = false;
     const settle = (operation) => {
       if (settled) return;
@@ -3041,14 +2890,15 @@ var nodeWikispineCommandRunner = {
     child.stdout.setEncoding("utf8");
     child.stdout.on("data", (chunk) => {
       if (settled) return;
-      try {
-        onStdout(chunk);
-      } catch (error) {
+      child.stdout.pause();
+      stdoutQueue = stdoutQueue.then(async () => await onStdout(chunk)).then(() => {
+        child.stdout.resume();
+      }).catch((error) => {
         child.kill();
         settle(
           () => reject(error instanceof Error ? error : new Error(String(error)))
         );
-      }
+      });
     });
     child.stderr.on("data", (chunk) => stderr.push(chunk));
     child.on("error", (error) => {
@@ -3059,12 +2909,14 @@ var nodeWikispineCommandRunner = {
       );
     });
     child.on("close", (exitCode) => {
-      settle(
-        () => resolve3({
-          exitCode,
-          stderr: Buffer.concat(stderr).toString("utf8")
-        })
-      );
+      void stdoutQueue.then(() => {
+        settle(
+          () => resolve4({
+            exitCode,
+            stderr: Buffer.concat(stderr).toString("utf8")
+          })
+        );
+      });
     });
     child.stdin.end(input);
   })
@@ -3075,7 +2927,7 @@ function abortError(signal) {
 
 // src/config.ts
 var import_ai2 = require("ai");
-var import_wiki_graph_core6 = require("wiki-graph-core");
+var import_wiki_graph_core8 = require("wiki-graph-core");
 var WikiGraphConfigManager = class {
   #runtime;
   constructor(runtime) {
@@ -3158,7 +3010,7 @@ var WikiGraphConfigManager = class {
       if (resolved === void 0) {
         throw new Error("WikiSpine provider is not configured.");
       }
-      const result = await (0, import_wiki_graph_core6.testWikispineRuntime)({
+      const result = await (0, import_wiki_graph_core8.testWikispineRuntime)({
         ...resolved,
         ...resolved.provider === "cli" ? { commandRunner: nodeWikispineCommandRunner } : {}
       });
@@ -3181,7 +3033,7 @@ function parseProvider(value) {
 }
 
 // src/continuations.ts
-var import_wiki_graph_core7 = require("wiki-graph-core");
+var import_wiki_graph_core9 = require("wiki-graph-core");
 var WikiGraphContinuationManager = class {
   #runtime;
   constructor(runtime) {
@@ -3196,13 +3048,13 @@ var WikiGraphContinuationManager = class {
   async create(context, cursor) {
     if (cursor === null || cursor === void 0) return null;
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core7.createContinuationCursor)(
+      async () => await (0, import_wiki_graph_core9.createContinuationCursor)(
         createContinuationPayload(context, cursor)
       )
     );
   }
   async #next(options) {
-    const cursor = await (0, import_wiki_graph_core7.readContinuationCursor)(options.cursor);
+    const cursor = await (0, import_wiki_graph_core9.readContinuationCursor)(options.cursor);
     const continuationCursor = options.format === void 0 ? cursor : { ...cursor, format: options.format };
     const limit = options.limit ?? 20;
     if (options.archive !== void 0) {
@@ -3227,29 +3079,29 @@ var WikiGraphContinuationManager = class {
 };
 async function continueArchiveCursor(cursor, limit) {
   const location = await resolveWikiGraphArchiveLocation(
-    getCursorArchivePath(cursor)
+    archiveTargetFromLogicalLocator(getCursorArchivePath(cursor))
   );
-  return await new import_wiki_graph_core7.WikiGraphArchiveFile(location.archiveFile).readDocument(
+  return await new import_wiki_graph_core9.WikiGraphArchiveFile(location.archiveFile).readDocument(
     async (document) => {
       switch (cursor.kind) {
         case "source-locators":
-          return await (0, import_wiki_graph_core7.listArchiveSourceLocators)(document, cursor.targetUri, {
+          return await (0, import_wiki_graph_core9.listArchiveSourceLocators)(document, cursor.targetUri, {
             cursor: cursor.cursor,
             limit
           });
         case "collection":
-          return await (0, import_wiki_graph_core7.listArchiveCollection)(
+          return await (0, import_wiki_graph_core9.listArchiveCollection)(
             document,
             createCollectionOptions(cursor, limit)
           );
         case "search":
-          return await (0, import_wiki_graph_core7.findArchiveObjects)(
+          return await (0, import_wiki_graph_core9.findArchiveObjects)(
             document,
             cursor.query ?? "",
             await createFindOptions(cursor, limit)
           );
         case "evidence":
-          return await (0, import_wiki_graph_core7.listArchiveEvidence)(document, cursor.targetUri, {
+          return await (0, import_wiki_graph_core9.listArchiveEvidence)(document, cursor.targetUri, {
             ...cursor.chapters === null ? {} : { chapters: cursor.chapters },
             cursor: cursor.cursor,
             limit,
@@ -3259,7 +3111,7 @@ async function continueArchiveCursor(cursor, limit) {
             ...cursor.sourceContext === void 0 ? {} : { sourceContext: cursor.sourceContext }
           });
         case "related":
-          return await (0, import_wiki_graph_core7.listRelatedArchiveObjects)(document, cursor.targetUri, {
+          return await (0, import_wiki_graph_core9.listRelatedArchiveObjects)(document, cursor.targetUri, {
             ...cursor.chapters === null ? {} : { chapters: cursor.chapters },
             cursor: cursor.cursor,
             ...cursor.evidenceLimit === void 0 ? {} : { evidenceLimit: cursor.evidenceLimit },
@@ -3283,30 +3135,30 @@ async function continueLibraryCursor(cursor, limit) {
   if (cursor.indexScope.kind !== "library-index") {
     throw new Error("Internal error: expected a library index cursor.");
   }
-  const target = await (0, import_wiki_graph_core7.resolveWikiGraphLibraryQueryTargetById)(
+  const target = await (0, import_wiki_graph_core9.resolveWikiGraphLibraryQueryTargetById)(
     cursor.indexScope.libraryId
   );
   switch (cursor.kind) {
     case "collection":
-      return await (requireLibraryQuery(cursor) === "archive-members" ? (0, import_wiki_graph_core7.listWikiGraphLibraryArchiveMembers)(
+      return await (requireLibraryQuery(cursor) === "archive-members" ? (0, import_wiki_graph_core9.listWikiGraphLibraryArchiveMembers)(
         target,
         createCollectionOptions(cursor, limit)
-      ) : (0, import_wiki_graph_core7.listWikiGraphLibraryObjects)(
+      ) : (0, import_wiki_graph_core9.listWikiGraphLibraryObjects)(
         target,
         createCollectionOptions(cursor, limit)
       ));
     case "search":
-      return await (requireLibraryQuery(cursor) === "archive-members" ? (0, import_wiki_graph_core7.findWikiGraphLibraryArchiveMembers)(
+      return await (requireLibraryQuery(cursor) === "archive-members" ? (0, import_wiki_graph_core9.findWikiGraphLibraryArchiveMembers)(
         target,
         cursor.query ?? "",
         await createFindOptions(cursor, limit)
-      ) : (0, import_wiki_graph_core7.findWikiGraphLibraryObjects)(
+      ) : (0, import_wiki_graph_core9.findWikiGraphLibraryObjects)(
         target,
         cursor.query ?? "",
         await createFindOptions(cursor, limit)
       ));
     case "evidence":
-      return await (0, import_wiki_graph_core7.listWikiGraphLibraryEvidence)(target, cursor.targetUri, {
+      return await (0, import_wiki_graph_core9.listWikiGraphLibraryEvidence)(target, cursor.targetUri, {
         cursor: cursor.cursor,
         limit,
         order: cursor.order,
@@ -3315,7 +3167,7 @@ async function continueLibraryCursor(cursor, limit) {
         ...cursor.sourceContext === void 0 ? {} : { sourceContext: cursor.sourceContext }
       });
     case "related":
-      return await (0, import_wiki_graph_core7.listRelatedWikiGraphLibraryObjects)(
+      return await (0, import_wiki_graph_core9.listRelatedWikiGraphLibraryObjects)(
         target,
         cursor.targetUri,
         {
@@ -3376,7 +3228,7 @@ function getCursorArchivePath(cursor) {
 }
 async function persistResultCursor(cursor, result) {
   if (result.nextCursor === null) return result;
-  const nextCursor = await (0, import_wiki_graph_core7.createContinuationCursor)({
+  const nextCursor = await (0, import_wiki_graph_core9.createContinuationCursor)({
     ...cursor,
     cursor: result.nextCursor
   });
@@ -3479,17 +3331,17 @@ function createLibraryQueryPayload(context) {
 }
 
 // src/default-worker.ts
-var import_wiki_graph_core11 = require("wiki-graph-core");
+var import_wiki_graph_core14 = require("wiki-graph-core");
 var import_worker3 = require("wiki-graph-core/worker");
 
 // src/stage.ts
-var import_wiki_graph_core8 = require("wiki-graph-core");
-var import_wiki_graph_core9 = require("wiki-graph-core");
 var import_wiki_graph_core10 = require("wiki-graph-core");
+var import_wiki_graph_core11 = require("wiki-graph-core");
+var import_wiki_graph_core12 = require("wiki-graph-core");
 function createStageLLM(config, options) {
   const llmOptions = buildWikiGraphLLMOptions(config);
-  return new import_wiki_graph_core10.LLM({
-    sampling: (0, import_wiki_graph_core9.createDefaultWikiGraphSampling)({
+  return new import_wiki_graph_core12.LLM({
+    sampling: (0, import_wiki_graph_core11.createDefaultWikiGraphSampling)({
       ...llmOptions.temperature === void 0 ? {} : { temperature: llmOptions.temperature },
       ...llmOptions.topP === void 0 ? {} : { topP: llmOptions.topP }
     }),
@@ -3512,8 +3364,134 @@ async function loadRequiredStageConfig(options) {
   return config;
 }
 
+// src/planning.ts
+var DEFAULT_GENERATION_JOB_CONCURRENCY = 3;
+var DEFAULT_GENERATION_REQUEST_CONCURRENCY = 6;
+function planGenerationTask(task, words, chapters, concurrent, model) {
+  const profile = getGenerationPlanningProfile(task);
+  const calls = Math.max(chapters, Math.ceil(words / profile.wordsPerCall));
+  const effectiveConcurrency = Math.max(
+    1,
+    task === "reading-graph" ? 1 : concurrent.request
+  );
+  const callBatches = Math.ceil(calls / effectiveConcurrency);
+  const wordSeconds = words * profile.secondsPerWord;
+  return {
+    model,
+    timeSeconds: {
+      max: Math.ceil(callBatches * profile.maxSecondsPerCall + wordSeconds),
+      min: Math.ceil(callBatches * profile.minSecondsPerCall + wordSeconds)
+    },
+    tokens: {
+      cacheableInput: Math.ceil(words * profile.cacheableInputTokenPerWord),
+      input: Math.ceil(words * profile.inputTokenPerWord),
+      output: Math.ceil(words * profile.outputTokenPerWord)
+    }
+  };
+}
+function createGenerationPerformanceHints(input) {
+  if (!input.hasJobWork) {
+    return [];
+  }
+  const hints = [];
+  const recommendedRequest = input.concurrent.request < 4 ? DEFAULT_GENERATION_REQUEST_CONCURRENCY : input.concurrent.request < 8 ? 8 : void 0;
+  if (input.hasRequestWork && recommendedRequest !== void 0) {
+    hints.push({
+      configKey: "request",
+      configValue: recommendedRequest,
+      current: input.concurrent.request,
+      kind: "request",
+      message: "LLM request concurrency can often be higher. Use at least 4; 6-8 is usually faster when the provider allows it.",
+      recommended: recommendedRequest
+    });
+  }
+  if (input.concurrent.job < 4 && input.chapters > 1) {
+    hints.push({
+      configKey: "job",
+      configValue: 4,
+      current: input.concurrent.job,
+      kind: "job",
+      message: "Multiple chapters need work and job concurrency is below 4. Raising it lets chapter jobs run in parallel.",
+      recommended: 4
+    });
+  }
+  return hints;
+}
+function formatGenerationPlanningModel(llm) {
+  if (llm?.model === void 0) {
+    return "not configured";
+  }
+  return llm.provider === void 0 ? llm.model : `${llm.provider}/${llm.model}`;
+}
+function formatGenerationPlanningDuration(seconds) {
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) {
+    return `${minutes}m`;
+  }
+  return `${Math.round(minutes / 60)}h`;
+}
+function getGenerationPlanningProfile(task) {
+  switch (task) {
+    case "index-fts":
+      return {
+        cacheableInputTokenPerWord: 0,
+        inputTokenPerWord: 0,
+        maxSecondsPerCall: 1,
+        minSecondsPerCall: 0,
+        outputTokenPerWord: 0,
+        secondsPerWord: 5e-4,
+        wordsPerCall: 1e5
+      };
+    case "index-embedding-source":
+    case "index-embedding-summary":
+      return {
+        cacheableInputTokenPerWord: 0,
+        inputTokenPerWord: 0,
+        maxSecondsPerCall: 10,
+        minSecondsPerCall: 1,
+        outputTokenPerWord: 0,
+        secondsPerWord: 2e-3,
+        wordsPerCall: 1e4
+      };
+    case "knowledge-graph":
+      return {
+        cacheableInputTokenPerWord: 60,
+        inputTokenPerWord: 80,
+        maxSecondsPerCall: 35,
+        minSecondsPerCall: 15,
+        outputTokenPerWord: 25,
+        secondsPerWord: 0.02,
+        wordsPerCall: 35
+      };
+    case "reading-graph":
+      return {
+        cacheableInputTokenPerWord: 20,
+        inputTokenPerWord: 25,
+        maxSecondsPerCall: 45,
+        minSecondsPerCall: 15,
+        outputTokenPerWord: 4,
+        secondsPerWord: 0.01,
+        wordsPerCall: 160
+      };
+    case "reading-summary":
+      return {
+        cacheableInputTokenPerWord: 45,
+        inputTokenPerWord: 55,
+        maxSecondsPerCall: 25,
+        minSecondsPerCall: 10,
+        outputTokenPerWord: 4,
+        secondsPerWord: 0.01,
+        wordsPerCall: 110
+      };
+  }
+}
+
 // src/worker.ts
 var import_worker = require("wiki-graph-core/worker");
+var import_wiki_graph_core13 = require("wiki-graph-core");
 var import_worker2 = require("wiki-graph-core/worker");
 async function runBuildJobWorker(options) {
   installNodeWikiGraphPlatform();
@@ -3530,7 +3508,7 @@ async function runWikiGraphQueueWorker(options = {}) {
   await runBuildJobWorker({
     concurrency: config.concurrent?.job ?? DEFAULT_GENERATION_JOB_CONCURRENCY,
     executeJob: async (job, reporter, context) => {
-      await (0, import_wiki_graph_core11.withLoggingContext)(
+      await (0, import_wiki_graph_core14.withLoggingContext)(
         { logDirectory: job.log, operation: "build-job" },
         async () => await executeBuildJob(job, reporter, context)
       );
@@ -3553,7 +3531,7 @@ async function executeBuildJob(job, reporter, context) {
       let stage = await readChapterStage(job);
       if (stage === "sourced") {
         await executeStep(job, "reading-graph", execution, reporter, context, {
-          ...execution.extractionPrompt === void 0 ? {} : { extractionPrompt: execution.extractionPrompt }
+          ...execution.extractionPrompt === void 0 ? {} : { prompt: execution.extractionPrompt }
         });
         stage = await readChapterStage(job);
       }
@@ -3586,8 +3564,8 @@ async function executeBuildJob(job, reporter, context) {
       }
     }
     await executeStep(job, job.target, execution, reporter, context, {
-      ...job.target === "reading-graph" ? { extractionPrompt: execution.extractionPrompt } : {},
-      ...job.target === "knowledge-graph" ? { policyPrompt: execution.knowledgeGraphPrompt } : {}
+      ...job.target === "reading-graph" ? { prompt: execution.extractionPrompt } : {},
+      ...job.target === "knowledge-graph" ? { prompt: execution.knowledgeGraphPrompt } : {}
     });
   } finally {
     await execution.close();
@@ -3602,9 +3580,9 @@ async function executeStep(job, kind, execution, reporter, context, inputOptions
   const stepWorkspace = await resetStepWorkspace(job.workspace, kind);
   const inputFile = await stepWorkspace.createFile("input.jsonl");
   const outputWorkspace = await stepWorkspace.createDirectory("output");
-  const revision = await new import_wiki_graph_core11.WikiGraphArchiveFile(job.archive).readDocument(
+  const revision = await new import_wiki_graph_core14.WikiGraphArchiveFile(job.archive).readDocument(
     async (document) => {
-      await (0, import_wiki_graph_core11.getChapterDetails)(document, job.chapterId);
+      await (0, import_wiki_graph_core14.getChapterDetails)(document, job.chapterId);
       return await (0, import_worker3.writeChapterJobInputFile)(
         document,
         job.chapterId,
@@ -3614,7 +3592,7 @@ async function executeStep(job, kind, execution, reporter, context, inputOptions
       );
     }
   );
-  await (0, import_wiki_graph_core11.recordBuildJobInputRevision)({
+  await (0, import_wiki_graph_core14.recordBuildJobInputRevision)({
     currentRevision: revision,
     jobId: job.jobId,
     ownerId: requireRunningJobOwnerId(job)
@@ -3644,16 +3622,23 @@ async function executeStep(job, kind, execution, reporter, context, inputOptions
     total: 1,
     unit: "item"
   });
-  await new import_wiki_graph_core11.WikiGraphArchiveFile(job.archive).write(async (document) => {
-    assertJobStillRunning(await (0, import_wiki_graph_core11.getBuildJob)(job.jobId));
-    await (0, import_worker3.applyChapterJobArtifactFile)(
-      document,
-      job.chapterId,
-      kind,
-      revision,
-      result.artifactFile
-    );
-  });
+  const target = await resolveWikiGraphArchiveTarget(job.archive);
+  const resolvedLocation = await resolveWikiGraphArchiveLocation(target);
+  const location = target.kind === "standalone" ? { ...resolvedLocation, archiveFile: job.archive } : resolvedLocation;
+  await writeWikiGraphArchiveLocation(
+    location,
+    async (document) => {
+      assertJobStillRunning(await (0, import_wiki_graph_core14.getBuildJob)(job.jobId));
+      await (0, import_worker3.applyChapterJobArtifactFile)(
+        document,
+        job.chapterId,
+        kind,
+        revision,
+        result.artifactFile
+      );
+    },
+    { invalidateContinuationCursors: true }
+  );
   await reporter.updatePhase({
     done: 1,
     phase: "committing",
@@ -3661,7 +3646,7 @@ async function executeStep(job, kind, execution, reporter, context, inputOptions
     unit: "item"
   });
   await reporter.stepCompleted(kind);
-  assertJobStillRunning(await (0, import_wiki_graph_core11.getBuildJob)(job.jobId));
+  assertJobStillRunning(await (0, import_wiki_graph_core14.getBuildJob)(job.jobId));
 }
 async function openJobExecutor(job, config, signal, reporter) {
   const generation = !job.target.startsWith("index-");
@@ -3680,18 +3665,22 @@ async function openJobExecutor(job, config, signal, reporter) {
   const request = llm === void 0 ? void 0 : async (messages, index, maxRetries) => await llm.request(messages, {
     retryIndex: index,
     retryMax: maxRetries,
-    scope: import_wiki_graph_core11.WikiGraphScope.ReaderExtraction,
+    scope: import_wiki_graph_core14.WikiGraphScope.ReaderExtraction,
     signal
   });
   if (request !== void 0 && llm !== void 0) {
     request.lazy = async (operation) => await llm.request(async () => await operation(request));
   }
-  const wikimediaResolver = job.target !== "knowledge-graph" ? void 0 : await (0, import_wiki_graph_core11.openWikimediaResolver)(
+  const wikimediaResolver = job.target !== "knowledge-graph" ? void 0 : await (0, import_wiki_graph_core14.openWikimediaResolver)(
     config.wikimedia === void 0 ? {
       kind: "local",
       llmRequest: requireValue(
         request,
         "Local Wikimedia resolution requires an LLM."
+      ),
+      llmModelId: requireValue(
+        stageConfig?.llm?.model,
+        "Local Wikimedia resolution requires an LLM model."
       )
     } : {
       endpoint: config.wikimedia.endpoint,
@@ -3715,9 +3704,9 @@ async function openJobExecutor(job, config, signal, reporter) {
         }
       }
     }),
-    ...promptSource === void 0 ? {} : { extractionPrompt: (0, import_wiki_graph_core8.resolveExtractionPrompt)(promptSource) },
+    ...promptSource === void 0 ? {} : { extractionPrompt: (0, import_wiki_graph_core10.resolveExtractionPrompt)(promptSource) },
     ...promptSource === void 0 ? {} : {
-      knowledgeGraphPrompt: (0, import_wiki_graph_core8.resolveKnowledgeGraphRecallPrompt)(promptSource)
+      knowledgeGraphPrompt: (0, import_wiki_graph_core10.resolveKnowledgeGraphRecallPrompt)(promptSource)
     }
   };
 }
@@ -3729,12 +3718,12 @@ async function resetStepWorkspace(workspace, kind) {
   return await workspace.createDirectory(name);
 }
 async function readChapterStage(job) {
-  return await new import_wiki_graph_core11.WikiGraphArchiveFile(job.archive).readDocument(
-    async (document) => (await (0, import_wiki_graph_core11.getChapterDetails)(document, job.chapterId)).stage
+  return await new import_wiki_graph_core14.WikiGraphArchiveFile(job.archive).readDocument(
+    async (document) => (await (0, import_wiki_graph_core14.getChapterDetails)(document, job.chapterId)).stage
   );
 }
 async function assertCurrentFtsArtifact(job) {
-  await new import_wiki_graph_core11.WikiGraphArchiveFile(job.archive).readDocument(async (document) => {
+  await new import_wiki_graph_core14.WikiGraphArchiveFile(job.archive).readDocument(async (document) => {
     const revision = await document.serials.getRevision(job.chapterId);
     const artifact = await document.indexArtifacts.get(job.chapterId, "fts");
     if (artifact?.sourceRevision !== revision) {
@@ -3833,27 +3822,27 @@ function normalizeOptionalPath(path) {
 }
 
 // src/jobs.ts
-var import_wiki_graph_core12 = require("wiki-graph-core");
+var import_wiki_graph_core15 = require("wiki-graph-core");
 var TERMINAL_STATES = /* @__PURE__ */ new Set(["canceled", "failed", "succeeded"]);
 var TERMINAL_EVENT_GRACE_READS = 3;
 var CORE_BUILD_JOB_BACKEND = {
-  add: async (options) => await (0, import_wiki_graph_core12.addBuildJob)(options),
-  boost: async (jobId) => await (0, import_wiki_graph_core12.boostBuildJob)(jobId),
-  cancel: async (jobId) => await (0, import_wiki_graph_core12.cancelBuildJob)(jobId),
-  get: async (jobId) => await (0, import_wiki_graph_core12.getBuildJob)(jobId),
-  list: async (options) => await (0, import_wiki_graph_core12.listBuildJobs)(options),
-  pause: async (jobId) => await (0, import_wiki_graph_core12.pauseBuildJob)(jobId),
+  add: async (options) => await (0, import_wiki_graph_core15.addBuildJob)(options),
+  boost: async (jobId) => await (0, import_wiki_graph_core15.boostBuildJob)(jobId),
+  cancel: async (jobId) => await (0, import_wiki_graph_core15.cancelBuildJob)(jobId),
+  get: async (jobId) => await (0, import_wiki_graph_core15.getBuildJob)(jobId),
+  list: async (options) => await (0, import_wiki_graph_core15.listBuildJobs)(options),
+  pause: async (jobId) => await (0, import_wiki_graph_core15.pauseBuildJob)(jobId),
   readEventChunk: async (job, cursor) => await readIncrementalBuildJobEvents(job, cursor),
-  readEvents: async (job) => await (0, import_wiki_graph_core12.readBuildJobEvents)(job),
-  resume: async (jobId) => await (0, import_wiki_graph_core12.resumeBuildJob)(jobId),
-  setTarget: async (jobId, target) => await (0, import_wiki_graph_core12.updateBuildJobTarget)(jobId, target)
+  readEvents: async (job) => await (0, import_wiki_graph_core15.readBuildJobEvents)(job),
+  resume: async (jobId) => await (0, import_wiki_graph_core15.resumeBuildJob)(jobId),
+  setTarget: async (jobId, target) => await (0, import_wiki_graph_core15.updateBuildJobTarget)(jobId, target)
 };
 async function readIncrementalBuildJobEvents(job, cursor) {
   let reader;
   try {
     reader = await job.events.openReader();
   } catch {
-    return { cursor, events: await (0, import_wiki_graph_core12.readBuildJobEvents)(job) };
+    return { cursor, events: await (0, import_wiki_graph_core15.readBuildJobEvents)(job) };
   }
   try {
     const offset = cursor <= reader.size ? cursor : 0;
@@ -3877,45 +3866,51 @@ var WikiGraphJobManager = class {
     this.#backend = backend;
   }
   async create(options) {
-    const job = await this.#runtime.run(
-      async () => await this.#backend.add({
-        ...options,
-        archive: typeof options.archive === "string" ? new NodeFile(resolveWikiGraphRuntimePath(options.archive)) : options.archive
-      })
-    );
-    return this.#createHandle(job);
+    const resolved = await this.#runtime.run(async () => {
+      const location = await resolveWikiGraphArchiveLocation(options.archive);
+      return {
+        job: await this.#backend.add({
+          ...options,
+          archive: location.archiveFile
+        }),
+        target: location.target
+      };
+    });
+    return await this.#createHandle(resolved.job, resolved.target);
   }
   async clean() {
-    return await this.#runtime.run(async () => await (0, import_wiki_graph_core12.cleanBuildJobs)());
+    return await this.#runtime.run(async () => await (0, import_wiki_graph_core15.cleanBuildJobs)());
   }
   async get(jobId) {
-    return this.#createHandle(
-      await this.#runtime.run(async () => await this.#backend.get(jobId))
+    return await this.#runtime.run(
+      async () => await this.#createHandle(await this.#backend.get(jobId))
     );
   }
   async resolveId(reference) {
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core12.resolveBuildJobId)(reference)
+      async () => await (0, import_wiki_graph_core15.resolveBuildJobId)(reference)
     );
   }
   async list(options = {}) {
-    const jobs = await this.#runtime.run(async () => {
+    return await this.#runtime.run(async () => {
       const normalized = {
         ...options.activeOnly === void 0 ? {} : { activeOnly: options.activeOnly },
         ...options.all === void 0 ? {} : { all: options.all },
         ...options.archive === void 0 ? {} : {
-          archive: typeof options.archive === "string" ? new NodeFile(resolveWikiGraphRuntimePath(options.archive)) : options.archive
+          archive: (await resolveWikiGraphArchiveLocation(options.archive)).archiveFile
         }
       };
-      return await this.#backend.list(normalized);
+      const jobs = await this.#backend.list(normalized);
+      return await Promise.all(
+        jobs.map(async (job) => await this.#createHandle(job))
+      );
     });
-    return jobs.map((job) => this.#createHandle(job));
   }
   async resolveChapters(jobs) {
     return await this.#runtime.run(async () => {
       const jobsByArchive = /* @__PURE__ */ new Map();
       for (const job of jobs) {
-        const archivePath = getBuildJobArchivePath(job);
+        const archivePath = getJobArchiveLocator(job);
         const grouped = jobsByArchive.get(archivePath) ?? [];
         grouped.push(job);
         jobsByArchive.set(archivePath, grouped);
@@ -3923,9 +3918,12 @@ var WikiGraphJobManager = class {
       const entries = (await Promise.all(
         [...jobsByArchive].map(async ([archivePath, archiveJobs]) => {
           try {
-            const chapters = await new import_wiki_graph_core12.WikiGraphArchiveFile(
-              new NodeFile(archivePath)
-            ).readDocument(async (document) => await (0, import_wiki_graph_core12.listChapters)(document));
+            const location = await resolveWikiGraphArchiveLocation(
+              archiveJobs[0].archive
+            );
+            const chapters = await new import_wiki_graph_core15.WikiGraphArchiveFile(
+              location.archiveFile
+            ).readDocument(async (document) => await (0, import_wiki_graph_core15.listChapters)(document));
             const chaptersById = new Map(
               chapters.map((chapter) => [chapter.chapterId, chapter])
             );
@@ -3935,7 +3933,7 @@ var WikiGraphJobManager = class {
                 [
                   job.jobId,
                   {
-                    locatedUri: (0, import_wiki_graph_core12.formatLocatedChapterUri)(
+                    locatedUri: (0, import_wiki_graph_core15.formatLocatedChapterUri)(
                       archivePath,
                       chapter.path
                     ),
@@ -3959,62 +3957,78 @@ var WikiGraphJobManager = class {
   async enqueue(options) {
     return await this.#runtime.run(async () => {
       const location = await resolveWikiGraphArchiveLocation(options.archive);
-      const target = options.target ?? "reading-summary";
-      await validateQueueTargetConfig(target, options.llmJSON);
-      const selectedExplicitly = options.chapterId !== void 0 || options.chapterIds !== void 0 || options.chapterPath !== void 0 || options.depth !== void 0;
-      const candidates = await new import_wiki_graph_core12.WikiGraphArchiveFile(
-        location.archiveFile
-      ).readDocument(async (document) => {
-        const chapters = await (0, import_wiki_graph_core12.listChapters)(document);
-        const selected = await selectQueueChapters(document, chapters, options);
-        const checked = await Promise.all(
-          selected.map(async (chapter) => ({
-            chapter,
-            reason: await readQueueReadinessReason(document, chapter, target)
-          }))
-        );
-        return checked;
-      });
-      const created = [];
-      const skipped = [];
-      for (const candidate of candidates) {
-        if (candidate.reason !== void 0) {
-          if (selectedExplicitly && candidates.length === 1) {
-            throw new Error(
-              formatQueueReadinessError(
-                candidate.chapter,
-                target,
-                candidate.reason
-              )
+      return await (0, import_wiki_graph_core15.withArchiveBuildJobCreationLock)(
+        location.archiveFile,
+        async () => {
+          const target = options.target ?? "reading-summary";
+          await validateQueueTargetConfig(target, options.llmJSON);
+          const selectedExplicitly = options.chapterId !== void 0 || options.chapterIds !== void 0 || options.chapterPath !== void 0 || options.depth !== void 0;
+          const candidates = await new import_wiki_graph_core15.WikiGraphArchiveFile(
+            location.archiveFile
+          ).readDocument(async (document) => {
+            const chapters = await (0, import_wiki_graph_core15.listChapters)(document);
+            const selected = await selectQueueChapters(
+              document,
+              chapters,
+              options
             );
-          }
-          skipped.push({
-            chapter: candidate.chapter,
-            reason: candidate.reason
-          });
-          continue;
-        }
-        try {
-          created.push({
-            chapter: candidate.chapter,
-            job: await this.create({
-              archive: location.archiveFile,
-              boost: options.boost ?? false,
-              chapterId: candidate.chapter.chapterId,
-              ...options.llmJSON === void 0 ? {} : { llmJSON: options.llmJSON },
-              ...options.prompt === void 0 ? {} : { prompt: options.prompt },
-              target
-            })
-          });
-        } catch (error) {
-          if (selectedExplicitly && candidates.length === 1) throw error;
-          skipped.push({
-            chapter: candidate.chapter,
-            reason: error instanceof Error ? error.message : String(error)
+            const checked = await Promise.all(
+              selected.map(async (chapter) => ({
+                chapter,
+                reason: await readQueueReadinessReason(
+                  document,
+                  chapter,
+                  target
+                )
+              }))
+            );
+            return checked;
           });
+          const created = [];
+          const skipped = [];
+          for (const candidate of candidates) {
+            if (candidate.reason !== void 0) {
+              if (selectedExplicitly && candidates.length === 1) {
+                throw new Error(
+                  formatQueueReadinessError(
+                    candidate.chapter,
+                    target,
+                    candidate.reason
+                  )
+                );
+              }
+              skipped.push({
+                chapter: candidate.chapter,
+                reason: candidate.reason
+              });
+              continue;
+            }
+            try {
+              created.push({
+                chapter: candidate.chapter,
+                job: await this.#createHandle(
+                  await this.#backend.add({
+                    archive: location.archiveFile,
+                    boost: options.boost ?? false,
+                    chapterId: candidate.chapter.chapterId,
+                    ...options.llmJSON === void 0 ? {} : { llmJSON: options.llmJSON },
+                    ...options.prompt === void 0 ? {} : { prompt: options.prompt },
+                    target
+                  }),
+                  location.target
+                )
+              });
+            } catch (error) {
+              if (selectedExplicitly && candidates.length === 1) throw error;
+              skipped.push({
+                chapter: candidate.chapter,
+                reason: error instanceof Error ? error.message : String(error)
+              });
+            }
+          }
+          return { created, skipped };
         }
-      }
-      return { created, skipped };
+      );
     });
   }
   async planEnqueue(options) {
@@ -4023,10 +4037,10 @@ var WikiGraphJobManager = class {
       const target = options.target ?? "reading-summary";
       await validateQueueTargetConfig(target, options.llmJSON);
       const selectedExplicitly = options.chapterId !== void 0 || options.chapterIds !== void 0 || options.chapterPath !== void 0 || options.depth !== void 0;
-      const candidates = await new import_wiki_graph_core12.WikiGraphArchiveFile(
+      const candidates = await new import_wiki_graph_core15.WikiGraphArchiveFile(
         location.archiveFile
       ).readDocument(async (document) => {
-        const chapters = await (0, import_wiki_graph_core12.listChapters)(document);
+        const chapters = await (0, import_wiki_graph_core15.listChapters)(document);
         const selected = await selectQueueChapters(document, chapters, options);
         return await Promise.all(
           selected.map(async (chapter) => ({
@@ -4060,34 +4074,39 @@ var WikiGraphJobManager = class {
     this.#subscriptions.add(controller);
     return () => this.#subscriptions.delete(controller);
   }
-  #createHandle(snapshot) {
-    return new WikiGraphJob(this, this.#runtime, this.#backend, snapshot);
+  async #createHandle(snapshot, target) {
+    const legacy = snapshot;
+    const resolvedTarget = target ?? (snapshot.archive === void 0 ? archiveTargetFromLogicalLocator(legacy.archivePath ?? "unknown.wikg") : await resolveWikiGraphArchiveTarget(snapshot.archive));
+    return new WikiGraphJob(
+      this,
+      this.#runtime,
+      this.#backend,
+      snapshot,
+      cloneWikiGraphArchiveTarget(resolvedTarget)
+    );
   }
 };
-function getBuildJobArchivePath(job) {
-  const record = job;
-  if (record.archive !== void 0) {
-    return getNodeResourcePath(record.archive);
-  }
-  if (typeof record.archivePath === "string") return record.archivePath;
-  throw new TypeError("Build job is missing archive");
+function getJobArchiveLocator(job) {
+  return job.archive.kind === "library" ? job.archive.uri : job.archive.path;
 }
 var WikiGraphJob = class {
   #manager;
   #runtime;
   #backend;
+  #archiveTarget;
   #snapshot;
-  constructor(manager, runtime, backend, snapshot) {
+  constructor(manager, runtime, backend, snapshot, archiveTarget) {
     this.#manager = manager;
     this.#runtime = runtime;
     this.#backend = backend;
     this.#snapshot = snapshot;
+    this.#archiveTarget = archiveTarget;
   }
   get id() {
     return this.#snapshot.jobId;
   }
   get snapshot() {
-    return this.#snapshot;
+    return toPublicJobSnapshot(this.#snapshot, this.#archiveTarget);
   }
   async status() {
     return await this.#update(async () => await this.#backend.get(this.id));
@@ -4114,7 +4133,8 @@ var WikiGraphJob = class {
     let cursor = 0;
     let job = this.#snapshot;
     if (options.from === "now") {
-      job = await this.status();
+      await this.status();
+      job = this.#snapshot;
       const chunk = await this.#readEventChunkSafely(job, cursor);
       const events = chunk.events;
       cursor = chunk.cursor;
@@ -4134,7 +4154,8 @@ var WikiGraphJob = class {
         yield event;
       }
       if (sawTerminalEvent) return;
-      job = await this.status();
+      await this.status();
+      job = this.#snapshot;
       if (isTerminalState(job.state)) {
         terminalReadsWithoutEvent += 1;
         if (terminalReadsWithoutEvent >= TERMINAL_EVENT_GRACE_READS) return;
@@ -4171,7 +4192,7 @@ var WikiGraphJob = class {
   }
   async #update(operation) {
     this.#snapshot = await this.#runtime.run(operation);
-    return this.#snapshot;
+    return this.snapshot;
   }
   async #readEventChunk(job, cursor) {
     return await this.#runtime.run(async () => {
@@ -4190,6 +4211,54 @@ var WikiGraphJob = class {
     }
   }
 };
+function toPublicJobSnapshot(job, archive) {
+  const legacy = job;
+  return {
+    archive: cloneWikiGraphArchiveTarget(archive),
+    archiveKey: archive.kind === "library" ? archive.uri : job.archiveKey,
+    ...getJobResourcePath(job.cache, legacy.cachePath) === void 0 ? {} : { cachePath: getJobResourcePath(job.cache, legacy.cachePath) },
+    chapterId: job.chapterId,
+    createdAt: job.createdAt,
+    ...job.currentStep === void 0 ? {} : { currentStep: job.currentStep },
+    ...job.errorJSON === void 0 ? {} : { errorJSON: job.errorJSON },
+    ...getJobResourcePath(job.events, legacy.eventsPath) === void 0 ? {} : { eventsPath: getJobResourcePath(job.events, legacy.eventsPath) },
+    ...job.finishedAt === void 0 ? {} : { finishedAt: job.finishedAt },
+    jobId: job.jobId,
+    ...job.inputRevision === void 0 ? {} : { inputRevision: job.inputRevision },
+    ...getJobResourcePath(job.log, legacy.logPath) === void 0 ? {} : { logPath: getJobResourcePath(job.log, legacy.logPath) },
+    ...job.llmJSON === void 0 ? {} : { llmJSON: job.llmJSON },
+    ...job.ownerId === void 0 ? {} : { ownerId: job.ownerId },
+    ...job.prompt === void 0 ? {} : { prompt: job.prompt },
+    queueRank: job.queueRank,
+    ...job.readingSummaryStartedAt === void 0 ? {} : { readingSummaryStartedAt: job.readingSummaryStartedAt },
+    state: job.state,
+    target: job.target,
+    updatedAt: job.updatedAt,
+    ...getJobResourcePath(job.workspace, legacy.workspacePath) === void 0 ? {} : {
+      workspacePath: getJobResourcePath(
+        job.workspace,
+        legacy.workspacePath
+      )
+    }
+  };
+}
+function cloneWikiGraphArchiveTarget(target) {
+  return target.kind === "library" ? Object.freeze({ kind: "library", uri: target.uri }) : Object.freeze({
+    kind: "standalone",
+    path: target.path,
+    ...target.objectUri === void 0 ? {} : { objectUri: target.objectUri }
+  });
+}
+function getJobResourcePath(resource, legacy) {
+  if (resource === void 0) return legacy;
+  try {
+    return getNodeResourcePath(resource);
+  } catch {
+    const identity = resource.identity;
+    if (typeof identity === "string") return identity;
+    throw new TypeError("Expected a Node File or Directory resource");
+  }
+}
 async function selectQueueChapters(document, chapters, options) {
   const ids = options.chapterIds ?? (options.chapterId === void 0 ? void 0 : [options.chapterId]);
   if (ids !== void 0) {
@@ -4200,7 +4269,7 @@ async function selectQueueChapters(document, chapters, options) {
   if (options.chapterPath === void 0) {
     return options.depth === void 0 ? chapters : chapters.filter((chapter) => chapter.depth <= options.depth);
   }
-  const rootId = await (0, import_wiki_graph_core12.resolveChapterPathReadonly)(
+  const rootId = await (0, import_wiki_graph_core15.resolveChapterPathReadonly)(
     document,
     options.chapterPath
   );
@@ -4265,14 +4334,14 @@ function formatQueueReadinessError(chapter, target, reason) {
 }
 async function wait(milliseconds, signal) {
   if (signal?.aborted === true) return;
-  await new Promise((resolve3) => {
+  await new Promise((resolve4) => {
     let settled = false;
     const complete = () => {
       if (settled) return;
       settled = true;
       clearTimeout(timeout);
       signal?.removeEventListener("abort", complete);
-      resolve3();
+      resolve4();
     };
     const timeout = setTimeout(complete, milliseconds);
     signal?.addEventListener("abort", complete, { once: true });
@@ -4294,8 +4363,8 @@ function forwardAbort(source, target) {
 }
 
 // src/libraries.ts
-var import_wiki_graph_core13 = require("wiki-graph-core");
-var import_promises4 = require("fs/promises");
+var import_wiki_graph_core16 = require("wiki-graph-core");
+var import_promises5 = require("fs/promises");
 var WikiGraphLibraryManager = class {
   #runtime;
   constructor(runtime) {
@@ -4304,80 +4373,109 @@ var WikiGraphLibraryManager = class {
   async create(folder) {
     const record = await this.#runtime.run(async () => {
       const path = resolveWikiGraphRuntimePath(folder);
-      await (0, import_promises4.mkdir)(path);
-      return await (0, import_wiki_graph_core13.createWikiGraphLibrary)({ folder: new NodeDirectory(path) });
+      await (0, import_promises5.mkdir)(path);
+      return await (0, import_wiki_graph_core16.createWikiGraphLibrary)({ folder: new NodeDirectory(path) });
     });
     return new WikiGraphLibrary(this.#runtime, record);
   }
-  async get(uri = (0, import_wiki_graph_core13.formatWikiGraphLibraryUri)()) {
+  async get(uri = (0, import_wiki_graph_core16.formatWikiGraphLibraryUri)()) {
     const target = requireLibraryTarget(uri);
     const record = await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.resolveWikiGraphLibrary)(target)
+      async () => await (0, import_wiki_graph_core16.resolveWikiGraphLibrary)(target)
     );
     return new WikiGraphLibrary(this.#runtime, record);
   }
   async addArchive(options) {
-    return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.addWikiGraphLibraryArchive)({
-        inputFile: new NodeFile(
-          resolveWikiGraphRuntimePath(options.inputPath)
-        ),
-        target: requireLibraryTarget(options.target),
-        ...options.to === void 0 ? {} : { to: options.to }
-      })
+    return toArchiveSnapshot(
+      await this.#runtime.run(
+        async () => await (0, import_wiki_graph_core16.addWikiGraphLibraryArchive)({
+          inputFile: new NodeFile(
+            await assertStandaloneWikiGraphArchivePath(options.inputPath)
+          ),
+          target: requireLibraryTarget(options.target),
+          ...options.to === void 0 ? {} : { to: options.to }
+        })
+      )
     );
   }
   async assertCurrent(target) {
     await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.assertWikiGraphLibrarySchemaCurrent)(requireLibraryTarget(target))
+      async () => await (0, import_wiki_graph_core16.assertWikiGraphLibrarySchemaCurrent)(requireLibraryTarget(target))
     );
   }
   async rebind(target, folder) {
-    return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.rebindWikiGraphLibrary)({
-        folder: new NodeDirectory(resolveWikiGraphRuntimePath(folder)),
-        target: requireLibraryTarget(target)
-      })
+    return toScanSnapshot(
+      await this.#runtime.run(
+        async () => await (0, import_wiki_graph_core16.rebindWikiGraphLibrary)({
+          folder: new NodeDirectory(resolveWikiGraphRuntimePath(folder)),
+          target: requireLibraryTarget(target)
+        })
+      )
     );
   }
   async remove(target) {
-    return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.removeWikiGraphLibrary)(requireLibraryTarget(target))
+    return toLibrarySnapshot(
+      await this.#runtime.run(
+        async () => await (0, import_wiki_graph_core16.removeWikiGraphLibrary)(requireLibraryTarget(target))
+      )
     );
   }
   async scan(target) {
-    return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.scanWikiGraphLibrary)(requireLibraryTarget(target))
+    return toScanSnapshot(
+      await this.#runtime.run(
+        async () => await (0, import_wiki_graph_core16.scanWikiGraphLibrary)(requireLibraryTarget(target))
+      )
     );
   }
   async getArchive(target) {
-    return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.getWikiGraphLibraryArchive)(requireLibraryTarget(target))
+    return toArchiveSnapshot(
+      await this.#runtime.run(
+        async () => await (0, import_wiki_graph_core16.getWikiGraphLibraryArchive)(requireLibraryTarget(target))
+      )
     );
   }
   async moveArchive(options) {
-    return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.moveWikiGraphLibraryArchive)({
-        target: requireLibraryTarget(options.target),
-        to: options.to
-      })
+    return toArchiveSnapshot(
+      await this.#runtime.run(
+        async () => await (0, import_wiki_graph_core16.moveWikiGraphLibraryArchive)({
+          target: requireLibraryTarget(options.target),
+          to: options.to
+        })
+      )
     );
   }
   async removeArchive(target) {
-    return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.removeWikiGraphLibraryArchive)({
-        target: requireLibraryTarget(target)
+    return toArchiveSnapshot(
+      await this.#runtime.run(
+        async () => await (0, import_wiki_graph_core16.removeWikiGraphLibraryArchive)({
+          target: requireLibraryTarget(target)
+        })
+      )
+    );
+  }
+  async replaceArchive(options) {
+    return toArchiveSnapshot(
+      await this.#runtime.run(async () => {
+        const target = requireLibraryTarget(options.target);
+        const current = await (0, import_wiki_graph_core16.getWikiGraphLibraryArchive)(target);
+        return await (0, import_wiki_graph_core16.replaceWikiGraphLibraryArchive)({
+          additionalDerivedStateKeys: current.file === void 0 ? [] : [getNodeResourcePath(current.file)],
+          inputFile: new NodeFile(
+            await assertStandaloneWikiGraphArchivePath(options.inputPath)
+          ),
+          target
+        });
       })
     );
   }
   async indexState(target) {
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.readWikiGraphLibraryIndexState)(requireLibraryTarget(target))
+      async () => await (0, import_wiki_graph_core16.readWikiGraphLibraryIndexState)(requireLibraryTarget(target))
     );
   }
   async rebuildIndex(target, onProgress) {
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.rebuildWikiGraphLibraryIndex)(
+      async () => await (0, import_wiki_graph_core16.rebuildWikiGraphLibraryIndex)(
         requireLibraryTarget(target),
         onProgress
       )
@@ -4385,17 +4483,17 @@ var WikiGraphLibraryManager = class {
   }
   async cleanIndex(target) {
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.cleanWikiGraphLibraryIndex)(requireLibraryTarget(target))
+      async () => await (0, import_wiki_graph_core16.cleanWikiGraphLibraryIndex)(requireLibraryTarget(target))
     );
   }
   async getMetadata(target) {
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.getWikiGraphLibraryMetadata)(requireLibraryTarget(target))
+      async () => await (0, import_wiki_graph_core16.getWikiGraphLibraryMetadata)(requireLibraryTarget(target))
     );
   }
   async replaceMetadata(target, value) {
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.replaceWikiGraphLibraryMetadata)(
+      async () => await (0, import_wiki_graph_core16.replaceWikiGraphLibraryMetadata)(
         requireLibraryTarget(target),
         value
       )
@@ -4403,7 +4501,7 @@ var WikiGraphLibraryManager = class {
   }
   async putMetadata(target, key, value) {
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.putWikiGraphLibraryMetadata)(
+      async () => await (0, import_wiki_graph_core16.putWikiGraphLibraryMetadata)(
         requireLibraryTarget(target),
         key,
         value
@@ -4412,7 +4510,7 @@ var WikiGraphLibraryManager = class {
   }
   async deleteMetadata(target, key) {
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.deleteWikiGraphLibraryMetadataKey)(
+      async () => await (0, import_wiki_graph_core16.deleteWikiGraphLibraryMetadataKey)(
         requireLibraryTarget(target),
         key
       )
@@ -4420,13 +4518,13 @@ var WikiGraphLibraryManager = class {
   }
   async clearMetadata(target) {
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.clearWikiGraphLibraryMetadata)(requireLibraryTarget(target))
+      async () => await (0, import_wiki_graph_core16.clearWikiGraphLibraryMetadata)(requireLibraryTarget(target))
     );
   }
   async search(target, query, options = {}) {
     return await this.#runtime.run(async () => {
       const embeddingProvider = await createConfiguredEmbeddingProvider();
-      return await (0, import_wiki_graph_core13.findWikiGraphLibraryObjects)(
+      return await (0, import_wiki_graph_core16.findWikiGraphLibraryObjects)(
         requireLibraryTarget(target),
         query,
         {
@@ -4439,7 +4537,7 @@ var WikiGraphLibraryManager = class {
   async searchArchiveMembers(target, query, options = {}) {
     return await this.#runtime.run(async () => {
       const embeddingProvider = await createConfiguredEmbeddingProvider();
-      return await (0, import_wiki_graph_core13.findWikiGraphLibraryArchiveMembers)(
+      return await (0, import_wiki_graph_core16.findWikiGraphLibraryArchiveMembers)(
         requireLibraryTarget(target),
         query,
         {
@@ -4451,7 +4549,7 @@ var WikiGraphLibraryManager = class {
   }
   async objects(target, options = {}) {
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.listWikiGraphLibraryObjects)(
+      async () => await (0, import_wiki_graph_core16.listWikiGraphLibraryObjects)(
         requireLibraryTarget(target),
         options
       )
@@ -4459,7 +4557,7 @@ var WikiGraphLibraryManager = class {
   }
   async archiveMembers(target, options = {}) {
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.listWikiGraphLibraryArchiveMembers)(
+      async () => await (0, import_wiki_graph_core16.listWikiGraphLibraryArchiveMembers)(
         requireLibraryTarget(target),
         options
       )
@@ -4469,17 +4567,18 @@ var WikiGraphLibraryManager = class {
     return await this.#runtime.run(
       async () => await withConfiguredWikimediaResolver(
         objectUri,
-        async (wikimediaOptions) => await (0, import_wiki_graph_core13.readWikiGraphLibraryPage)(
+        async (wikimediaOptions) => await (0, import_wiki_graph_core16.readWikiGraphLibraryPage)(
           requireLibraryTarget(target),
           objectUri,
           { ...options, ...wikimediaOptions }
         )
-      )
+      ),
+      options.signal
     );
   }
   async related(target, objectUri, options = {}) {
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.listRelatedWikiGraphLibraryObjects)(
+      async () => await (0, import_wiki_graph_core16.listRelatedWikiGraphLibraryObjects)(
         requireLibraryTarget(target),
         objectUri,
         options
@@ -4488,7 +4587,7 @@ var WikiGraphLibraryManager = class {
   }
   async evidence(target, objectUri, options = {}) {
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.listWikiGraphLibraryEvidence)(
+      async () => await (0, import_wiki_graph_core16.listWikiGraphLibraryEvidence)(
         requireLibraryTarget(target),
         objectUri,
         options
@@ -4497,7 +4596,7 @@ var WikiGraphLibraryManager = class {
   }
   async pack(target, objectUri, budget = 5e3) {
     return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.packWikiGraphLibraryContext)(
+      async () => await (0, import_wiki_graph_core16.packWikiGraphLibraryContext)(
         requireLibraryTarget(target),
         objectUri,
         budget
@@ -4506,7 +4605,7 @@ var WikiGraphLibraryManager = class {
   }
   async list() {
     const records = await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.listWikiGraphLibraries)()
+      async () => await (0, import_wiki_graph_core16.listWikiGraphLibraries)()
     );
     return records.map((record) => new WikiGraphLibrary(this.#runtime, record));
   }
@@ -4519,35 +4618,57 @@ var WikiGraphLibrary = class {
     this.#record = record;
   }
   get snapshot() {
-    return this.#record;
+    return toLibrarySnapshot(this.#record);
   }
   get uri() {
-    return (0, import_wiki_graph_core13.formatWikiGraphLibraryUri)(
+    return (0, import_wiki_graph_core16.formatWikiGraphLibraryUri)(
       this.#record.isDefault ? void 0 : this.#record.publicId
     );
   }
   async archives() {
     const target = requireLibraryTarget(this.uri);
-    return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.listWikiGraphLibraryArchives)(target)
-    );
+    return (await this.#runtime.run(
+      async () => await (0, import_wiki_graph_core16.listWikiGraphLibraryArchives)(target)
+    )).map(toArchiveSnapshot);
   }
   async scan() {
     const target = requireLibraryTarget(this.uri);
-    return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.scanWikiGraphLibrary)(target)
+    return toScanSnapshot(
+      await this.#runtime.run(async () => await (0, import_wiki_graph_core16.scanWikiGraphLibrary)(target))
     );
   }
   async remove() {
     const target = requireLibraryTarget(this.uri);
-    return await this.#runtime.run(
-      async () => await (0, import_wiki_graph_core13.removeWikiGraphLibrary)(target)
+    return toLibrarySnapshot(
+      await this.#runtime.run(async () => await (0, import_wiki_graph_core16.removeWikiGraphLibrary)(target))
     );
   }
 };
+function toLibrarySnapshot(record) {
+  const compatible = record;
+  return {
+    id: record.id,
+    publicId: record.publicId,
+    uri: record.uri,
+    folderPath: compatible.folderPath ?? (record.folder === void 0 ? "" : getNodeResourcePath(record.folder)),
+    isDefault: record.isDefault,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt
+  };
+}
+function toArchiveSnapshot(record) {
+  const { file: _file, ...snapshot } = record;
+  return snapshot;
+}
+function toScanSnapshot(result) {
+  return {
+    ...result.library === void 0 ? {} : { library: toLibrarySnapshot(result.library) },
+    archives: result.archives.map(toArchiveSnapshot)
+  };
+}
 function requireLibraryTarget(value) {
   if (typeof value !== "string") return value;
-  const target = (0, import_wiki_graph_core13.parseWikiGraphLibraryUri)(value);
+  const target = (0, import_wiki_graph_core16.parseWikiGraphLibraryUri)(value);
   if (target === void 0) {
     throw new TypeError(`Invalid Wiki Graph library URI: ${value}`);
   }
@@ -4555,8 +4676,8 @@ function requireLibraryTarget(value) {
 }
 
 // src/maintenance.ts
-var import_wiki_graph_core14 = require("wiki-graph-core");
-var import_path4 = require("path");
+var import_wiki_graph_core17 = require("wiki-graph-core");
+var import_path6 = require("path");
 var WikiGraphMaintenanceManager = class {
   #runtime;
   constructor(runtime) {
@@ -4566,22 +4687,22 @@ var WikiGraphMaintenanceManager = class {
     return await this.#runtime.run(
       async () => {
         if (target.kind === "home") {
-          return await (0, import_wiki_graph_core14.upgradeWikiGraphMaintenanceTarget)({ kind: "home" });
+          return await (0, import_wiki_graph_core17.upgradeWikiGraphMaintenanceTarget)({ kind: "home" });
         }
         if (target.kind === "library") {
-          const parsed = (0, import_wiki_graph_core14.parseWikiGraphLibraryUri)(target.uri);
+          const parsed = (0, import_wiki_graph_core17.parseWikiGraphLibraryUri)(target.uri);
           if (parsed === void 0 || parsed.kind === "archive") {
             throw new Error(
               `Invalid Wiki Graph library upgrade target: ${target.uri}`
             );
           }
-          return await (0, import_wiki_graph_core14.upgradeWikiGraphMaintenanceTarget)({
+          return await (0, import_wiki_graph_core17.upgradeWikiGraphMaintenanceTarget)({
             kind: "library",
             target: parsed
           });
         }
-        const path = resolveWikiGraphRuntimePath(target.path);
-        return await (0, import_wiki_graph_core14.upgradeWikiGraphMaintenanceTarget)({
+        const path = await assertStandaloneWikiGraphArchivePath(target.path);
+        return await (0, import_wiki_graph_core17.upgradeWikiGraphMaintenanceTarget)({
           file: new NodeFile(path),
           kind: "archive"
         });
@@ -4594,9 +4715,9 @@ var WikiGraphMaintenanceManager = class {
     return await this.#runtime.run(async () => {
       const resolvedInputPath = resolveWikiGraphRuntimePath(inputPath);
       const resolvedOutputPath = resolveWikiGraphRuntimePath(outputPath);
-      await (0, import_wiki_graph_core14.migrateLegacySdpubToWikg)(
+      await (0, import_wiki_graph_core17.migrateLegacySdpubToWikg)(
         new NodeFile(resolvedInputPath),
-        new NodeFile(resolvedOutputPath, (0, import_path4.basename)(resolvedOutputPath))
+        new NodeFile(resolvedOutputPath, (0, import_path6.basename)(resolvedOutputPath))
       );
       return {
         inputPath: resolvedInputPath,
@@ -4610,7 +4731,7 @@ function defaultWikgOutputPath(inputPath) {
 }
 
 // src/sdk.ts
-var import_wiki_graph_core15 = require("wiki-graph-core");
+var import_wiki_graph_core18 = require("wiki-graph-core");
 var WikiGraphSDK = class {
   #context;
   #homeReady;
@@ -4641,7 +4762,7 @@ var WikiGraphSDK = class {
     throwIfAborted(signal);
     const runWithContext = async () => await withWikiGraphSDKRuntimeContext(this.#context, async () => {
       if (options.skipHomeBootstrap !== true) {
-        this.#homeReady ??= (0, import_wiki_graph_core15.ensureWikiGraphHomeSchemaCurrent)().catch(
+        this.#homeReady ??= (0, import_wiki_graph_core18.ensureWikiGraphHomeSchemaCurrent)().catch(
           (error) => {
             this.#homeReady = void 0;
             throw error;
@@ -4671,7 +4792,7 @@ function createWikiGraphSDK(options = {}) {
 }
 
 // src/index.ts
-var import_wiki_graph_core16 = require("wiki-graph-core");
+var import_wiki_graph_core19 = require("wiki-graph-core");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DANGEROUS_RUNTIME_ENV_NAMES,
@@ -4687,6 +4808,7 @@ var import_wiki_graph_core16 = require("wiki-graph-core");
   WikiGraphArchiveExistsError,
   WikiGraphArchiveHandle,
   WikiGraphArchiveManager,
+  WikiGraphArchiveOwnershipError,
   WikiGraphConfigManager,
   WikiGraphContinuationManager,
   WikiGraphConversionManager,
@@ -4705,7 +4827,6 @@ var import_wiki_graph_core16 = require("wiki-graph-core");
   createNodeTemplateEnvironment,
   createNodeWikiGraphStorage,
   createStageLLM,
-  createWikiGraphArchiveInspectReport,
   createWikiGraphSDK,
   deleteLocalConfigValue,
   embedQueryText,
@@ -4723,6 +4844,7 @@ var import_wiki_graph_core16 = require("wiki-graph-core");
   getNodeResourcePath,
   getWikiGraphSDKRuntimeContext,
   getWikiGraphSDKStateDir,
+  inspectWikiGraphArchive,
   installNodeWikiGraphPlatform,
   isSourceLocatorScopeUri,
   isWikiGraphLibraryUri,
@@ -4749,7 +4871,6 @@ var import_wiki_graph_core16 = require("wiki-graph-core");
   resolveExtractionPrompt,
   resolveHostedProviderEndpoint,
   resolveKnowledgeGraphRecallPrompt,
-  resolveWikiGraphArchiveLocation,
   resolveWikispineConfig,
   runWikiGraphQueueWorker,
   validateLocalConfigSection,