wiki-graph 0.5.0 → 0.6.0

package/dist/index.js

@@ -12,6 +12,578 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// ../core/src/runtime/platform/files.ts
+var init_files = __esm({
+  "../core/src/runtime/platform/files.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/runtime/platform/index.ts
+async function withWikiGraphStorage(storage, operation) {
+  if (storage === void 0) {
+    return await operation();
+  }
+  return await storageContext.run(storage, operation);
+}
+var installedPlatform, DeferredHostAsyncContext, storageContext;
+var init_platform = __esm({
+  "../core/src/runtime/platform/index.ts"() {
+    "use strict";
+    init_files();
+    DeferredHostAsyncContext = class {
+      #impl;
+      #fallbackStore;
+      run(store, callback) {
+        const implementation = this.#implementation();
+        if (implementation !== void 0) {
+          return implementation.run(store, callback);
+        }
+        const previous = this.#fallbackStore;
+        this.#fallbackStore = store;
+        try {
+          return callback();
+        } finally {
+          this.#fallbackStore = previous;
+        }
+      }
+      enterWith(store) {
+        const implementation = this.#implementation();
+        if (implementation !== void 0) {
+          implementation.enterWith(store);
+        } else {
+          this.#fallbackStore = store;
+        }
+      }
+      getStore() {
+        return this.#implementation()?.getStore() ?? this.#fallbackStore;
+      }
+      #implementation() {
+        if (this.#impl !== void 0) {
+          return this.#impl;
+        }
+        if (installedPlatform === void 0) {
+          return void 0;
+        }
+        this.#impl = installedPlatform.asyncContext.create();
+        if (this.#fallbackStore !== void 0) {
+          this.#impl.enterWith(this.#fallbackStore);
+          this.#fallbackStore = void 0;
+        }
+        return this.#impl;
+      }
+    };
+    storageContext = new DeferredHostAsyncContext();
+  }
+});
+
+// ../core/src/runtime/common/template.ts
+function normalizeTemplateName(templateName) {
+  if (LEADING_DOT_SEGMENT_PATTERN.test(templateName)) {
+    throw new Error(`invalid template name ${templateName}`);
+  }
+  const withoutLeadingSlash = templateName.replace(LEADING_SLASH_PATTERN, "");
+  const withoutExtension = withoutLeadingSlash.replace(
+    JINJA_EXTENSION_PATTERN,
+    ""
+  );
+  if (withoutExtension.split("/").includes("..")) {
+    throw new Error(`invalid template name ${templateName}`);
+  }
+  return `${withoutExtension}.jinja`;
+}
+var JINJA_EXTENSION_PATTERN, LEADING_DOT_SEGMENT_PATTERN, LEADING_SLASH_PATTERN;
+var init_template = __esm({
+  "../core/src/runtime/common/template.ts"() {
+    "use strict";
+    init_platform();
+    JINJA_EXTENSION_PATTERN = /\.jinja$/iu;
+    LEADING_DOT_SEGMENT_PATTERN = /^\.+\//u;
+    LEADING_SLASH_PATTERN = /^\/+/u;
+  }
+});
+
+// src/runtime/node-platform.ts
+import * as asyncHooks from "async_hooks";
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as fsPromises from "fs/promises";
+import * as os from "os";
+import * as pathModule from "path";
+import * as process2 from "process";
+import { Writable } from "stream";
+import { pipeline } from "stream/promises";
+import * as sqlite3 from "sqlite3";
+import * as yauzl from "yauzl";
+import * as yazl from "yazl";
+import { Environment, Loader } from "nunjucks";
+function encodeNodeResourceIdentity(kind, path) {
+  return `node-${kind}:${Buffer.from(pathModule.resolve(path), "utf8").toString("base64url")}`;
+}
+function decodeNodeResourceIdentity(identity, kind) {
+  const prefix = `node-${kind}:`;
+  if (!identity.startsWith(prefix)) {
+    return pathModule.isAbsolute(identity) ? identity : void 0;
+  }
+  try {
+    return Buffer.from(identity.slice(prefix.length), "base64url").toString(
+      "utf8"
+    );
+  } catch {
+    return void 0;
+  }
+}
+function getNodeResourcePath(resource) {
+  if (resource instanceof NodeFile || resource instanceof NodeDirectory) {
+    return resource.path;
+  }
+  if (typeof resource === "object" && resource !== null && "path" in resource && typeof resource.path === "string") {
+    return resource.path;
+  }
+  throw new TypeError("Expected a Node File or Directory resource");
+}
+function assertChildName(name) {
+  if (name.length === 0 || name === "." || name === ".." || pathModule.isAbsolute(name) || name.includes("/") || name.includes("\\")) {
+    throw new TypeError(`Directory child must be a relative name: ${name}`);
+  }
+}
+async function openNodeDatabase(file, options = {}) {
+  const flags = (options.readonly === true ? nodeSqlite3.OPEN_READONLY : nodeSqlite3.OPEN_READWRITE | nodeSqlite3.OPEN_CREATE) | nodeSqlite3.OPEN_FULLMUTEX;
+  return new NodeDatabaseConnection(await openNativeNodeDatabase(file, flags));
+}
+async function openNativeNodeDatabase(file, flags) {
+  if (!(file instanceof NodeFile)) {
+    throw new TypeError("The Node database adapter requires a NodeFile");
+  }
+  return await new Promise((resolve9, reject) => {
+    const database = new nodeSqlite3.Database(file.path, flags, (error) => {
+      if (error) reject(error);
+      else resolve9(database);
+    });
+  });
+}
+async function openNodeZip(file) {
+  if (!(file instanceof NodeFile)) {
+    throw new TypeError("The Node ZIP adapter requires a NodeFile");
+  }
+  const zipFile = await new Promise((resolve9, reject) => {
+    yauzl.open(
+      file.path,
+      { autoClose: false, lazyEntries: true },
+      (error, opened) => {
+        if (error || opened === void 0)
+          reject(error ?? new Error("Cannot open ZIP"));
+        else resolve9(opened);
+      }
+    );
+  });
+  const entries = await new Promise(
+    (resolve9, reject) => {
+      const discovered = /* @__PURE__ */ new Map();
+      const rejectAndClose = (error) => {
+        zipFile.close();
+        reject(
+          error instanceof Error ? error : new Error("Cannot scan ZIP central directory")
+        );
+      };
+      const resolveEntries = () => {
+        zipFile.off("error", rejectAndClose);
+        resolve9(discovered);
+      };
+      zipFile.on("entry", (entry) => {
+        if (!entry.fileName.endsWith("/")) {
+          discovered.set(entry.fileName, entry);
+        }
+        zipFile.readEntry();
+      });
+      zipFile.once("error", rejectAndClose);
+      zipFile.once("end", resolveEntries);
+      zipFile.readEntry();
+    }
+  );
+  let closed = false;
+  return {
+    close: () => {
+      if (!closed) zipFile.close();
+      closed = true;
+      return Promise.resolve();
+    },
+    listEntries: () => Promise.resolve([...entries.keys()]),
+    readEntry: async (name) => {
+      if (closed) throw new Error("Cannot read a closed ZIP archive");
+      const entry = entries.get(name);
+      if (entry === void 0) return void 0;
+      return await readNodeZipEntry(zipFile, entry);
+    }
+  };
+}
+async function readNodeZipEntry(zipFile, entry) {
+  const stream = await new Promise((resolve9, reject) => {
+    zipFile.openReadStream(entry, (error, opened) => {
+      if (error || opened === void 0) {
+        reject(error ?? new Error(`Cannot read ZIP entry: ${entry.fileName}`));
+      } else {
+        resolve9(opened);
+      }
+    });
+  });
+  return await collectNodeStream(stream);
+}
+async function writeNodeZip(file, entries) {
+  const zipFile = new yazl.ZipFile();
+  const writer = await file.openWriter();
+  const outputStream = zipFile.outputStream;
+  const outputDone = writeNodeStream(outputStream, writer);
+  const entryState = { cancelled: false, complete: false };
+  let iterator;
+  try {
+    iterator = getNodeZipEntryIterator(entries);
+    const entriesDone = addNodeZipEntries(zipFile, iterator, entryState);
+    await Promise.race([entriesDone, outputDone]);
+    if (!entryState.complete) {
+      throw new Error("ZIP output ended before entry production completed");
+    }
+    zipFile.end();
+    await outputDone;
+    await writer.commit();
+  } catch (error) {
+    entryState.cancelled = true;
+    if (!entryState.complete && iterator !== void 0) {
+      closeNodeZipEntryIterator(iterator);
+    }
+    if (!outputStream.destroyed) {
+      outputStream.destroy(
+        error instanceof Error ? error : new Error("Cannot write ZIP archive")
+      );
+    }
+    await outputDone.catch(() => void 0);
+    await writer.abort().catch(() => void 0);
+    throw error;
+  }
+}
+async function addNodeZipEntries(zipFile, iterator, state) {
+  while (!state.cancelled) {
+    const result = await iterator.next();
+    if (state.cancelled) return;
+    if (result.done) {
+      state.complete = true;
+      return;
+    }
+    zipFile.addBuffer(Buffer.from(result.value.data), result.value.name, {
+      compress: false
+    });
+  }
+}
+function getNodeZipEntryIterator(entries) {
+  const asyncIterator = entries[Symbol.asyncIterator];
+  return asyncIterator === void 0 ? entries[Symbol.iterator]() : asyncIterator.call(entries);
+}
+function closeNodeZipEntryIterator(iterator) {
+  if (iterator.return === void 0) return;
+  try {
+    void Promise.resolve(iterator.return()).catch(() => void 0);
+  } catch {
+  }
+}
+async function writeNodeStream(input, writer) {
+  await pipeline(
+    input,
+    new Writable({
+      write: (chunk, _encoding, callback) => {
+        void writer.write(chunk).then(
+          () => callback(),
+          (error) => callback(
+            error instanceof Error ? error : new Error("Cannot stream ZIP archive")
+          )
+        );
+      }
+    })
+  );
+}
+async function collectNodeStream(input) {
+  return await new Promise((resolve9, reject) => {
+    const chunks = [];
+    input.on("data", (chunk) => chunks.push(chunk));
+    input.once("error", reject);
+    input.once("end", () => resolve9(Buffer.concat(chunks)));
+  });
+}
+function resolveNodeDataDirectory() {
+  const injected = globalThis.__WIKIGRAPH_DATA_DIR__;
+  if (typeof injected === "string" && injected !== "") return injected;
+  let directory = nodeProcess.cwd();
+  while (true) {
+    for (const candidate of [
+      pathModule.join(directory, "data"),
+      pathModule.join(directory, "packages", "core", "data")
+    ]) {
+      try {
+        if (fs.statSync(candidate).isDirectory()) return candidate;
+      } catch {
+      }
+    }
+    const parent = pathModule.dirname(directory);
+    if (parent === directory)
+      throw new Error("Could not locate data directory");
+    directory = parent;
+  }
+}
+function createNodeWikiGraphStorage(stateRoot = pathModule.join(os.homedir(), ".wikigraph")) {
+  return {
+    library: new NodeDirectory(stateRoot),
+    documentStore: new NodeDirectory(pathModule.join(stateRoot, "documents"))
+  };
+}
+async function withNodeWikiGraphStorage(stateRoot, operation) {
+  return await withWikiGraphStorage(
+    stateRoot === void 0 ? void 0 : createNodeWikiGraphStorage(stateRoot),
+    operation
+  );
+}
+var nodeProcess, nodeSqlite3, NodeFile, NodeDirectory, NodeDatabaseConnection, nodeWikiGraphPlatform, NodeTemplateLoader;
+var init_node_platform = __esm({
+  "src/runtime/node-platform.ts"() {
+    "use strict";
+    init_platform();
+    init_template();
+    nodeProcess = process2.default ?? process2;
+    nodeSqlite3 = sqlite3.default ?? sqlite3;
+    NodeFile = class {
+      constructor(path, name = pathModule.basename(path)) {
+        this.path = path;
+        this.identity = encodeNodeResourceIdentity("file", path);
+        this.name = name;
+      }
+      path;
+      identity;
+      name;
+      async read(options) {
+        return await fsPromises.readFile(
+          this.path,
+          options?.encoding === void 0 ? void 0 : { encoding: options.encoding }
+        );
+      }
+      async getSize() {
+        try {
+          return (await fsPromises.stat(this.path)).size;
+        } catch (error) {
+          if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+            return 0;
+          }
+          throw error;
+        }
+      }
+      async getLastModified() {
+        try {
+          return (await fsPromises.stat(this.path)).mtimeMs;
+        } catch (error) {
+          if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+            return void 0;
+          }
+          throw error;
+        }
+      }
+      async openWriter() {
+        await fsPromises.mkdir(pathModule.dirname(this.path), { recursive: true });
+        const temporary = `${this.path}.tmp-${crypto.randomUUID()}`;
+        const handle = await fsPromises.open(temporary, "wx");
+        let closed = false;
+        return {
+          write: async (data) => {
+            if (closed) throw new Error("Cannot write to a closed FileWriter");
+            if (typeof data === "string") await handle.write(data);
+            else await handle.write(Buffer.from(data));
+          },
+          commit: async () => {
+            if (!closed) {
+              await handle.close();
+              await fsPromises.rename(temporary, this.path);
+            }
+            closed = true;
+          },
+          abort: async () => {
+            if (!closed) {
+              await handle.close();
+              await fsPromises.rm(temporary, { force: true });
+            }
+            closed = true;
+          }
+        };
+      }
+    };
+    NodeDirectory = class _NodeDirectory {
+      constructor(path) {
+        this.path = path;
+        this.identity = encodeNodeResourceIdentity("directory", path);
+        this.name = pathModule.basename(path);
+      }
+      path;
+      identity;
+      name;
+      async getFile(name) {
+        assertChildName(name);
+        const file = new NodeFile(pathModule.join(this.path, name));
+        try {
+          return (await fsPromises.stat(file.path)).isFile() ? file : void 0;
+        } catch {
+          return void 0;
+        }
+      }
+      async getLastModified() {
+        try {
+          return (await fsPromises.stat(this.path)).mtimeMs;
+        } catch (error) {
+          if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+            return void 0;
+          }
+          throw error;
+        }
+      }
+      async getDirectory(name) {
+        assertChildName(name);
+        const directory = new _NodeDirectory(pathModule.join(this.path, name));
+        try {
+          return (await fsPromises.stat(directory.path)).isDirectory() ? directory : void 0;
+        } catch {
+          return void 0;
+        }
+      }
+      async list() {
+        const entries = await fsPromises.readdir(this.path, {
+          withFileTypes: true
+        });
+        return entries.map(
+          (entry) => entry.isDirectory() ? new _NodeDirectory(pathModule.join(this.path, entry.name)) : new NodeFile(pathModule.join(this.path, entry.name), entry.name)
+        );
+      }
+      async createFile(name) {
+        assertChildName(name);
+        await fsPromises.mkdir(this.path, { recursive: true });
+        const file = new NodeFile(pathModule.join(this.path, name));
+        await fsPromises.writeFile(file.path, "", { flag: "wx" });
+        return file;
+      }
+      async createDirectory(name) {
+        assertChildName(name);
+        await fsPromises.mkdir(this.path, { recursive: true });
+        const directory = new _NodeDirectory(pathModule.join(this.path, name));
+        await fsPromises.mkdir(directory.path);
+        return directory;
+      }
+      async remove(name, options) {
+        assertChildName(name);
+        await fsPromises.rm(pathModule.join(this.path, name), {
+          force: true,
+          recursive: options?.recursive === true
+        });
+      }
+    };
+    NodeDatabaseConnection = class {
+      constructor(database) {
+        this.database = database;
+      }
+      database;
+      async close() {
+        await new Promise((resolve9, reject) => {
+          this.database.close((error) => {
+            if (error) reject(error);
+            else resolve9();
+          });
+        });
+      }
+      async execute(sql) {
+        await new Promise((resolve9, reject) => {
+          this.database.exec(sql, (error) => {
+            if (error) reject(error);
+            else resolve9();
+          });
+        });
+      }
+      async queryAll(sql, params = []) {
+        return await new Promise((resolve9, reject) => {
+          this.database.all(sql, [...params], (error, rows) => {
+            if (error) reject(error);
+            else resolve9(rows);
+          });
+        });
+      }
+      async queryOne(sql, params = []) {
+        return await new Promise((resolve9, reject) => {
+          this.database.get(sql, [...params], (error, row) => {
+            if (error) reject(error);
+            else resolve9(row);
+          });
+        });
+      }
+      async run(sql, params = []) {
+        await new Promise((resolve9, reject) => {
+          this.database.run(sql, [...params], (error) => {
+            if (error) reject(error);
+            else resolve9();
+          });
+        });
+      }
+    };
+    nodeWikiGraphPlatform = {
+      asyncContext: {
+        create: () => new asyncHooks.AsyncLocalStorage()
+      },
+      database: { open: openNodeDatabase },
+      lifecycle: {
+        instanceId: `node-process:${nodeProcess.pid}`,
+        isInstanceAlive: (instanceId) => {
+          const match = /^node-process:(\d+)$/u.exec(instanceId);
+          if (match === null) return Promise.resolve(void 0);
+          try {
+            nodeProcess.kill(Number(match[1]), 0);
+            return Promise.resolve(true);
+          } catch (error) {
+            if (typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH") {
+              return Promise.resolve(false);
+            }
+            return Promise.resolve(true);
+          }
+        }
+      },
+      resources: {
+        getDirectory: (identity) => {
+          const path = decodeNodeResourceIdentity(identity, "directory");
+          return Promise.resolve(
+            path === void 0 ? void 0 : new NodeDirectory(path)
+          );
+        },
+        getFile: (identity) => {
+          const path = decodeNodeResourceIdentity(identity, "file");
+          return Promise.resolve(
+            path === void 0 ? void 0 : new NodeFile(path)
+          );
+        },
+        resolveLegacyDirectory: (reference) => {
+          const path = decodeNodeResourceIdentity(reference, "directory");
+          return Promise.resolve(
+            path === void 0 ? void 0 : new NodeDirectory(path)
+          );
+        }
+      },
+      templates: {
+        createEnvironment: (options) => new Environment(new NodeTemplateLoader(), options)
+      },
+      zip: { open: openNodeZip, write: writeNodeZip }
+    };
+    NodeTemplateLoader = class extends Loader {
+      getSource(templateName) {
+        const name = normalizeTemplateName(templateName);
+        const filePath = pathModule.join(resolveNodeDataDirectory(), name);
+        return {
+          noCache: false,
+          path: name,
+          src: fs.readFileSync(filePath, "utf8")
+        };
+      }
+    };
+  }
+});
+
 // src/support/errors.ts
 import { CLI_PRIMARY_COMMAND } from "wiki-graph-core";
 function withHelpRoute(message, route) {
@@ -79,7 +651,7 @@ var init_formats = __esm({
 });
 
 // src/runtime/context.ts
-import { AsyncLocalStorage } from "async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 async function withWikiGraphCLIRuntimeContext(context, operation) {
   return await cliRuntimeContext.run(context, operation);
 }
@@ -89,6 +661,9 @@ function getCLICwd() {
 function getCLIEnv() {
   return cliRuntimeContext.getStore()?.env ?? process.env;
 }
+function getCLIEnvValue(name) {
+  return getCLIEnv()[name];
+}
 function getCLIDevProjectRoot() {
   return cliRuntimeContext.getStore()?.devProjectRoot;
 }
@@ -126,15 +701,15 @@ var cliRuntimeContext, queueAutostartForTesting;
 var init_context = __esm({
   "src/runtime/context.ts"() {
     "use strict";
-    cliRuntimeContext = new AsyncLocalStorage();
+    cliRuntimeContext = new AsyncLocalStorage2();
   }
 });
 
 // src/support/io.ts
 import { createReadStream } from "fs";
-import { rm } from "fs/promises";
-import { join } from "path";
-import { createWikiGraphTempDirectory } from "wiki-graph-core";
+import { mkdtemp, rm as rm2 } from "fs/promises";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
 function readTextStreamFromStdin() {
   const stdin = getCLIStdin();
   stdin.setEncoding("utf8");
@@ -149,10 +724,10 @@ async function writeTextToStdout(text) {
   await writeChunkToStdout(text);
 }
 async function writeTextToStderr(text) {
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve9, reject) => {
     getCLIStderr().write(text, (error) => {
       if (error === void 0 || error === null) {
-        resolve4();
+        resolve9();
         return;
       }
       reject(error);
@@ -163,15 +738,15 @@ async function writeBinaryToStdout(data) {
   await writeChunkToStdout(data);
 }
 async function writeChunkToStdout(chunk) {
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve9, reject) => {
     getCLIStdout().write(chunk, (error) => {
       if (error === void 0 || error === null) {
-        resolve4();
+        resolve9();
         return;
       }
       if (isBrokenPipeError(error)) {
         setCLIExitCode(0);
-        resolve4();
+        resolve9();
         return;
       }
       reject(error);
@@ -183,14 +758,14 @@ function isBrokenPipeError(error) {
 }
 async function createTemporaryOutputPath(prefix, extension) {
   void prefix;
-  const directoryPath = await createWikiGraphTempDirectory("cli-output");
+  const directoryPath = await mkdtemp(join2(tmpdir(), "wikigraph-cli-output-"));
   return {
     directoryPath,
-    filePath: join(directoryPath, `output${extension}`)
+    filePath: join2(directoryPath, `output${extension}`)
   };
 }
 async function removeTemporaryDirectory(directoryPath) {
-  await rm(directoryPath, { force: true, recursive: true });
+  await rm2(directoryPath, { force: true, recursive: true });
 }
 var init_io = __esm({
   "src/support/io.ts"() {
@@ -388,11 +963,74 @@ var init_tree = __esm({
   }
 });
 
+// src/support/uri.ts
+import { homedir as homedir2 } from "os";
+import { isAbsolute as isAbsolute2, relative, resolve as resolve2 } from "path";
+import {
+  formatWikiGraphCommandUri as formatPortableWikiGraphCommandUri,
+  parseLocatedWikiGraphUri as parsePortableLocatedWikiGraphUri
+} from "wiki-graph-core";
+function parseLocatedWikiGraphUri(uri) {
+  const parsed = parsePortableLocatedWikiGraphUri(uri);
+  if (parsed.archivePath === void 0 || parsed.archivePath.startsWith("wikg://lib/")) {
+    return parsed;
+  }
+  return {
+    ...parsed,
+    archivePath: resolveCLIArchivePath(parsed.archivePath)
+  };
+}
+function formatWikiGraphCommandUri(archivePath, objectUri, cwd = getCLICwd()) {
+  let locator = archivePath;
+  if (isAbsolute2(archivePath)) {
+    const candidate = relative(cwd, archivePath);
+    if (candidate !== "" && !candidate.startsWith("..") && !isAbsolute2(candidate)) {
+      locator = candidate;
+    }
+  }
+  return formatPortableWikiGraphCommandUri(locator, objectUri);
+}
+function getRelativeArchiveUriResolution(uri) {
+  let parsed;
+  try {
+    parsed = parsePortableLocatedWikiGraphUri(uri);
+  } catch {
+    return void 0;
+  }
+  const locator = parsed.archivePath;
+  if (locator === void 0 || locator === "~" || locator.startsWith("~/") || locator.startsWith("wikg://lib/") || isAbsolute2(locator)) {
+    return void 0;
+  }
+  const workingDirectory = getCLICwd();
+  return {
+    inputUri: uri,
+    resolvedArchivePath: resolve2(workingDirectory, locator),
+    workingDirectory
+  };
+}
+function resolveCLIArchivePath(locator) {
+  if (locator === "~") return getCLIHomeDirectory();
+  if (locator.startsWith("~/")) {
+    return resolve2(getCLIHomeDirectory(), locator.slice(2));
+  }
+  return resolve2(getCLICwd(), locator);
+}
+function getCLIHomeDirectory() {
+  const environmentHome = getCLIEnvValue("HOME")?.trim();
+  return environmentHome === void 0 || environmentHome === "" ? homedir2() : environmentHome;
+}
+var init_uri = __esm({
+  "src/support/uri.ts"() {
+    "use strict";
+    init_context();
+  }
+});
+
 // src/support/version.ts
-import { existsSync, readFileSync } from "fs";
-import { dirname, join as join2, parse, resolve } from "path";
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join3, parse, resolve as resolve3 } from "path";
 function isCLIPackageJSON(path) {
-  const parsed = JSON.parse(readFileSync(path, "utf8"));
+  const parsed = JSON.parse(readFileSync2(path, "utf8"));
   return typeof parsed === "object" && parsed !== null && "name" in parsed && parsed.name === "wiki-graph";
 }
 function findPackageJSONPathFromWorkingDirectory() {
@@ -400,8 +1038,8 @@ function findPackageJSONPathFromWorkingDirectory() {
   const rootDirectoryPath = parse(currentDirectoryPath).root;
   while (true) {
     for (const candidatePath of [
-      join2(currentDirectoryPath, "package.json"),
-      join2(currentDirectoryPath, "packages", "cli", "package.json")
+      join3(currentDirectoryPath, "package.json"),
+      join3(currentDirectoryPath, "packages", "cli", "package.json")
     ]) {
       if (existsSync(candidatePath) && isCLIPackageJSON(candidatePath)) {
         return candidatePath;
@@ -410,13 +1048,13 @@ function findPackageJSONPathFromWorkingDirectory() {
     if (currentDirectoryPath === rootDirectoryPath) {
       return void 0;
     }
-    currentDirectoryPath = dirname(currentDirectoryPath);
+    currentDirectoryPath = dirname2(currentDirectoryPath);
   }
 }
 function resolvePackageJSONPath() {
   const injectedCLIDistDirectoryPath = globalThis.__WIKIGRAPH_CLI_DIST_DIR__;
   const candidatePaths = [
-    typeof injectedCLIDistDirectoryPath === "string" ? resolve(injectedCLIDistDirectoryPath, "../package.json") : void 0,
+    typeof injectedCLIDistDirectoryPath === "string" ? resolve3(injectedCLIDistDirectoryPath, "../package.json") : void 0,
     findPackageJSONPathFromWorkingDirectory()
   ];
   for (const candidatePath of candidatePaths) {
@@ -428,7 +1066,7 @@ function resolvePackageJSONPath() {
 }
 function readCLIVersion() {
   const packageJSONPath = resolvePackageJSONPath();
-  const parsed = JSON.parse(readFileSync(packageJSONPath, "utf8"));
+  const parsed = JSON.parse(readFileSync2(packageJSONPath, "utf8"));
   if (typeof parsed === "object" && parsed !== null && "version" in parsed && typeof parsed.version === "string") {
     return parsed.version;
   }
@@ -451,13 +1089,15 @@ var init_support = __esm({
     init_json();
     init_shell();
     init_tree();
+    init_uri();
     init_version();
   }
 });
 
 // src/runtime/local-config.ts
-import { resolveWikiGraphCoreDatabasePath } from "wiki-graph-core";
 import { openSharedStateDatabase } from "wiki-graph-core";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
 async function readLocalConfigSection(section) {
   return await withLocalConfigDatabase(async (database) => {
     return await readLocalConfigSectionInDatabase(database, section);
@@ -540,7 +1180,9 @@ function validateLocalConfigSection(section, value) {
 }
 async function withLocalConfigDatabase(operation) {
   const database = await openSharedStateDatabase(
-    resolveWikiGraphCoreDatabasePath(),
+    new NodeFile(
+      join4(getCLIStateDir() ?? join4(homedir3(), ".wikigraph"), "core.sqlite")
+    ),
     LOCAL_CONFIG_SCHEMA_SQL
   );
   try {
@@ -690,6 +1332,8 @@ var LOCAL_CONFIG_SECTIONS, LOCAL_CONFIG_SCHEMA_SQL;
 var init_local_config = __esm({
   "src/runtime/local-config.ts"() {
     "use strict";
+    init_context();
+    init_node_platform();
     LOCAL_CONFIG_SECTIONS = [
       "concurrent",
       "embeddings",
@@ -1219,12 +1863,12 @@ function planGenerationTask(task, words, chapters, concurrent, model) {
   };
 }
 function createGenerationPerformanceHints(input) {
-  if (!input.hasGenerationWork) {
+  if (!input.hasJobWork) {
     return [];
   }
   const hints = [];
   const recommendedRequest = input.concurrent.request < 4 ? DEFAULT_GENERATION_REQUEST_CONCURRENCY : input.concurrent.request < 8 ? 8 : void 0;
-  if (recommendedRequest !== void 0) {
+  if (input.hasRequestWork && recommendedRequest !== void 0) {
     hints.push({
       command: `wg wikg://local/config/concurrent put request ${recommendedRequest}`,
       current: input.concurrent.request,
@@ -1238,7 +1882,7 @@ function createGenerationPerformanceHints(input) {
       command: "wg wikg://local/config/concurrent put job 4",
       current: input.concurrent.job,
       kind: "job",
-      message: "Multiple chapters need generation and job concurrency is below 4. Raising it lets chapter jobs run in parallel.",
+      message: "Multiple chapters need work and job concurrency is below 4. Raising it lets chapter jobs run in parallel.",
       recommended: 4
     });
   }
@@ -1690,7 +2334,6 @@ var init_progress_output = __esm({
 });
 
 // src/runtime/stage.ts
-import { resolveDataDirPath as resolveDataDirPath2 } from "wiki-graph-core";
 import {
   DEFAULT_EXTRACTION_PROMPT,
   DEFAULT_KNOWLEDGE_GRAPH_RECALL_PROMPT,
@@ -1702,14 +2345,13 @@ import { LLM } from "wiki-graph-core";
 function createStageLLM(config, options) {
   const llmOptions = buildLLMOptions(config);
   return new LLM({
-    dataDirPath: resolveDataDirPath2(),
     sampling: createDefaultWikiGraphSampling({
       ...llmOptions.temperature === void 0 ? {} : { temperature: llmOptions.temperature },
       ...llmOptions.topP === void 0 ? {} : { topP: llmOptions.topP }
     }),
     ...llmOptions,
-    ...options?.cacheDirPath === void 0 ? {} : { cacheDirPath: options.cacheDirPath },
-    ...options?.logDirPath === void 0 ? {} : { logDirPath: options.logDirPath },
+    ...options?.cacheDirectory === void 0 ? {} : { cacheDirectory: options.cacheDirectory },
+    ...options?.logDirectory === void 0 ? {} : { logDirectory: options.logDirectory },
     ...options?.onStreamProgress === void 0 ? {} : { onStreamProgress: options.onStreamProgress },
     ...options?.onTokenUsage === void 0 ? {} : { onTokenUsage: options.onTokenUsage }
   });
@@ -1737,6 +2379,52 @@ var init_stage = __esm({
   }
 });
 
+// src/runtime/wikispine.ts
+import { spawn } from "child_process";
+var nodeWikispineCommandRunner;
+var init_wikispine = __esm({
+  "src/runtime/wikispine.ts"() {
+    "use strict";
+    nodeWikispineCommandRunner = {
+      run: async ({ args, command, input, onStdout }) => await new Promise((resolve9, reject) => {
+        const child = spawn(command, [...args], {
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        const stderr = [];
+        let settled = false;
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+          if (settled) return;
+          try {
+            onStdout(chunk);
+          } catch (error) {
+            settled = true;
+            child.kill();
+            reject(error instanceof Error ? error : new Error(String(error)));
+          }
+        });
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", (error) => {
+          if (settled) return;
+          settled = true;
+          reject(
+            new Error(`Failed to start wikispine command: ${error.message}`)
+          );
+        });
+        child.on("close", (exitCode) => {
+          if (settled) return;
+          settled = true;
+          resolve9({
+            exitCode,
+            stderr: Buffer.concat(stderr).toString("utf8")
+          });
+        });
+        child.stdin.end(input);
+      })
+    };
+  }
+});
+
 // src/runtime/index.ts
 var init_runtime = __esm({
   "src/runtime/index.ts"() {
@@ -1748,6 +2436,7 @@ var init_runtime = __esm({
     init_progress();
     init_progress_output();
     init_stage();
+    init_wikispine();
   }
 });
 
@@ -1756,8 +2445,8 @@ var convert_exports = {};
 __export(convert_exports, {
   runConvertCommand: () => runConvertCommand
 });
-import { rm as rm2 } from "fs/promises";
-import { resolve as resolve2 } from "path";
+import { rm as rm3 } from "fs/promises";
+import { resolve as resolve4 } from "path";
 import { WikiGraph } from "wiki-graph-core";
 async function runConvertCommand(args) {
   const input = resolveInputEndpoint(args);
@@ -1801,7 +2490,7 @@ async function runConvertCommand(args) {
       throw new Error("Internal error: wikg input requires a file path.");
     }
     try {
-      await app.openSession(input.path, async (digest) => {
+      await app.openSession(new NodeFile(input.path), async (digest) => {
         await writeDigestOutput(digest, output);
       });
       return;
@@ -1822,7 +2511,7 @@ async function runConvertCommand(args) {
       }
       await app.digestTextStreamSession(
         {
-          ...digestDirPath === void 0 ? {} : { documentDirPath: digestDirPath },
+          ...digestDirPath === void 0 ? {} : { documentDirectory: new NodeDirectory(digestDirPath) },
           ...progressRenderer.onProgress === void 0 ? {} : { onProgress: progressRenderer.onProgress },
           sourceFormat: input.format,
           stream: readTextStreamFromStdin(),
@@ -1839,9 +2528,9 @@ async function runConvertCommand(args) {
       case "epub":
         await app.digestEpubSession(
           {
-            ...digestDirPath === void 0 ? {} : { documentDirPath: digestDirPath },
+            ...digestDirPath === void 0 ? {} : { documentDirectory: new NodeDirectory(digestDirPath) },
             ...progressRenderer.onProgress === void 0 ? {} : { onProgress: progressRenderer.onProgress },
-            path: input.path,
+            file: new NodeFile(input.path),
             ...extractionPrompt === void 0 ? {} : { extractionPrompt },
             targetStage
           },
@@ -1853,9 +2542,9 @@ async function runConvertCommand(args) {
       case "markdown":
         await app.digestMarkdownSession(
           {
-            ...digestDirPath === void 0 ? {} : { documentDirPath: digestDirPath },
+            ...digestDirPath === void 0 ? {} : { documentDirectory: new NodeDirectory(digestDirPath) },
             ...progressRenderer.onProgress === void 0 ? {} : { onProgress: progressRenderer.onProgress },
-            path: input.path,
+            file: new NodeFile(input.path),
             ...extractionPrompt === void 0 ? {} : { extractionPrompt },
             targetStage
           },
@@ -1867,9 +2556,9 @@ async function runConvertCommand(args) {
       case "txt":
         await app.digestTxtSession(
           {
-            ...digestDirPath === void 0 ? {} : { documentDirPath: digestDirPath },
+            ...digestDirPath === void 0 ? {} : { documentDirectory: new NodeDirectory(digestDirPath) },
             ...progressRenderer.onProgress === void 0 ? {} : { onProgress: progressRenderer.onProgress },
-            path: input.path,
+            file: new NodeFile(input.path),
             ...extractionPrompt === void 0 ? {} : { extractionPrompt },
             targetStage
           },
@@ -1888,8 +2577,8 @@ async function prepareDigestDirPath(args, requiresDigest) {
   if (normalizedPath === void 0 || !requiresDigest) {
     return void 0;
   }
-  const resolvedPath = resolve2(normalizedPath);
-  await rm2(resolvedPath, { force: true, recursive: true });
+  const resolvedPath = resolve4(normalizedPath);
+  await rm3(resolvedPath, { force: true, recursive: true });
   return resolvedPath;
 }
 async function loadRequiredConfig(args, requiresDigest) {
@@ -1938,14 +2627,14 @@ async function writeDigestOutput(digest, output) {
 async function writeDigestToFile(digest, path, format) {
   switch (format) {
     case "epub":
-      await digest.exportEpub(path);
+      await digest.exportEpub(new NodeFile(path));
       return;
     case "markdown":
     case "txt":
-      await digest.exportText(path);
+      await digest.exportText(new NodeFile(path));
       return;
     case "wikg":
-      await digest.saveAs(path);
+      await digest.saveAs(new NodeFile(path));
       return;
   }
 }
@@ -2040,17 +2729,17 @@ var init_convert = __esm({
     init_llm();
     init_support();
     init_runtime();
+    init_node_platform();
   }
 });
 
 // src/commands/archive-command/create.ts
-import { rename, rm as rm3, stat } from "fs/promises";
-import { basename, dirname as dirname2, join as join3 } from "path";
+import { mkdtemp as mkdtemp2, rename as rename2, rm as rm4, stat as stat2 } from "fs/promises";
+import { basename as basename2, dirname as dirname3, join as join5 } from "path";
+import { tmpdir as tmpdir2 } from "os";
 import {
-  createWikiGraphTempDirectory as createWikiGraphTempDirectory2,
   DirectoryDocument,
   formatLocatedWikiGraphUri,
-  formatWikiGraphCommandUri,
   TOC_FILE_VERSION,
   writeWikgArchive
 } from "wiki-graph-core";
@@ -2061,7 +2750,7 @@ async function createArchive(args) {
     await finalizeCreatedArchiveFile(args, outputPath);
   } finally {
     if (outputPath !== args.archivePath) {
-      await rm3(outputPath, { force: true, recursive: true });
+      await rm4(outputPath, { force: true, recursive: true });
     }
   }
   await writeCreatedArchive(args);
@@ -2081,8 +2770,11 @@ async function writeCreatedArchiveFile(args, outputPath) {
   });
 }
 async function createEmptyArchive(outputPath) {
-  const directoryPath = await createWikiGraphTempDirectory2("archive-write");
-  const document = await DirectoryDocument.open(directoryPath);
+  const directoryPath = await mkdtemp2(
+    join5(tmpdir2(), "wikigraph-archive-write-")
+  );
+  const directory = new NodeDirectory(directoryPath);
+  const document = await DirectoryDocument.open(directory);
   try {
     try {
       await document.openSession(async (openedDocument) => {
@@ -2094,9 +2786,9 @@ async function createEmptyArchive(outputPath) {
     } finally {
       await document.release();
     }
-    await writeWikgArchive(directoryPath, outputPath);
+    await writeWikgArchive(directory, new NodeFile(outputPath));
   } finally {
-    await rm3(directoryPath, { force: true, recursive: true });
+    await rm4(directoryPath, { force: true, recursive: true });
   }
 }
 async function prepareCreateArchiveOutputPath(args) {
@@ -2106,20 +2798,20 @@ async function prepareCreateArchiveOutputPath(args) {
   if (args.replace !== true) {
     return args.archivePath;
   }
-  return join3(
-    dirname2(args.archivePath),
-    `.${basename(args.archivePath)}.${process.pid}.${Date.now()}.tmp.wikg`
+  return join5(
+    dirname3(args.archivePath),
+    `.${basename2(args.archivePath)}.${process.pid}.${Date.now()}.tmp.wikg`
   );
 }
 async function finalizeCreatedArchiveFile(args, outputPath) {
   if (outputPath === args.archivePath) {
     return;
   }
-  await rename(outputPath, args.archivePath);
+  await rename2(outputPath, args.archivePath);
 }
 async function fileExists(path) {
   try {
-    await stat(path);
+    await stat2(path);
     return true;
   } catch (error) {
     if (isNodeENOENTError(error)) {
@@ -2150,6 +2842,7 @@ async function writeCreatedArchive(args) {
 var init_create = __esm({
   "src/commands/archive-command/create.ts"() {
     "use strict";
+    init_node_platform();
     init_convert();
     init_support();
   }
@@ -2157,7 +2850,6 @@ var init_create = __esm({
 
 // src/commands/archive-command/inspect.ts
 import {
-  formatWikiGraphCommandUri as formatWikiGraphCommandUri2,
   isArchiveSearchIndexCurrent,
   listChapters
 } from "wiki-graph-core";
@@ -2171,11 +2863,10 @@ async function writeArchiveInspectReport(document, args) {
 }
 async function createArchiveInspectReport(document, args) {
   const archiveUri = formatArchiveInspectCommandUri(args.archivePath);
-  const scopeUri = args.chapterId === void 0 ? archiveUri : `${archiveUri}/chapter/${args.chapterId}`;
   const [
     chapters,
     summaryWords,
-    ftsCurrent,
+    indexCacheCurrent,
     config,
     ftsArtifactCoverage,
     sourceEmbeddingArtifactCoverage,
@@ -2189,6 +2880,8 @@ async function createArchiveInspectReport(document, args) {
     readIndexArtifactCoverage(document, "embedding-source", args.chapterId),
     readIndexArtifactCoverage(document, "embedding-summary", args.chapterId)
   ]);
+  const selectedChapter = args.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
@@ -2219,15 +2912,28 @@ async function createArchiveInspectReport(document, args) {
     contentChapters,
     summaryEmbeddingArtifactCoverage
   );
-  const queryBlockedChapters = contentChapters.filter(
+  const queryBlockedContentChapters = contentChapters.filter(
     (chapter) => !ftsArtifactCovered.includes(chapter) && !sourceEmbeddingArtifactCovered.includes(chapter)
-  ).map((chapter) => chapter.chapterId);
+  );
+  const queryBlockedChapters = queryBlockedContentChapters.map(
+    (chapter) => createInspectChapterReference(archiveUri, chapter)
+  );
+  const queryReady = queryBlockedChapters.length === 0;
+  const buildFtsCommand = formatCliCommand([
+    "wikg://local/job",
+    "add",
+    "--input",
+    scopeUri,
+    "--task",
+    "index-fts"
+  ]);
   const improvements = createInspectImprovements({
     archiveUri,
     concurrent,
     contentChapters,
-    ftsCurrent,
+    indexCacheCurrent,
     planningModel,
+    queryBlockedChapters: queryBlockedContentChapters,
     scopeUri,
     summaryCovered,
     knowledgeGraphCovered,
@@ -2239,7 +2945,10 @@ async function createArchiveInspectReport(document, args) {
       ...improvements.map((improvement) => improvement.missingChapters ?? 0)
     ),
     concurrent,
-    hasGenerationWork: improvements.some(
+    hasJobWork: improvements.some(
+      (improvement) => improvement.planning !== void 0
+    ),
+    hasRequestWork: improvements.some(
       (improvement) => improvement.planning !== void 0
     )
   });
@@ -2255,15 +2964,18 @@ async function createArchiveInspectReport(document, args) {
       sourceWords,
       summaryWords
     },
-    index: {
-      current: ftsCurrent,
-      ...ftsCurrent ? {} : {
+    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 ? {} : {
         fixCommand: formatCliCommand([`${archiveUri}/index`, "sync"]),
         impact: "The next archive query may need to sync index cache first.",
         resource: "local CPU/disk time only; no provider calls."
       },
-      querySupport: queryBlockedChapters.length === 0,
-      status: ftsCurrent ? "current" : "missing-or-outdated"
+      status: !queryReady ? "blocked" : indexCacheCurrent ? "current" : "missing-or-outdated",
+      syncAvailable: queryReady && !indexCacheCurrent
     },
     coverage: {
       ftsIndexArtifact: createInspectCoverage(
@@ -2285,12 +2997,25 @@ async function createArchiveInspectReport(document, args) {
         contentChapters
       )
     },
-    queryBlockedChapters,
+    query: {
+      ready: queryReady
+    },
+    searchArtifacts: {
+      blockedChapters: queryBlockedChapters,
+      ...!queryReady ? {
+        fixCommand: buildFtsCommand,
+        resource: "local CPU/disk time only; no provider calls."
+      } : {},
+      helpCommand: "wg help readiness",
+      ready: queryReady,
+      status: queryReady ? "ready" : "incomplete"
+    },
     retrievalGuidance: formatRetrievalGuidance({
-      ftsCurrent,
+      indexCacheCurrent,
       knowledgeGraphCovered,
       readingGraphCovered,
       contentChapters,
+      queryReady,
       sourceWords
     }),
     improvements,
@@ -2305,13 +3030,13 @@ function formatArchiveInspectCommandUri(archivePath) {
   if (archivePath.startsWith("wikg://lib/")) {
     return archivePath;
   }
-  return formatWikiGraphCommandUri2(archivePath);
+  return formatWikiGraphCommandUri(archivePath);
 }
 function formatArchiveInspectText(report) {
   return [
     "Archive Inspect",
     `URI: ${report.uri}`,
-    `Scope: ${report.scope.type === "archive" ? "archive" : `chapter ${report.scope.chapterId}`}`,
+    `Scope: ${report.scope.type === "archive" ? "archive" : report.uri}`,
     "",
     "Content",
     `Chapters: ${report.content.chapters.content} content / ${report.content.chapters.total} total`,
@@ -2319,13 +3044,21 @@ function formatArchiveInspectText(report) {
     `Source words: ${report.content.sourceWords}`,
     `Summary words: ${report.content.summaryWords}`,
     "",
+    "Query Readiness",
+    `Status: ${report.query.ready ? "available" : "unavailable"}`,
+    `Search artifacts: ${report.searchArtifacts.status}`,
+    ...report.searchArtifacts.ready ? [] : [
+      `Fix: ${report.searchArtifacts.fixCommand}`,
+      `Resource: ${report.searchArtifacts.resource}`,
+      `Help: ${report.searchArtifacts.helpCommand}`
+    ],
+    "",
     "Index Cache",
-    `Status: ${report.index.current ? "current" : "missing or outdated"}`,
-    `Query support: ${report.index.querySupport ? "available" : "unavailable"}`,
-    ...report.index.current ? [] : [
-      `Impact: ${report.index.impact}`,
-      `Fix: ${report.index.fixCommand}`,
-      `Resource: ${report.index.resource}`
+    `Status: ${report.localIndexCache.status === "missing-or-outdated" ? "missing or outdated" : report.localIndexCache.status}`,
+    ...report.localIndexCache.current ? [] : [
+      `Impact: ${report.localIndexCache.impact}`,
+      ...report.localIndexCache.fixCommand === void 0 ? [] : [`Fix: ${report.localIndexCache.fixCommand}`],
+      ...report.localIndexCache.resource === void 0 ? [] : [`Resource: ${report.localIndexCache.resource}`]
     ],
     "",
     "Coverage",
@@ -2345,8 +3078,11 @@ function formatArchiveInspectText(report) {
     formatCoverageLine("Knowledge Graph", report.coverage.knowledgeGraph),
     formatCoverageLine("Summary Artifact", report.coverage.summary),
     `Summary note: ${report.help.summaryCoverage}`,
-    ...report.queryBlockedChapters.length === 0 ? [] : [
-      `Query blockers: chapters ${report.queryBlockedChapters.join(", ")} have neither FTS nor source embedding index artifacts.`
+    ...report.searchArtifacts.blockedChapters.length === 0 ? [] : [
+      "Query blockers: these chapters have neither FTS nor source embedding index artifacts:",
+      ...report.searchArtifacts.blockedChapters.map(
+        (chapter) => `- ${chapter.title === null ? "[untitled]" : chapter.title}: ${chapter.locatedUri}`
+      )
     ],
     "",
     "Retrieval Guidance",
@@ -2362,6 +3098,17 @@ function formatArchiveInspectText(report) {
     ]
   ].join("\n") + "\n";
 }
+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 listChapters(document) : (await listChapters(document)).filter(
     (chapter) => chapter.chapterId === chapterId
@@ -2430,7 +3177,7 @@ function formatRetrievalGuidance(input) {
     ];
   }
   const lines = [
-    `Query cache: ${input.ftsCurrent ? "current" : "missing or outdated; archive query can sync it from artifacts"}.`
+    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(
@@ -2466,13 +3213,6 @@ function formatObjectSearchGuidance(label, covered, total) {
 }
 function createInspectImprovements(input) {
   const improvements = [];
-  if (!input.ftsCurrent) {
-    improvements.push({
-      command: formatCliCommand([`${input.archiveUri}/index`, "sync"]),
-      recommendation: "Sync the index cache from chapter index artifacts so query starts without a lazy cache rebuild.",
-      title: "Sync index cache"
-    });
-  }
   if (input.contentChapters.length === 0) {
     improvements.push({
       command: formatCliCommand([
@@ -2486,6 +3226,28 @@ function createInspectImprovements(input) {
     });
     return improvements;
   }
+  if (input.queryBlockedChapters.length > 0) {
+    improvements.push({
+      command: formatCliCommand([
+        "wikg://local/job",
+        "add",
+        "--input",
+        input.scopeUri,
+        "--task",
+        "index-fts"
+      ]),
+      missingChapters: input.queryBlockedChapters.length,
+      missingWords: sumWords(input.queryBlockedChapters),
+      recommendation: "Build local FTS artifacts to make this scope queryable. This does not call a provider.",
+      title: "Enable query with local FTS"
+    });
+  } else if (!input.indexCacheCurrent) {
+    improvements.push({
+      command: formatCliCommand([`${input.archiveUri}/index`, "sync"]),
+      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,
@@ -2612,6 +3374,7 @@ function formatPercent(numerator, denominator) {
 var init_inspect = __esm({
   "src/commands/archive-command/inspect.ts"() {
     "use strict";
+    init_support();
     init_config();
     init_runtime();
     init_support();
@@ -2627,7 +3390,20 @@ async function createOutputContinuationCursor(context, cursor) {
     return null;
   }
   let input;
-  if (context.continuationKind === "evidence") {
+  if (context.continuationKind === "source-locators") {
+    if (context.targetUri === void 0) {
+      throw new Error("Source locator cursors require a target URI.");
+    }
+    input = {
+      archiveKey: context.archiveKey,
+      archivePath: context.archivePath,
+      cursor,
+      format: context.format,
+      indexScope: context.indexScope,
+      kind: "source-locators",
+      targetUri: context.targetUri
+    };
+  } else if (context.continuationKind === "evidence") {
     if (context.targetUri === void 0) {
       throw new Error("Evidence continuation cursors require a target URI.");
     }
@@ -2724,25 +3500,13 @@ function formatSourceCitationBlock(uri, text) {
   return [`@@ ${uri} @@`, normalizeSourceText(text)].join("\n");
 }
 function normalizeSourceText(text) {
-  const lines = text.replace(/\r\n?/g, "\n").split("\n");
-  while (lines.length > 0 && lines[0]?.trim() === "") {
-    lines.shift();
-  }
-  while (lines.length > 0 && lines.at(-1)?.trim() === "") {
-    lines.pop();
-  }
+  const lines = text.replace(/\r\n?/gu, "\n").split("\n");
+  while (lines.length > 0 && lines[0]?.trim() === "") lines.shift();
+  while (lines.length > 0 && lines.at(-1)?.trim() === "") lines.pop();
   const normalizedLines = [];
-  let previousLineWasBlank = false;
   for (const line of lines) {
-    if (line.trim() === "") {
-      if (!previousLineWasBlank) {
-        normalizedLines.push("");
-      }
-      previousLineWasBlank = true;
-      continue;
-    }
-    normalizedLines.push(line);
-    previousLineWasBlank = false;
+    if (line.trim() === "" && normalizedLines.at(-1) === "") continue;
+    normalizedLines.push(line.trim() === "" ? "" : line);
   }
   return normalizedLines.join("\n");
 }
@@ -2864,7 +3628,7 @@ function toWikiGraphUri(id) {
       return id;
   }
 }
-var init_uri = __esm({
+var init_uri2 = __esm({
   "src/commands/archive-output/object/uri.ts"() {
     "use strict";
   }
@@ -2878,6 +3642,11 @@ var init_types = __esm({
     DEFAULT_GET_EVIDENCE_LIMIT = 3;
     PLAIN_OBJECT_KEY_PRIORITY = [
       "uri",
+      "digest",
+      "mediaType",
+      "name",
+      "identifier",
+      "locator",
       "title",
       "label",
       "labels",
@@ -2954,10 +3723,6 @@ var init_plain = __esm({
 });
 
 // src/commands/archive-output/text/object.ts
-import {
-  formatWikiGraphCommandUri as formatWikiGraphCommandUri3,
-  parseLocatedWikiGraphUri as parseLocatedWikiGraphUri7
-} from "wiki-graph-core";
 function formatFindObject(object) {
   const lines = formatScoredLines(
     object.score,
@@ -3000,10 +3765,10 @@ function formatOpenShortUriCommand(locator, objectUri) {
   if (locator.startsWith("wikg://lib/")) {
     return `${locator.replace(/\/+$/u, "")}/${objectUri.slice("wikg://".length)}`;
   }
-  return formatWikiGraphCommandUri3(locator, objectUri);
+  return formatWikiGraphCommandUri(locator, objectUri);
 }
 function isShortOutputUri(uri) {
-  return uri.startsWith("wikg://") && parseLocatedWikiGraphUri7(uri).archivePath === void 0;
+  return uri.startsWith("wikg://") && parseLocatedWikiGraphUri(uri).archivePath === void 0;
 }
 function formatBacklinkLines(backlinks) {
   const lines = [
@@ -3093,7 +3858,8 @@ var init_object = __esm({
   "src/commands/archive-output/text/object.ts"() {
     "use strict";
     init_support();
-    init_uri();
+    init_support();
+    init_uri2();
     init_evidence();
     init_lines();
     init_plain();
@@ -3248,6 +4014,10 @@ async function createBacklinkBucketObject(bucket, context) {
 async function createPageObject(page, context) {
   const librarySource = createLibrarySourceObject(page);
   switch (page.type) {
+    case "artifact": {
+      const { id: _id, type: _type, ...rest } = page;
+      return { ...librarySource, ...rest, uri: page.id };
+    }
     case "entity-wikipage":
       return {
         ...librarySource,
@@ -3379,14 +4149,11 @@ var init_objects = __esm({
   "src/commands/archive-output/object/objects.ts"() {
     "use strict";
     init_cursor();
-    init_uri();
+    init_uri2();
   }
 });
 
 // src/commands/archive-output/text/page.ts
-import {
-  formatWikiGraphCommandUri as formatWikiGraphCommandUri4
-} from "wiki-graph-core";
 async function formatEvidenceBackedPageText(uri, label, evidence, context) {
   if (context.evidenceLimit === void 0) {
     return [`${uri}`, label].join("\n");
@@ -3409,7 +4176,7 @@ function appendEntityNextSteps(text, uri, archivePath) {
   if (!isEntityOutputUri(uri)) {
     return text;
   }
-  const entityUri = formatWikiGraphCommandUri4(
+  const entityUri = formatWikiGraphCommandUri(
     archivePath,
     uri.replace(/\/$/u, "")
   );
@@ -3480,6 +4247,8 @@ function formatPosition(position) {
 }
 async function formatPackAnchor(anchor, context) {
   switch (anchor.type) {
+    case "artifact":
+      return formatPlainObject(await createPageObject(anchor, context));
     case "chapter-title":
     case "chapter":
       return formatPlainObject(await createPageObject(anchor, context));
@@ -3536,7 +4305,7 @@ var init_page = __esm({
     "use strict";
     init_support();
     init_objects();
-    init_uri();
+    init_uri2();
     init_evidence();
     init_plain();
   }
@@ -4008,6 +4777,12 @@ async function writePage(page, context, format) {
     return;
   }
   switch (page.type) {
+    case "artifact":
+      await writeTextToStdout(
+        `${formatPlainObject(await createPageObject(page, context))}
+`
+      );
+      return;
     case "chapter-title":
       await writeTextToStdout(
         `${formatPlainObject(await createPageObject(page, context))}
@@ -4122,13 +4897,77 @@ ${page.content}
       return;
   }
 }
-var init_page2 = __esm({
-  "src/commands/archive-output/write/page.ts"() {
+var init_page2 = __esm({
+  "src/commands/archive-output/write/page.ts"() {
+    "use strict";
+    init_support();
+    init_text();
+    init_jsonl();
+    init_objects();
+  }
+});
+
+// src/commands/archive-output/write/source-locators.ts
+async function writeSourceLocators(result, context, format) {
+  const nextCursor = await createOutputContinuationCursor(
+    context,
+    result.nextCursor
+  );
+  if (format === "json") {
+    await writeTextToStdout(
+      formatCLIJSON({
+        limit: result.limit,
+        nextCursor,
+        objects: result.items
+      })
+    );
+    return;
+  }
+  if (format === "jsonl") {
+    await writeJSONL([...result.items, createPageCursorObject(nextCursor)]);
+    return;
+  }
+  if (result.items.length === 0) {
+    await writeTextToStdout("No source locators.\n");
+    return;
+  }
+  await writeTextToStdout(
+    `${result.items.map(formatSourceLocator).join("\n")}${formatNextCursor(nextCursor)}
+`
+  );
+}
+async function writeAllSourceLocators(readPage, initialCursor, context, format) {
+  const pages = [];
+  let cursor = initialCursor;
+  while (true) {
+    const page = await readPage(cursor);
+    if (format === "jsonl") {
+      await writeJSONL(page.items);
+    } else {
+      pages.push(page);
+    }
+    if (page.nextCursor === null) break;
+    cursor = page.nextCursor;
+  }
+  if (format === "jsonl") return;
+  const items = pages.flatMap((page) => page.items);
+  await writeSourceLocators(
+    { items, limit: items.length, nextCursor: null },
+    context,
+    format
+  );
+}
+function formatSourceLocator(locator) {
+  return `${locator.range[0]}..${locator.range[1]} -> ${locator.uri}`;
+}
+var init_source_locators = __esm({
+  "src/commands/archive-output/write/source-locators.ts"() {
     "use strict";
     init_support();
+    init_cursor();
+    init_page_cursor();
     init_text();
     init_jsonl();
-    init_objects();
   }
 });
 
@@ -4141,6 +4980,7 @@ var init_write = __esm({
     init_list();
     init_pack();
     init_page2();
+    init_source_locators();
   }
 });
 
@@ -4156,13 +4996,12 @@ var init_archive_output = __esm({
 import {
   formatLocatedWikiGraphUri as formatLocatedWikiGraphUri2,
   parseWikiGraphLibraryUri as parseWikiGraphLibraryUri4,
-  parseLocatedWikiGraphUri as parseLocatedWikiGraphUri8,
-  requireLocatedObjectOrArchiveUri,
-  resolveWikiGraphLibraryArchivePath
+  resolveWikiGraphLibraryArchiveFile
 } from "wiki-graph-core";
 async function resolveArchiveRuntimeLocation(uriOrPath) {
   if (!uriOrPath.startsWith("wikg://")) {
     return {
+      archiveFile: new NodeFile(uriOrPath),
       archiveKey: uriOrPath,
       archivePath: uriOrPath,
       indexScope: {
@@ -4173,11 +5012,13 @@ async function resolveArchiveRuntimeLocation(uriOrPath) {
       locatedUri: formatLocatedWikiGraphUri2(uriOrPath)
     };
   }
-  const parsed = parseLocatedWikiGraphUri8(uriOrPath);
+  const parsed = parseLocatedWikiGraphUri(uriOrPath);
   const archiveLocator = parsed.archivePath ?? uriOrPath;
   const libraryArchiveTarget = archiveLocator.startsWith("wikg://lib/") ? parseWikiGraphLibraryUri4(archiveLocator) : void 0;
-  const archivePath = libraryArchiveTarget?.kind === "archive" ? await resolveWikiGraphLibraryArchivePath(archiveLocator) : archiveLocator;
+  const archiveFile = libraryArchiveTarget?.kind === "archive" ? await resolveWikiGraphLibraryArchiveFile(archiveLocator) : new NodeFile(archiveLocator);
+  const archivePath = getNodeResourcePath(archiveFile);
   return {
+    archiveFile,
     archiveKey: archivePath,
     archivePath,
     indexScope: { archiveKey: archivePath, archivePath, kind: "archive-index" },
@@ -4210,7 +5051,11 @@ function getArchivePath(uri) {
   if (parseWikiGraphLibraryUri4(uri)?.kind === "scope") {
     return uri;
   }
-  return requireLocatedObjectOrArchiveUri(uri).archivePath;
+  const archivePath = parseLocatedWikiGraphUri(uri).archivePath;
+  if (archivePath === void 0) {
+    throw new Error(`Missing archive locator in URI: ${uri}`);
+  }
+  return archivePath;
 }
 function getArchiveIndexScope(uri) {
   if (parseWikiGraphLibraryUri4(uri)?.kind === "scope") {
@@ -4224,19 +5069,21 @@ function getObjectUri(uri) {
   if (libraryTarget?.kind === "scope" && libraryTarget.objectUri !== void 0) {
     return libraryTarget.objectUri;
   }
-  const parsed = requireLocatedObjectOrArchiveUri(uri);
+  const parsed = parseLocatedWikiGraphUri(uri);
   return parsed.objectUri ?? "wikg://";
 }
 function isArchiveRootGet(args) {
-  return args.objectId !== void 0 && requireLocatedObjectOrArchiveUri(args.objectId).objectUri === void 0;
+  return args.objectId !== void 0 && parseLocatedWikiGraphUri(args.objectId).objectUri === void 0;
 }
 function parseChapterScope(uri) {
   const match = /^wikg:\/\/chapter\/([1-9][0-9]*)(?:\/|$)/u.exec(uri);
   return match?.[1] === void 0 ? void 0 : Number(match[1]);
 }
-var init_uri2 = __esm({
+var init_uri3 = __esm({
   "src/commands/archive-command/run/uri.ts"() {
     "use strict";
+    init_support();
+    init_node_platform();
   }
 });
 
@@ -4249,13 +5096,13 @@ import {
 } from "wiki-graph-core";
 async function readArchiveDocument(path, operation) {
   const location = await resolveArchiveRuntimeLocation(path);
-  return await new WikiGraphArchiveFile(location.archivePath).readDocument(
+  return await new WikiGraphArchiveFile(location.archiveFile).readDocument(
     operation
   );
 }
 async function writeArchiveDocument(path, operation, options = {}) {
   const location = await resolveArchiveRuntimeLocation(path);
-  const result = await new WikiGraphArchiveFile(location.archivePath).write(
+  const result = await new WikiGraphArchiveFile(location.archiveFile).write(
     operation,
     options
   );
@@ -4291,7 +5138,7 @@ function reportLibraryIndexSyncFailure(error) {
 var init_document = __esm({
   "src/commands/archive-command/run/document.ts"() {
     "use strict";
-    init_uri2();
+    init_uri3();
   }
 });
 
@@ -4308,7 +5155,7 @@ var init_types2 = __esm({
 
 // src/commands/archive-command/run/options.ts
 import {
-  parseLocatedWikiGraphUri as parseLocatedWikiGraphUri9
+  parseLocatedWikiGraphUri as parseLocatedWikiGraphUri2
 } from "wiki-graph-core";
 function createFindOptions(args) {
   const types = args.kinds?.map((kind) => {
@@ -4420,7 +5267,7 @@ function createScopeOptions(args) {
   if (args.chapters !== void 0) {
     return { chapters: args.chapters };
   }
-  const objectUri = parseLocatedWikiGraphUri9(args.archivePath).objectUri;
+  const objectUri = parseLocatedWikiGraphUri2(args.archivePath).objectUri;
   if (objectUri === void 0) {
     return {};
   }
@@ -4467,7 +5314,7 @@ var init_options = __esm({
   "src/commands/archive-command/run/options.ts"() {
     "use strict";
     init_types2();
-    init_uri2();
+    init_uri3();
   }
 });
 
@@ -4478,6 +5325,7 @@ import {
   findWikiGraphLibraryObjects,
   listArchiveCollection,
   listArchiveEvidence,
+  listArchiveSourceLocators,
   listWikiGraphLibraryArchiveMembers,
   listRelatedWikiGraphLibraryObjects,
   listWikiGraphLibraryEvidence,
@@ -4500,6 +5348,33 @@ async function runNextArchivePage(args) {
       );
     }
   }
+  if (cursor.kind === "source-locators") {
+    await readArchiveDocument(
+      getCursorArchivePath(cursor),
+      async (document) => {
+        const format = args.format ?? cursor.format;
+        const limit = args.limit ?? DEFAULT_OUTPUT_LIMIT;
+        await writeSourceLocators(
+          await listArchiveSourceLocators(document, cursor.targetUri, {
+            cursor: cursor.cursor,
+            limit
+          }),
+          {
+            archiveKey: cursor.archiveKey,
+            archivePath: cursor.archivePath,
+            continuationKind: "source-locators",
+            format,
+            indexScope: cursor.indexScope,
+            limit,
+            targetUri: cursor.targetUri,
+            types: null
+          },
+          format
+        );
+      }
+    );
+    return;
+  }
   if (cursor.indexScope?.kind === "library-index") {
     await runNextLibraryIndexPage(args, cursor);
     return;
@@ -4658,6 +5533,10 @@ async function runNextLibraryIndexPage(args, cursor) {
   const format = args.format ?? cursor.format;
   const limit = args.limit ?? DEFAULT_OUTPUT_LIMIT;
   switch (cursor.kind) {
+    case "source-locators":
+      throw new Error(
+        "Source locator cursors do not use the aggregate library index."
+      );
     case "collection": {
       const collectionOptions = {
         ...cursor.backlinks === void 0 ? {} : { backlinks: cursor.backlinks },
@@ -4809,7 +5688,7 @@ function createCursorOutputContext(cursor, format, limit) {
     format,
     indexScope: cursor.indexScope,
     limit,
-    types: cursor.kind === "evidence" || cursor.kind === "related" ? null : cursor.types,
+    types: cursor.kind === "evidence" || cursor.kind === "related" || cursor.kind === "source-locators" ? null : cursor.types,
     ...cursor.kind === "search" || cursor.kind === "collection" ? cursor.backlinks === void 0 ? {} : { backlinks: cursor.backlinks } : {},
     ...cursor.kind === "search" || cursor.kind === "collection" ? cursor.evidenceLimit === void 0 ? {} : { evidenceLimit: cursor.evidenceLimit } : {},
     ...cursor.kind === "search" || cursor.kind === "collection" ? cursor.sourceContext === void 0 ? {} : { sourceContext: cursor.sourceContext } : {},
@@ -4835,7 +5714,7 @@ var init_next = __esm({
     init_document();
     init_options();
     init_types2();
-    init_uri2();
+    init_uri3();
   }
 });
 
@@ -4855,7 +5734,7 @@ var init_root = __esm({
   "src/commands/archive-command/run/root.ts"() {
     "use strict";
     init_support();
-    init_uri2();
+    init_uri3();
   }
 });
 
@@ -4868,18 +5747,18 @@ var init_run = __esm({
     init_options();
     init_root();
     init_types2();
-    init_uri2();
+    init_uri3();
   }
 });
 
 // src/commands/archive-command/run/scope.ts
 import {
   listChapters as listChapters2,
-  parseLocatedWikiGraphUri as parseLocatedWikiGraphUri10,
+  parseLocatedWikiGraphUri as parseLocatedWikiGraphUri3,
   resolveChapterPathReadonly
 } from "wiki-graph-core";
 async function resolveArchiveChapterScope(document, args) {
-  const objectUri = parseLocatedWikiGraphUri10(args.archivePath).objectUri;
+  const objectUri = parseLocatedWikiGraphUri3(args.archivePath).objectUri;
   if (objectUri === void 0) {
     return void 0;
   }
@@ -4959,6 +5838,8 @@ import {
   resolveWikiGraphLibrary,
   findArchiveObjects as findArchiveObjects2,
   listArchiveQueryableChapterIds,
+  listArchiveSourceLocators as listArchiveSourceLocators2,
+  isSourceLocatorScopeUri,
   rebuildArchiveSearchIndex,
   WikiGraphArchiveFile as WikiGraphArchiveFile2
 } from "wiki-graph-core";
@@ -5028,6 +5909,32 @@ async function runArchiveCommand(args) {
       await readArchiveDocument(
         getArchivePath(args.archivePath),
         async (document) => {
+          const objectUri = getObjectUri(args.archivePath);
+          if (isSourceLocatorScopeUri(objectUri)) {
+            const context2 = createArchiveOutputContext(args, {
+              continuationKind: "source-locators",
+              targetUri: objectUri
+            });
+            const readPage = async (cursor) => await listArchiveSourceLocators2(document, objectUri, {
+              ...cursor === void 0 ? {} : { cursor },
+              ...args.limit === void 0 ? {} : { limit: args.limit }
+            });
+            if (args.all === true) {
+              await writeAllSourceLocators(
+                readPage,
+                args.cursor,
+                context2,
+                args.format ?? "text"
+              );
+              return;
+            }
+            await writeSourceLocators(
+              await readPage(args.cursor),
+              context2,
+              args.format ?? "text"
+            );
+            return;
+          }
           const scope = await resolveArchiveChapterScope(document, args);
           const scopedArgs = scope === void 0 ? args : { ...args, chapters: scope.chapterIds };
           const context = createArchiveOutputContext(scopedArgs, {
@@ -5207,14 +6114,21 @@ async function runArchiveCommand(args) {
 }
 async function ensureArchiveQueryIndexCache(args) {
   const location = await resolveArchiveRuntimeLocation(args.archivePath);
-  await new WikiGraphArchiveFile2(location.archivePath).write(
+  await new WikiGraphArchiveFile2(location.archiveFile).write(
     async (document) => {
       const scopedArgs = await createScopedQueryArgs(document, args);
       const options = scopedArgs.chapters === void 0 ? {} : { chapters: scopedArgs.chapters };
       if (await isArchiveSearchIndexCurrent2(document, options)) {
         return;
       }
-      await rebuildArchiveSearchIndex(document, void 0, options);
+      try {
+        await rebuildArchiveSearchIndex(document, void 0, options);
+      } catch (error) {
+        if (isArchiveQueryNotReadyError(error)) {
+          throw createArchiveQueryNotReadyError(args, error.message);
+        }
+        throw error;
+      }
     },
     { searchIndexWritebackPolicy: "cache" }
   );
@@ -5228,12 +6142,37 @@ async function createScopedQueryArgs(document, args) {
     ...scope === void 0 ? {} : { chapters: scope.chapterIds }
   });
   if (queryableChapters.length === 0) {
-    throw new Error(
+    throw createArchiveQueryNotReadyError(
+      args,
       "Wiki Graph query is not ready. No chapters in this scope have a current FTS artifact or source embedding artifact."
     );
   }
   return { ...args, chapters: queryableChapters };
 }
+function createArchiveQueryNotReadyError(args, reason) {
+  const buildCommand = formatCliCommand([
+    "wikg://local/job",
+    "add",
+    "--input",
+    args.archivePath,
+    "--task",
+    "index-fts"
+  ]);
+  return new Error(
+    [
+      reason,
+      "",
+      "Build local FTS artifacts without provider calls:",
+      `  ${buildCommand}`,
+      "",
+      "Help:",
+      "  wg help readiness"
+    ].join("\n")
+  );
+}
+function isArchiveQueryNotReadyError(error) {
+  return error instanceof Error && error.name === "ArchiveQueryNotReadyError";
+}
 function applyChapterScope(args, scope) {
   return scope === void 0 ? args : { ...args, chapters: scope.chapterIds };
 }
@@ -5517,6 +6456,7 @@ var init_archive_command = __esm({
     "use strict";
     init_config();
     init_embedding();
+    init_support();
     init_convert();
     init_create();
     init_inspect();
@@ -5593,12 +6533,12 @@ var init_entry_context = __esm({
 });
 
 // src/runtime/internal-child.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync2 } from "fs";
-import { join as join4, resolve as resolve3 } from "path";
+import { join as join6, resolve as resolve5 } from "path";
 function spawnInternalChild(kind, options = {}) {
   const command = createInternalChildCommand(kind, options.args ?? []);
-  return spawn(command.command, command.args, {
+  return spawn2(command.command, command.args, {
     cwd: getCLICwd(),
     detached: options.detached === true,
     env: createInternalChildEnvironment(),
@@ -5639,8 +6579,8 @@ function createInternalChildCommand(kind, args) {
   if (devProjectRoot !== void 0 && stateDir !== void 0) {
     return {
       args: [
-        join4(devProjectRoot, "node_modules", "tsx", "dist", "cli.mjs"),
-        join4(devProjectRoot, "packages", "cli", "src", "bin", `${kind}.ts`),
+        join6(devProjectRoot, "node_modules", "tsx", "dist", "cli.mjs"),
+        join6(devProjectRoot, "packages", "cli", "src", "bin", `${kind}.ts`),
         "--wikigraph-internal-child",
         kind,
         "--wikigraph-state-dir",
@@ -5670,8 +6610,8 @@ function createInternalChildEnvironment() {
 }
 function resolveProductionEntryPath(kind) {
   const filename = `${kind}.js`;
-  const distDirPath = globalThis.__WIKIGRAPH_CLI_DIST_DIR__ ?? resolve3(getCLICwd(), "packages", "cli", "dist");
-  const adjacent = join4(distDirPath, filename);
+  const distDirPath = globalThis.__WIKIGRAPH_CLI_DIST_DIR__ ?? resolve5(getCLICwd(), "packages", "cli", "dist");
+  const adjacent = join6(distDirPath, filename);
   if (existsSync2(adjacent)) {
     return adjacent;
   }
@@ -5703,6 +6643,7 @@ function createQueueAddEstimate(input) {
     target: input.target
   });
   const workChapters = Math.max(0, ...steps.map((step) => step.chapters));
+  const usesProvider = steps.some((step) => step.task !== "index-fts");
   return {
     chapters: input.chapters.length,
     concurrent,
@@ -5710,11 +6651,13 @@ function createQueueAddEstimate(input) {
     performanceHints: createGenerationPerformanceHints({
       chapters: workChapters,
       concurrent,
-      hasGenerationWork: steps.length > 0
+      hasJobWork: steps.length > 0,
+      hasRequestWork: usesProvider
     }),
     planning: sumGenerationPlanningCosts(model, steps),
     steps,
     target: input.target,
+    usesProvider,
     words
   };
 }
@@ -5847,7 +6790,7 @@ function sumGenerationPlanningCosts(model, steps) {
 function formatQueueAddEstimateJSON(estimate) {
   return {
     chapters: estimate.chapters,
-    concurrent: estimate.concurrent,
+    concurrent: estimate.usesProvider ? estimate.concurrent : { job: estimate.concurrent.job },
     includesPrerequisites: estimate.includesPrerequisites,
     performanceHints: estimate.performanceHints,
     steps: estimate.steps.map((step) => ({
@@ -5862,7 +6805,7 @@ function formatQueueAddEstimateJSON(estimate) {
     tokens: estimate.planning.tokens,
     waitSeconds: estimate.planning.timeSeconds,
     words: estimate.words,
-    model: estimate.planning.model
+    ...estimate.usesProvider ? { model: estimate.planning.model } : {}
   };
 }
 function formatQueueAddEstimateLines(estimate) {
@@ -5870,10 +6813,10 @@ function formatQueueAddEstimateLines(estimate) {
     "Estimate:",
     `  Work: ${estimate.target} over ${estimate.chapters} chapter${estimate.chapters === 1 ? "" : "s"} / ${estimate.words} words`,
     ...estimate.includesPrerequisites ? ["  Includes prerequisite Reading Graph work where missing."] : [],
-    `  Model: ${estimate.planning.model}`,
+    ...estimate.usesProvider ? [`  Model: ${estimate.planning.model}`] : [],
     `  Tokens: ${estimate.planning.tokens.input} input / ${estimate.planning.tokens.cacheableInput} cacheable input / ${estimate.planning.tokens.output} output`,
     `  Wait: ${formatGenerationPlanningDuration(estimate.planning.timeSeconds.min)}-${formatGenerationPlanningDuration(estimate.planning.timeSeconds.max)}`,
-    `  Current concurrency: job=${estimate.concurrent.job} request=${estimate.concurrent.request}`,
+    `  Current concurrency: job=${estimate.concurrent.job}${estimate.usesProvider ? ` request=${estimate.concurrent.request}` : ""}`,
     ...formatQueuePerformanceHintLines(estimate.performanceHints)
   ];
 }
@@ -5897,9 +6840,19 @@ var init_estimate = __esm({
 });
 
 // src/commands/queue/output.ts
+import {
+  formatLocatedChapterUri as formatLocatedChapterUri2,
+  listChapters as listChapters3,
+  WikiGraphArchiveFile as WikiGraphArchiveFile3
+} from "wiki-graph-core";
 async function writeJobList(jobs, options) {
+  const chapters = await resolveJobChapters(jobs);
   if (options.json) {
-    await writeTextToStdout(formatCLIJSON({ items: jobs.map(formatJobJSON) }));
+    await writeTextToStdout(
+      formatCLIJSON({
+        items: jobs.map((job) => formatJobJSON(job, chapters.get(job.jobId)))
+      })
+    );
     return;
   }
   if (jobs.length === 0) {
@@ -5909,57 +6862,65 @@ async function writeJobList(jobs, options) {
   await writeTextToStdout(
     `${formatJobListHeader()}
 ${jobs.map(
-      (job) => `${job.jobId.slice(0, 8).padEnd(8)} ${job.state.padEnd(9)} ${(job.currentStep ?? "-").padEnd(7)} ${job.target.padEnd(7)} ${job.chapterId.toString().padStart(7)} ${formatArchiveName(job.archivePath)}`
+      (job) => `${job.jobId.slice(0, 8).padEnd(8)} ${job.state.padEnd(9)} ${(job.currentStep ?? "-").padEnd(7)} ${job.target.padEnd(7)} ${formatJobChapterListLabel(job, chapters.get(job.jobId))}`
     ).join("\n")}
 `
   );
 }
 function formatJobListHeader() {
-  return `${"JOB".padEnd(8)} ${"STATE".padEnd(9)} ${"STEP".padEnd(7)} ${"TARGET".padEnd(7)} ${"CHAPTER".padStart(7)} ARCHIVE`;
+  return `${"JOB".padEnd(8)} ${"STATE".padEnd(9)} ${"STEP".padEnd(7)} ${"TARGET".padEnd(7)} CHAPTER`;
 }
 async function writeJobStatus(job, options) {
+  const chapter = await resolveJobChapter(job);
   if (options.json) {
-    await writeTextToStdout(formatCLIJSON(formatJobJSON(job)));
+    await writeTextToStdout(formatCLIJSON(formatJobJSON(job, chapter)));
     return;
   }
   await writeTextToStdout(
     [
       `Job: ${job.jobId}`,
       `State: ${job.state}`,
-      `Archive: ${job.archivePath}`,
-      `Chapter: ${job.chapterId}`,
+      `Archive: ${requireJobResourcePath(job, "archive", "archivePath")}`,
+      `Chapter: ${formatJobChapterLabel(job, chapter)}`,
+      ...chapter === void 0 ? [] : [`Chapter URI: ${chapter.locatedUri}`],
       `Target: ${job.target}`,
       `Step: ${job.currentStep ?? "-"}`,
-      `Workspace: ${job.workspacePath}`,
-      `Cache: ${job.cachePath}`,
-      `Logs: ${job.logPath}`,
+      `Workspace: ${getJobResourcePath(job, "workspace", "workspacePath") ?? "-"}`,
+      `Cache: ${getJobResourcePath(job, "cache", "cachePath") ?? "-"}`,
+      `Logs: ${getJobResourcePath(job, "log", "logPath") ?? "-"}`,
       ...job.errorJSON === void 0 ? [] : [`Error: ${job.errorJSON}`]
     ].join("\n") + "\n"
   );
 }
-function formatJobJSON(job) {
+function formatJobJSON(job, chapter) {
   return {
     archiveKey: job.archiveKey,
-    archivePath: job.archivePath,
-    cachePath: job.cachePath,
+    archivePath: getJobResourcePath(job, "archive", "archivePath"),
+    cachePath: getJobResourcePath(job, "cache", "cachePath"),
     chapterId: job.chapterId,
+    ...chapter === void 0 ? {} : {
+      chapter: {
+        locatedUri: chapter.locatedUri,
+        title: chapter.title,
+        uri: chapter.uri
+      }
+    },
     createdAt: job.createdAt,
     ...job.currentStep === void 0 ? {} : { currentStep: job.currentStep },
     ...job.errorJSON === void 0 ? {} : { errorJSON: job.errorJSON },
-    eventsPath: job.eventsPath,
+    eventsPath: getJobResourcePath(job, "events", "eventsPath"),
     ...job.finishedAt === void 0 ? {} : { finishedAt: job.finishedAt },
     jobId: job.jobId,
-    logPath: job.logPath,
+    logPath: getJobResourcePath(job, "log", "logPath"),
     ...job.llmJSON === void 0 ? {} : { llm: formatJobLLMJSON(job.llmJSON) },
     ...job.ownerId === void 0 ? {} : { ownerId: job.ownerId },
-    ...job.ownerPid === void 0 ? {} : { ownerPid: job.ownerPid },
     ...job.prompt === void 0 ? {} : { prompt: job.prompt },
     queueRank: job.queueRank,
     state: job.state,
     ...job.readingSummaryStartedAt === void 0 ? {} : { readingSummaryStartedAt: job.readingSummaryStartedAt },
     target: job.target,
     updatedAt: job.updatedAt,
-    workspacePath: job.workspacePath
+    workspacePath: getJobResourcePath(job, "workspace", "workspacePath")
   };
 }
 function formatJobQueuedNotice(job) {
@@ -6003,10 +6964,11 @@ function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 async function writeJobSummary(job, options = { json: false }) {
+  const chapter = options.chapter === void 0 ? await resolveJobChapter(job) : createJobChapterReference(job, options.chapter);
   if (options.json) {
     await writeTextToStdout(
       formatCLIJSON({
-        ...formatJobJSON(job),
+        ...formatJobJSON(job, chapter),
         ...formatJobQueuedNotice(job) === void 0 ? {} : { notice: formatJobQueuedNotice(job) },
         ...options.estimate === void 0 ? {} : { estimate: formatQueueAddEstimateJSON(options.estimate) },
         ...options.watch === true ? {
@@ -6021,7 +6983,8 @@ async function writeJobSummary(job, options = { json: false }) {
   }
   await writeTextToStdout(
     [
-      `Job ${job.jobId} ${job.state} ${job.target} chapter ${job.chapterId} ${job.archivePath}`,
+      `Job ${job.jobId} ${job.state} ${job.target} chapter ${formatJobChapterLabel(job, chapter)}`,
+      ...chapter === void 0 ? [] : [`Chapter URI: ${chapter.locatedUri}`],
       ...formatJobQueuedNotice(job) === void 0 ? [] : [formatJobQueuedNotice(job)],
       ...options.watch === true ? [
         `Watch: ${formatCliCommand([
@@ -6035,12 +6998,29 @@ async function writeJobSummary(job, options = { json: false }) {
   );
 }
 async function writeArchiveAddSummary(input) {
+  const jobsCommand = formatCliCommand(["wikg://local/job", "--json"]);
+  const verifyCommand = formatCliCommand([
+    formatWikiGraphCommandUri(input.archivePath),
+    "inspect"
+  ]);
   if (input.json) {
     await writeTextToStdout(
       formatCLIJSON({
-        created: input.created.map((item) => formatJobJSON(item.job)),
+        created: input.created.map(
+          (item) => formatJobJSON(
+            item.job,
+            createJobChapterReference(item.job, item.chapter)
+          )
+        ),
         ...input.estimate === void 0 ? {} : { estimate: formatQueueAddEstimateJSON(input.estimate) },
-        skipped: input.skipped
+        ...input.created.length === 0 ? {} : { jobsCommand, verifyCommand },
+        skipped: input.skipped.map((item) => ({
+          chapterId: item.chapter.chapterId,
+          chapter: formatChapterJSON(
+            createJobChapterReferenceFromPath(input.archivePath, item.chapter)
+          ),
+          reason: item.reason
+        }))
       })
     );
     return;
@@ -6051,38 +7031,129 @@ async function writeArchiveAddSummary(input) {
   ];
   for (const job of input.created) {
     lines.push(
-      `Job ${job.job.jobId} ${job.job.state} ${job.job.target} chapter ${job.job.chapterId}`
+      `Job ${job.job.jobId} ${job.job.state} ${job.job.target} chapter ${formatChapterLabel(job.chapter)}`,
+      `Chapter URI: ${createJobChapterReference(job.job, job.chapter).locatedUri}`
     );
   }
   for (const skipped of input.skipped) {
-    lines.push(`Skipped chapter ${skipped.chapterId}: ${skipped.reason}`);
+    lines.push(
+      `Skipped chapter ${formatChapterLabel(skipped.chapter)}: ${skipped.reason}`
+    );
   }
   if (input.estimate !== void 0) {
     lines.push("", ...formatQueueAddEstimateLines(input.estimate));
   }
+  if (input.created.length > 0) {
+    lines.push(
+      "",
+      `Jobs: ${jobsCommand}`,
+      `Verify after the jobs finish: ${verifyCommand}`
+    );
+  }
   await writeTextToStdout(`${lines.join("\n")}
 `);
 }
-function formatArchiveName(path) {
-  return path.split(/[\\/]/u).at(-1) ?? path;
+function formatJobChapterLabel(job, chapter) {
+  return chapter === void 0 ? `[unavailable; internal id ${job.chapterId}]` : formatChapterLabel(chapter);
+}
+function formatJobChapterListLabel(job, chapter) {
+  return chapter === void 0 ? `[unavailable; internal id ${job.chapterId}]` : `${chapter.title ?? "[untitled]"} ${chapter.locatedUri}`;
+}
+function formatChapterLabel(chapter) {
+  return chapter.title === null || chapter.title === void 0 ? chapter.uri : `${JSON.stringify(chapter.title)} (${chapter.uri})`;
+}
+function formatChapterJSON(chapter) {
+  return {
+    locatedUri: chapter.locatedUri,
+    title: chapter.title,
+    uri: chapter.uri
+  };
+}
+function createJobChapterReference(job, chapter) {
+  return createJobChapterReferenceFromPath(
+    requireJobResourcePath(job, "archive", "archivePath"),
+    chapter
+  );
+}
+function createJobChapterReferenceFromPath(archivePath, chapter) {
+  return {
+    locatedUri: formatLocatedChapterUri2(archivePath, chapter.path),
+    title: chapter.title,
+    uri: chapter.uri
+  };
+}
+async function resolveJobChapters(jobs) {
+  const jobsByArchive = /* @__PURE__ */ new Map();
+  for (const job of jobs) {
+    const archivePath = requireJobResourcePath(job, "archive", "archivePath");
+    const grouped = jobsByArchive.get(archivePath) ?? [];
+    grouped.push(job);
+    jobsByArchive.set(archivePath, grouped);
+  }
+  const entries = (await Promise.all(
+    [...jobsByArchive].map(async ([archivePath, archiveJobs]) => {
+      try {
+        let chapters = [];
+        await new WikiGraphArchiveFile3(
+          new NodeFile(archivePath)
+        ).readDocument(async (document) => {
+          chapters = await listChapters3(document);
+        });
+        const chaptersById = new Map(
+          chapters.map((chapter) => [chapter.chapterId, chapter])
+        );
+        return archiveJobs.flatMap((job) => {
+          const chapter = chaptersById.get(job.chapterId);
+          return chapter === void 0 ? [] : [
+            [
+              job.jobId,
+              createJobChapterReferenceFromPath(archivePath, chapter)
+            ]
+          ];
+        });
+      } catch {
+        return [];
+      }
+    })
+  )).flat();
+  return new Map(entries);
+}
+async function resolveJobChapter(job) {
+  return (await resolveJobChapters([job])).get(job.jobId);
+}
+function getJobResourcePath(job, resourceKey, legacyKey) {
+  const record = job;
+  const resource = record[resourceKey];
+  if (resource !== void 0) {
+    return getNodeResourcePath(resource);
+  }
+  const legacyPath = record[legacyKey];
+  if (typeof legacyPath === "string") return legacyPath;
+  return void 0;
+}
+function requireJobResourcePath(job, resourceKey, legacyKey) {
+  const path = getJobResourcePath(job, resourceKey, legacyKey);
+  if (path !== void 0) return path;
+  throw new TypeError(`Build job is missing ${resourceKey}`);
 }
 var init_output = __esm({
   "src/commands/queue/output.ts"() {
     "use strict";
     init_support();
     init_estimate();
+    init_node_platform();
   }
 });
 
 // src/commands/queue/add.ts
 import {
   addBuildJob,
-  listChapters as listChapters3
+  listChapters as listChapters4
 } from "wiki-graph-core";
-import { WikiGraphArchiveFile as WikiGraphArchiveFile3 } from "wiki-graph-core";
+import { WikiGraphArchiveFile as WikiGraphArchiveFile4 } from "wiki-graph-core";
 async function addChapterJob(args, chapterId) {
   return await addBuildJob({
-    archivePath: args.archivePath,
+    archive: new NodeFile(args.archivePath),
     boost: args.boost ?? false,
     chapterId,
     ...args.llmJSON === void 0 ? {} : { llmJSON: args.llmJSON },
@@ -6093,16 +7164,16 @@ async function addChapterJob(args, chapterId) {
 async function addArchiveJobs(args, config) {
   const created = [];
   const skipped = [];
-  await new WikiGraphArchiveFile3(args.archivePath).readDocument(
+  await new WikiGraphArchiveFile4(new NodeFile(args.archivePath)).readDocument(
     async (document) => {
       const chapterIdSet = args.chapterIds === void 0 ? void 0 : new Set(args.chapterIds);
-      for (const chapter of await listChapters3(document)) {
+      for (const chapter of await listChapters4(document)) {
         if (chapterIdSet !== void 0 && !chapterIdSet.has(chapter.chapterId)) {
           continue;
         }
         if (chapter.stage === "planned") {
           skipped.push({
-            chapterId: chapter.chapterId,
+            chapter,
             reason: "planned"
           });
           continue;
@@ -6112,7 +7183,7 @@ async function addArchiveJobs(args, config) {
           const summary = await document.readSummary(chapter.chapterId);
           if (summary === void 0 || summary.trim() === "") {
             skipped.push({
-              chapterId: chapter.chapterId,
+              chapter,
               reason: "missing summary"
             });
             continue;
@@ -6128,7 +7199,7 @@ async function addArchiveJobs(args, config) {
           );
           if (artifact?.sourceRevision !== revision) {
             skipped.push({
-              chapterId: chapter.chapterId,
+              chapter,
               reason: "missing current FTS index artifact"
             });
             continue;
@@ -6141,7 +7212,7 @@ async function addArchiveJobs(args, config) {
           });
         } catch (error) {
           skipped.push({
-            chapterId: chapter.chapterId,
+            chapter,
             reason: error instanceof Error ? error.message : String(error)
           });
         }
@@ -6149,6 +7220,7 @@ async function addArchiveJobs(args, config) {
     }
   );
   await writeArchiveAddSummary({
+    archivePath: args.archivePath,
     created,
     ...created.length === 0 ? {} : {
       estimate: createQueueAddEstimate({
@@ -6163,9 +7235,9 @@ async function addArchiveJobs(args, config) {
 }
 async function assertQueueAddReady(args, chapterId) {
   let chapter;
-  await new WikiGraphArchiveFile3(args.archivePath).readDocument(
+  await new WikiGraphArchiveFile4(new NodeFile(args.archivePath)).readDocument(
     async (document) => {
-      chapter = (await listChapters3(document)).find(
+      chapter = (await listChapters4(document)).find(
         (entry) => entry.chapterId === chapterId
       );
     }
@@ -6173,18 +7245,20 @@ async function assertQueueAddReady(args, chapterId) {
   if (chapter === void 0) {
     throw new Error(`Chapter ${chapterId} does not exist.`);
   }
-  await new WikiGraphArchiveFile3(args.archivePath).read(async (digest) => {
-    if (await digest.readChapterStage(chapterId) === "planned") {
-      throw new Error(
-        `Chapter ${chapter.uri} is planned. Set source before queueing a build job.`
-      );
+  await new WikiGraphArchiveFile4(new NodeFile(args.archivePath)).read(
+    async (digest) => {
+      if (await digest.readChapterStage(chapterId) === "planned") {
+        throw new Error(
+          `Chapter ${chapter.uri} is planned. Set source before queueing a build job.`
+        );
+      }
     }
-  });
+  );
   const target = args.target ?? "reading-summary";
   if (target !== "index-embedding-summary" && target !== "knowledge-graph" && target !== "reading-graph") {
     return;
   }
-  await new WikiGraphArchiveFile3(args.archivePath).readDocument(
+  await new WikiGraphArchiveFile4(new NodeFile(args.archivePath)).readDocument(
     async (document) => {
       if (target === "index-embedding-summary") {
         const summary = await document.readSummary(chapterId);
@@ -6208,9 +7282,9 @@ async function assertQueueAddReady(args, chapterId) {
 }
 async function readQueueAddChapter(args, chapterId) {
   let matched;
-  await new WikiGraphArchiveFile3(args.archivePath).readDocument(
+  await new WikiGraphArchiveFile4(new NodeFile(args.archivePath)).readDocument(
     async (document) => {
-      matched = (await listChapters3(document)).find(
+      matched = (await listChapters4(document)).find(
         (chapter) => chapter.chapterId === chapterId
       );
     }
@@ -6244,6 +7318,7 @@ var init_add = __esm({
     init_internal_child();
     init_estimate();
     init_output();
+    init_node_platform();
   }
 });
 
@@ -6252,7 +7327,7 @@ var chapter_exports = {};
 __export(chapter_exports, {
   runArchiveChapterCommand: () => runArchiveChapterCommand
 });
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { Readable } from "stream";
 import {
   addBuildJob as addBuildJob2,
@@ -6260,8 +7335,9 @@ import {
   applyChapterTree,
   assertNoActiveBuildJobConflicts,
   assertNoActiveBuildJobs,
+  formatLocatedChapterUri as formatLocatedChapterUri3,
   getChapterTree,
-  listChapters as listChapters4,
+  listChapters as listChapters5,
   moveChapter,
   parseChapterTreeInput,
   removeChapter,
@@ -6269,9 +7345,10 @@ import {
   resolveChapterPathReadonly as resolveChapterPathReadonly2,
   setChapterSource,
   setChapterSummary,
-  setChapterTitle
+  setChapterTitle,
+  parseSourceTextJsonl,
+  WikiGraphArchiveFile as WikiGraphArchiveFile5
 } from "wiki-graph-core";
-import { WikiGraphArchiveFile as WikiGraphArchiveFile4 } from "wiki-graph-core";
 async function runArchiveChapterCommand(args) {
   switch (args.action) {
     case "add":
@@ -6281,7 +7358,7 @@ async function runArchiveChapterCommand(args) {
           args.parentChapterPath
         );
         await assertNoActiveBuildJobConflicts({
-          archivePath: args.path,
+          archive: new NodeFile(args.path),
           operation: "Adding chapter",
           scope: { kind: "archive" }
         });
@@ -6296,13 +7373,15 @@ async function runArchiveChapterCommand(args) {
             Readable.from([await readRequiredSourceText(args)])
           );
         }
-        await writeChapterDetails(details, args.json ?? false);
+        await writeChapterDetails(details, args.json ?? false, {
+          locatedUri: formatChapterCommandUri(args.path, details.path)
+        });
       });
       return;
     case "list":
       await readArchiveDocument(args.path, async (document) => {
         await writeChapterList(
-          await listChapters4(document),
+          await listChapters5(document),
           args.json ?? false
         );
       });
@@ -6322,17 +7401,30 @@ async function runArchiveChapterCommand(args) {
       });
       return;
     case "build-index-artifact": {
-      const chapterId = await readArchiveDocument(
-        args.path,
-        async (document) => await resolveRequiredChapterPath(document, args.chapterPath)
-      );
+      const chapter = await readArchiveDocument(args.path, async (document) => {
+        const chapterId = await resolveRequiredChapterPath(
+          document,
+          args.chapterPath
+        );
+        const matched = (await listChapters5(document)).find(
+          (entry) => entry.chapterId === chapterId
+        );
+        if (matched === void 0) {
+          throw new Error(`Chapter internal id ${chapterId} does not exist.`);
+        }
+        return matched;
+      });
       const job = await addBuildJob2({
-        archivePath: args.path,
-        chapterId,
+        archive: new NodeFile(args.path),
+        chapterId: chapter.chapterId,
         target: requireIndexArtifactTarget(args.indexArtifactTarget)
       });
       tryStartQueueWorker();
-      await writeJobSummary(job, { json: args.json ?? false, watch: true });
+      await writeJobSummary(job, {
+        chapter,
+        json: args.json ?? false,
+        watch: true
+      });
       return;
     }
     case "delete-index-artifact":
@@ -6378,7 +7470,7 @@ async function runArchiveChapterCommand(args) {
           args.parentChapterPath
         );
         await assertNoActiveBuildJobConflicts({
-          archivePath: args.path,
+          archive: new NodeFile(args.path),
           operation: "Moving chapter",
           scope: { kind: "archive" }
         });
@@ -6400,7 +7492,7 @@ async function runArchiveChapterCommand(args) {
           args.chapterPath
         );
         await assertNoActiveBuildJobConflicts({
-          archivePath: args.path,
+          archive: new NodeFile(args.path),
           operation: "Removing chapter",
           scope: { kind: "archive" }
         });
@@ -6444,14 +7536,17 @@ async function runArchiveChapterCommand(args) {
           args.chapterPath
         );
         await assertNoActiveBuildJobs({
-          archivePath: args.path,
+          archive: new NodeFile(args.path),
           chapterIds: [chapterId],
           operation: "Setting chapter source"
         });
+        const sourceText = await readRequiredSourceText(args);
+        const parsed = args.inputFormat === "jsonl" ? parseSourceTextJsonl(sourceText) : void 0;
         const details = await setChapterSource(
           document,
           chapterId,
-          Readable.from([await readRequiredSourceText(args)])
+          Readable.from([parsed?.text ?? sourceText]),
+          parsed === void 0 ? {} : { provenance: parsed.provenance }
         );
         await writeChapterDetails(details, args.json ?? false);
       });
@@ -6463,7 +7558,7 @@ async function runArchiveChapterCommand(args) {
           args.chapterPath
         );
         await assertNoActiveBuildJobs({
-          archivePath: args.path,
+          archive: new NodeFile(args.path),
           chapterIds: [chapterId],
           operation: "Setting chapter summary",
           requiresTarget: "reading-summary"
@@ -6483,7 +7578,7 @@ async function runArchiveChapterCommand(args) {
           args.chapterPath
         );
         await assertNoActiveBuildJobs({
-          archivePath: args.path,
+          archive: new NodeFile(args.path),
           chapterIds: [chapterId],
           operation: "Setting chapter title"
         });
@@ -6502,7 +7597,7 @@ async function runArchiveChapterCommand(args) {
           async (document) => {
             if (args.dryRun !== true) {
               await assertNoActiveBuildJobConflicts({
-                archivePath: args.path,
+                archive: new NodeFile(args.path),
                 operation: "Changing chapter tree",
                 scope: { kind: "archive" }
               });
@@ -6599,7 +7694,7 @@ function formatIndexArtifactKind(kind) {
 async function runEditableCommand(path, operation, options = {}) {
   if (options.markLibraryDirty === false) {
     const location = await resolveArchiveRuntimeLocation(path);
-    await new WikiGraphArchiveFile4(location.archivePath).write(operation);
+    await new WikiGraphArchiveFile5(location.archiveFile).write(operation);
     return;
   }
   await writeArchiveDocument(path, operation);
@@ -6619,7 +7714,7 @@ async function readContentText(args) {
     return content;
   }
   if (args.inputPath !== void 0) {
-    return await readFile(args.inputPath, "utf8");
+    return await readFile2(args.inputPath, "utf8");
   }
   throw new Error(
     "Missing input. Pass a positional value, use --input <path>, or use --input - for stdin."
@@ -6629,18 +7724,19 @@ async function readRequiredSourceText(args) {
   const content = await readContentText(args);
   if (content.trim() === "") {
     throw new Error(
-      "Source input is empty. Pass non-empty text with --input <path> or --input -."
+      "Source input is empty. Pass non-empty positional text, use --input <path>, or use --input - for stdin."
     );
   }
   return content;
 }
-async function writeChapterDetails(details, json) {
+async function writeChapterDetails(details, json, options = {}) {
   if (json) {
     await writeTextToStdout(
       formatCLIJSON({
         childCount: details.childCount,
         graphReady: details.graphReady,
         hasSummary: details.hasSummary,
+        ...options.locatedUri === void 0 ? {} : { locatedUri: options.locatedUri },
         sourceUnits: details.fragmentCount,
         stage: formatStage(details.stage),
         title: details.title,
@@ -6651,6 +7747,7 @@ async function writeChapterDetails(details, json) {
   }
   const lines = [
     `Chapter: ${details.uri}`,
+    ...options.locatedUri === void 0 ? [] : [`Located URI: ${options.locatedUri}`],
     `Title: ${details.title ?? "[untitled]"}`,
     `Stage: ${formatStage(details.stage)}`,
     `Source Units: ${details.fragmentCount}`,
@@ -6661,6 +7758,18 @@ async function writeChapterDetails(details, json) {
   await writeTextToStdout(`${lines.join("\n")}
 `);
 }
+function formatChapterCommandUri(archiveLocator, chapterPath) {
+  if (archiveLocator.startsWith("wikg://lib/")) {
+    return `${archiveLocator.replace(/\/+$/u, "")}/chapter/${chapterPath}`;
+  }
+  if (archiveLocator.startsWith("wikg://")) {
+    const parsed = parseLocatedWikiGraphUri(archiveLocator);
+    if (parsed.archivePath !== void 0) {
+      return formatLocatedChapterUri3(parsed.archivePath, chapterPath);
+    }
+  }
+  return formatLocatedChapterUri3(archiveLocator, chapterPath);
+}
 async function writeChapterList(entries, json) {
   if (json) {
     await writeTextToStdout(
@@ -6723,9 +7832,9 @@ async function writeChapterTreeApplyResult(result, dryRun) {
       `Move ${move.oldUri} [index ${move.oldIndex}] -> ${move.newUri} [index ${move.newIndex}]`
     );
   }
-  for (const rename2 of result.renamed) {
+  for (const rename3 of result.renamed) {
     lines.push(
-      `Rename ${rename2.uri}: ${formatTitle(rename2.oldTitle)} -> ${formatTitle(rename2.newTitle)}`
+      `Rename ${rename3.uri}: ${formatTitle(rename3.oldTitle)} -> ${formatTitle(rename3.newTitle)}`
     );
   }
   await writeTextToStdout(`${lines.join("\n")}
@@ -6750,20 +7859,20 @@ async function assertResetAllowed(archivePath, chapterId, stage) {
   switch (stage) {
     case "planned":
       await assertNoActiveBuildJobs({
-        archivePath,
+        archive: new NodeFile(archivePath),
         chapterIds: [chapterId],
         operation: "Resetting chapter to planned"
       });
       return;
     case "sourced":
       await assertNoActiveBuildJobs({
-        archivePath,
+        archive: new NodeFile(archivePath),
         chapterIds: [chapterId],
         operation: "Resetting chapter graph",
         requiresTarget: "reading-graph"
       });
       await assertNoActiveBuildJobs({
-        archivePath,
+        archive: new NodeFile(archivePath),
         chapterIds: [chapterId],
         operation: "Resetting chapter summary",
         requiresTarget: "reading-summary"
@@ -6771,7 +7880,7 @@ async function assertResetAllowed(archivePath, chapterId, stage) {
       return;
     case "graphed":
       await assertNoActiveBuildJobs({
-        archivePath,
+        archive: new NodeFile(archivePath),
         chapterIds: [chapterId],
         operation: "Resetting chapter summary",
         requiresTarget: "reading-summary"
@@ -6782,12 +7891,13 @@ async function assertResetAllowed(archivePath, chapterId, stage) {
 var init_chapter = __esm({
   "src/commands/archive-command/chapter.ts"() {
     "use strict";
+    init_node_platform();
     init_support();
     init_support();
     init_add();
     init_output();
     init_document();
-    init_uri2();
+    init_uri3();
   }
 });
 
@@ -6802,7 +7912,7 @@ import {
   listArchiveQueryableChapterIds as listArchiveQueryableChapterIds2,
   readSearchIndexCapabilityStatus,
   rebuildArchiveSearchIndex as rebuildArchiveSearchIndex2,
-  WikiGraphArchiveFile as WikiGraphArchiveFile5
+  WikiGraphArchiveFile as WikiGraphArchiveFile6
 } from "wiki-graph-core";
 async function runArchiveIndexCommand(args) {
   switch (args.action) {
@@ -6819,7 +7929,7 @@ async function runArchiveIndexCommand(args) {
 }
 async function readIndexCache(args) {
   const location = await resolveArchiveRuntimeLocation(args.archivePath);
-  await new WikiGraphArchiveFile5(location.archivePath).readDocument(
+  await new WikiGraphArchiveFile6(location.archiveFile).readDocument(
     async (document) => {
       await writeIndexOutput(args, {
         capabilities: await readSearchIndexCapabilityStatus(document),
@@ -6834,7 +7944,7 @@ async function syncIndexCache(args) {
     jsonl: args.jsonl ?? false,
     throttleMs: INDEX_PROGRESS_OUTPUT_INTERVAL_MS
   });
-  await new WikiGraphArchiveFile5(location.archivePath).write(
+  await new WikiGraphArchiveFile6(location.archiveFile).write(
     async (document) => {
       await writer.write({
         json: { type: "started" },
@@ -6893,7 +8003,7 @@ async function syncIndexCache(args) {
 }
 async function cleanIndexCache(args) {
   const location = await resolveArchiveRuntimeLocation(args.archivePath);
-  await new WikiGraphArchiveFile5(location.archivePath).write(
+  await new WikiGraphArchiveFile6(location.archiveFile).write(
     async (document) => {
       await document.deleteSearchIndexDatabase();
       await writeIndexOutput(args, {
@@ -6973,7 +8083,7 @@ var init_search_index = __esm({
     init_support();
     init_support();
     init_runtime();
-    init_uri2();
+    init_uri3();
     INDEX_PROGRESS_OUTPUT_INTERVAL_MS = 6e3;
   }
 });
@@ -6992,7 +8102,7 @@ async function runArchiveMetaCommand(args) {
   }
   const app = new WikiGraph2({});
   const location = await resolveArchiveRuntimeLocation(args.inputPath);
-  await app.openSession(location.archivePath, async (digest) => {
+  await app.openSession(new NodeFile(location.archivePath), async (digest) => {
     await writeArchiveMeta(await digest.readMeta(), {
       json: args.json ?? false
     });
@@ -7001,7 +8111,7 @@ async function runArchiveMetaCommand(args) {
 async function runArchiveCoverCommand(args) {
   const app = new WikiGraph2({});
   const location = await resolveArchiveRuntimeLocation(args.inputPath);
-  await app.openSession(location.archivePath, async (digest) => {
+  await app.openSession(new NodeFile(location.archivePath), async (digest) => {
     if (process.stdout.isTTY === true) {
       throw new Error(
         "Refusing to write binary cover data to an interactive terminal. Redirect stdout or pipe it."
@@ -7081,7 +8191,8 @@ var init_maintenance = __esm({
     init_support();
     init_support();
     init_document();
-    init_uri2();
+    init_uri3();
+    init_node_platform();
   }
 });
 
@@ -7144,28 +8255,51 @@ var legacy_exports = {};
 __export(legacy_exports, {
   runLegacyCommand: () => runLegacyCommand
 });
-import { upgradeWikiGraphMaintenanceTarget } from "wiki-graph-core";
+import { migrateLegacySdpubToWikg } from "wiki-graph-core";
+import { resolve as resolve6 } from "path";
 async function runLegacyCommand(args) {
   switch (args.action) {
     case "migrate": {
       process.stderr.write(
         "`wg legacy migrate` is deprecated. Use `wg maintenance upgrade <sdpub-path>`.\n"
       );
-      const result = await upgradeWikiGraphMaintenanceTarget(args.inputPath, {
-        ...args.outputPath === void 0 ? {} : { outputPath: args.outputPath }
-      });
-      if (result.kind !== "sdpub") {
-        throw new Error("Legacy migrate only supports sdpub inputs.");
-      }
-      process.stdout.write(`Wrote ${result.outputPath}
+      const outputPath = resolve6(
+        args.outputPath ?? defaultWikgOutputPath(args.inputPath)
+      );
+      await migrateLegacySdpubToWikg(
+        new NodeFile(resolve6(args.inputPath)),
+        new NodeFile(outputPath)
+      );
+      process.stdout.write(`Wrote ${outputPath}
 `);
       return;
     }
   }
 }
+function defaultWikgOutputPath(inputPath) {
+  return inputPath.toLowerCase().endsWith(".sdpub") ? `${inputPath.slice(0, -".sdpub".length)}.wikg` : `${inputPath}.wikg`;
+}
 var init_legacy = __esm({
   "src/commands/legacy.ts"() {
     "use strict";
+    init_node_platform();
+  }
+});
+
+// src/runtime/home-target.ts
+import { homedir as homedir4 } from "os";
+import { join as join7, resolve as resolve7 } from "path";
+function isWikiGraphHomeTarget(target) {
+  if (target === "home" || target === "~/.wikigraph") return true;
+  const configuredHome = resolve7(
+    getCLIStateDir() ?? join7(homedir4(), ".wikigraph")
+  );
+  return resolve7(getCLICwd(), target) === configuredHome;
+}
+var init_home_target = __esm({
+  "src/runtime/home-target.ts"() {
+    "use strict";
+    init_context();
   }
 });
 
@@ -7175,14 +8309,21 @@ __export(maintenance_exports2, {
   runMaintenanceCommand: () => runMaintenanceCommand
 });
 import {
-  upgradeWikiGraphMaintenanceTarget as upgradeWikiGraphMaintenanceTarget2
+  parseWikiGraphLibraryUri as parseWikiGraphLibraryUri7,
+  upgradeWikiGraphMaintenanceTarget
 } from "wiki-graph-core";
+import { resolve as resolve8 } from "path";
 async function runMaintenanceCommand(args) {
   switch (args.action) {
     case "upgrade": {
-      const result = await upgradeWikiGraphMaintenanceTarget2(args.target, {
-        ...args.outputPath === void 0 ? {} : { outputPath: args.outputPath }
-      });
+      if (args.outputPath !== void 0 || args.target.endsWith(".sdpub")) {
+        throw new Error(
+          "Legacy sdpub migration is available through `wg legacy migrate`."
+        );
+      }
+      const result = await upgradeWikiGraphMaintenanceTarget(
+        parseMaintenanceTarget(args.target)
+      );
       await writeTextToStdout(
         args.json === true ? formatCLIJSON(result) : formatMaintenanceUpgradeResult(result)
       );
@@ -7193,13 +8334,10 @@ async function runMaintenanceCommand(args) {
 function formatMaintenanceUpgradeResult(result) {
   switch (result.kind) {
     case "home":
-      return `Home ${result.status}: ${result.path} (schema v${result.schemaVersionBefore} -> v${result.schemaVersionAfter})
+      return `Home ${result.status} (schema v${result.schemaVersionBefore} -> v${result.schemaVersionAfter})
 `;
     case "archive":
-      return `Archive ${result.status}: ${result.path} (schema v${result.schemaVersionBefore} -> v${result.schemaVersionAfter})
-`;
-    case "sdpub":
-      return `Wrote ${result.outputPath}
+      return `Archive ${result.status}: ${result.fileName} (schema v${result.schemaVersionBefore} -> v${result.schemaVersionAfter})
 `;
     case "lib": {
       const lines = [
@@ -7215,10 +8353,28 @@ function formatMaintenanceUpgradeResult(result) {
     }
   }
 }
+function parseMaintenanceTarget(target) {
+  if (isWikiGraphHomeTarget(target)) {
+    return { kind: "home" };
+  }
+  if (target.startsWith("wikg://lib")) {
+    const parsed = parseWikiGraphLibraryUri7(target);
+    if (parsed === void 0 || parsed.kind === "archive") {
+      throw new Error(`Invalid Wiki Graph library upgrade target: ${target}`);
+    }
+    return { kind: "library", target: parsed };
+  }
+  if (!target.endsWith(".wikg")) {
+    throw new Error(`Unsupported maintenance upgrade target: ${target}`);
+  }
+  return { file: new NodeFile(resolve8(target)), kind: "archive" };
+}
 var init_maintenance2 = __esm({
   "src/commands/maintenance.ts"() {
     "use strict";
+    init_home_target();
     init_support();
+    init_node_platform();
   }
 });
 
@@ -7228,7 +8384,7 @@ __export(local_config_exports, {
   mergeMaskedSecretsForSet: () => mergeMaskedSecretsForSet,
   runLocalConfigCommand: () => runLocalConfigCommand
 });
-import { Writable } from "stream";
+import { Writable as Writable2 } from "stream";
 import { createInterface } from "readline/promises";
 import { generateText } from "ai";
 import {
@@ -7418,7 +8574,8 @@ async function runWikispineConfigTest(args) {
   try {
     const provider = parseWikispineProvider(wikispine.provider);
     const result = await testWikispineRuntime({
-      provider
+      provider,
+      ...provider === "cli" ? { commandRunner: nodeWikispineCommandRunner } : {}
     });
     const output = {
       durationMs: result.durationMs,
@@ -7552,7 +8709,7 @@ async function readSecretValue(key) {
   if (process.stdin.isTTY !== true) {
     throw new Error(`${key} requires an interactive terminal.`);
   }
-  const mutedOutput = new Writable({
+  const mutedOutput = new Writable2({
     write(_chunk, _encoding, callback) {
       callback();
     }
@@ -7578,6 +8735,7 @@ var init_local_config2 = __esm({
   "src/commands/local-config.ts"() {
     "use strict";
     init_llm();
+    init_wikispine();
     init_embedding();
     init_context();
     init_support();
@@ -7591,7 +8749,7 @@ var library_exports = {};
 __export(library_exports, {
   runLibraryCommand: () => runLibraryCommand
 });
-import { readFile as readFile2 } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile3 } from "fs/promises";
 import {
   addWikiGraphLibraryArchive,
   assertWikiGraphLibrarySchemaCurrent,
@@ -7627,7 +8785,7 @@ async function runLibraryCommand(args) {
       }
       await writeLibraryArchive(
         await addWikiGraphLibraryArchive({
-          inputPath: args.inputPath,
+          inputFile: new NodeFile(args.inputPath),
           target: args.target,
           ...args.to === void 0 ? {} : { to: args.to }
         }),
@@ -7639,7 +8797,10 @@ async function runLibraryCommand(args) {
       if (args.path === void 0) {
         throw new Error("Missing --path <folder> for library create.");
       }
-      const library = await createWikiGraphLibrary({ folderPath: args.path });
+      await mkdir2(args.path);
+      const library = await createWikiGraphLibrary({
+        folder: new NodeDirectory(args.path)
+      });
       await writeLibrary(library, args.json ?? false);
       return;
     }
@@ -7678,7 +8839,7 @@ async function runLibraryCommand(args) {
       await writeScanResult(
         "path set",
         async () => await rebindWikiGraphLibrary({
-          folderPath,
+          folder: new NodeDirectory(folderPath),
           target: args.target
         }),
         args.json ?? false,
@@ -7865,9 +9026,9 @@ async function writeLibrary(library, json) {
       formatCLIJSON({
         uri: library.uri,
         id: library.publicId,
-        folderPath: library.folderPath,
+        folderPath: getNodeResourcePath(library.folder),
         isDefault: library.isDefault,
-        stagingPath: library.stagingPath,
+        stagingPath: getNodeResourcePath(library.staging),
         createdAt: library.createdAt,
         updatedAt: library.updatedAt
       })
@@ -7884,7 +9045,7 @@ async function writeLibraries(libraries, json) {
         items: libraries.map((library) => ({
           uri: library.uri,
           id: library.publicId,
-          path: library.folderPath,
+          path: getNodeResourcePath(library.folder),
           isDefault: library.isDefault
         }))
       })
@@ -7896,7 +9057,7 @@ async function writeLibraries(libraries, json) {
       (library) => [
         library.uri,
         library.publicId,
-        library.folderPath,
+        getNodeResourcePath(library.folder),
         library.isDefault ? "default" : ""
       ].join("	")
     ).join("\n") + (libraries.length === 0 ? "" : "\n")
@@ -7905,11 +9066,14 @@ async function writeLibraries(libraries, json) {
 async function writeLibraryPath(library, json) {
   if (json) {
     await writeTextToStdout(
-      formatCLIJSON({ uri: `${library.uri}/path`, path: library.folderPath })
+      formatCLIJSON({
+        uri: `${library.uri}/path`,
+        path: getNodeResourcePath(library.folder)
+      })
     );
     return;
   }
-  await writeTextToStdout(`${library.folderPath}
+  await writeTextToStdout(`${getNodeResourcePath(library.folder)}
 `);
 }
 async function writeLibraryArchivePath(archive, json) {
@@ -8019,7 +9183,7 @@ async function writeLibraryArchivePage(archive, json) {
       `Entity: ${archive.uri}/entity`,
       `Triple: ${archive.uri}/triple`,
       `Inspect: ${archive.uri} inspect`,
-      `Metadata path: ${archive.path}`,
+      `Metadata path: ${formatArchiveHostPath(archive)}`,
       ""
     ].join("\n")
   );
@@ -8030,7 +9194,7 @@ function formatLibraryArchiveJSON(archive) {
     id: archive.publicId,
     libraryUri: archive.libraryUri,
     relativePath: archive.relativePath,
-    path: archive.path,
+    path: formatArchiveHostPath(archive),
     exists: archive.exists,
     status: archive.status,
     lastSeenMutationToken: archive.lastSeenMutationToken,
@@ -8056,7 +9220,7 @@ function formatLibraryArchivePageJSON(archive) {
       inspect: `${archive.uri} inspect`
     },
     metadata: {
-      path: archive.path,
+      path: formatArchiveHostPath(archive),
       exists: archive.exists,
       lastSeenMutationToken: archive.lastSeenMutationToken,
       lastSeenSize: archive.lastSeenSize,
@@ -8195,7 +9359,7 @@ async function readRawInput(args) {
     return content;
   }
   if (args.inputPath !== void 0) {
-    return await readFile2(args.inputPath, "utf8");
+    return await readFile3(args.inputPath, "utf8");
   }
   throw new Error(
     "Missing input. Pass a value, use --input <path>, or use --input - for stdin."
@@ -8242,12 +9406,16 @@ function formatMetadataTextValue(value) {
   }
   return String(value);
 }
+function formatArchiveHostPath(archive) {
+  return archive.file === void 0 ? archive.relativePath : getNodeResourcePath(archive.file);
+}
 var INDEX_PROGRESS_OUTPUT_INTERVAL_MS2;
 var init_library = __esm({
   "src/commands/library.ts"() {
     "use strict";
     init_support();
     init_run();
+    init_node_platform();
     init_archive_output();
     init_runtime();
     INDEX_PROGRESS_OUTPUT_INTERVAL_MS2 = 6e3;
@@ -8259,15 +9427,15 @@ var object_metadata_exports = {};
 __export(object_metadata_exports, {
   runObjectMetadataCommand: () => runObjectMetadataCommand
 });
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 import { ObjectMetadataKind } from "wiki-graph-core";
-import { WikiGraphArchiveFile as WikiGraphArchiveFile6 } from "wiki-graph-core";
+import { WikiGraphArchiveFile as WikiGraphArchiveFile7 } from "wiki-graph-core";
 async function runObjectMetadataCommand(args) {
   const target = parseObjectMetadataTarget(args.objectPath);
   switch (args.action) {
     case "get": {
       const location = await resolveArchiveRuntimeLocation(args.archivePath);
-      await new WikiGraphArchiveFile6(location.archivePath).readDocument(
+      await new WikiGraphArchiveFile7(location.archiveFile).readDocument(
         async (document) => {
           await writeMetadataMap2(
             await document.metadata.getMap(args.objectPath),
@@ -8354,7 +9522,7 @@ async function readRawInput2(args) {
     return content;
   }
   if (args.inputPath !== void 0) {
-    return await readFile3(args.inputPath, "utf8");
+    return await readFile4(args.inputPath, "utf8");
   }
   throw new Error(
     "Missing input. Pass a value, use --input <path>, or use --input - for stdin."
@@ -8453,7 +9621,7 @@ var init_object_metadata = __esm({
   "src/commands/object-metadata.ts"() {
     "use strict";
     init_document();
-    init_uri2();
+    init_uri3();
     init_support();
     init_support();
   }
@@ -8644,23 +9812,33 @@ import {
   runBuildJobWorker,
   snapshotChapterKnowledgeGraphInput,
   snapshotChapterSummaryInput,
-  writeIndexArtifactOutput
+  writeIndexArtifactOutput,
+  ensureRelativeFile
 } from "wiki-graph-core";
-import { WikiGraphArchiveFile as WikiGraphArchiveFile7 } from "wiki-graph-core";
-import { join as join5 } from "path";
+import { WikiGraphArchiveFile as WikiGraphArchiveFile8 } from "wiki-graph-core";
 async function runQueueWorker() {
   const config = await loadCLIConfig();
-  await runBuildJobWorker({
-    concurrency: config.concurrent?.job ?? DEFAULT_GENERATION_JOB_CONCURRENCY,
-    executeJob: async (job, reporter, context) => {
-      await executeBuildJob(job, reporter, context);
-    }
-  });
+  const controller = new AbortController();
+  const stop = () => controller.abort();
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  try {
+    await runBuildJobWorker({
+      concurrency: config.concurrent?.job ?? DEFAULT_GENERATION_JOB_CONCURRENCY,
+      executeJob: async (job, reporter, context) => {
+        await executeBuildJob(job, reporter, context);
+      },
+      signal: controller.signal
+    });
+  } finally {
+    process.removeListener("SIGINT", stop);
+    process.removeListener("SIGTERM", stop);
+  }
 }
 async function executeBuildJob(job, reporter, context) {
   await withLoggingContext(
     {
-      logDirPath: job.logPath,
+      logDirectory: job.log,
       operation: "build-job"
     },
     async () => {
@@ -8680,8 +9858,8 @@ async function executeGenerationBuildJob(job, reporter, context) {
     ...job.llmJSON === void 0 ? {} : { llmJSON: job.llmJSON }
   });
   const llm = createStageLLM(config, {
-    cacheDirPath: job.cachePath,
-    logDirPath: job.logPath,
+    cacheDirectory: job.cache,
+    logDirectory: job.log,
     onStreamProgress: async (event) => {
       await reporter.addOutputCharacters(event.outputCharacters);
     },
@@ -8703,9 +9881,7 @@ async function executeGenerationBuildJob(job, reporter, context) {
     signal: context.signal
   });
   request.lazy = async (operation) => await llm.request(async () => await operation(request));
-  const buildInput = await new WikiGraphArchiveFile7(
-    job.archivePath
-  ).readDocument(
+  const buildInput = await new WikiGraphArchiveFile8(job.archive).readDocument(
     async (document) => await readChapterBuildInput(document, job.chapterId)
   );
   let { details } = buildInput;
@@ -8725,7 +9901,7 @@ async function executeGenerationBuildJob(job, reporter, context) {
     );
   }
   if (job.target === "knowledge-graph" || job.target === "reading-graph") {
-    await new WikiGraphArchiveFile7(job.archivePath).readDocument(
+    await new WikiGraphArchiveFile8(job.archive).readDocument(
       async (document) => {
         const artifact = await document.indexArtifacts.get(
           job.chapterId,
@@ -8742,8 +9918,8 @@ async function executeGenerationBuildJob(job, reporter, context) {
   if (job.target === "knowledge-graph") {
     const wikispine = requireKnowledgeGraphWikispineConfig(config);
     await reporter.stepStarted("knowledge-graph");
-    const knowledgeGraphInput = await new WikiGraphArchiveFile7(
-      job.archivePath
+    const knowledgeGraphInput = await new WikiGraphArchiveFile8(
+      job.archive
     ).readDocument(async (document) => {
       await assertCurrentBuildInputRevision(job, document);
       return await snapshotChapterKnowledgeGraphInput(document, job.chapterId);
@@ -8756,11 +9932,14 @@ async function executeGenerationBuildJob(job, reporter, context) {
         progressTracker: reporter,
         request,
         resolverOptions: {
-          logDirPath: job.logPath,
+          logDirectory: job.log,
           normalizer: createDisambiguationProfileNormalizer({ request })
         },
-        wikispine,
-        workspacePath: job.workspacePath
+        wikispine: {
+          ...wikispine,
+          ...wikispine.provider === "cli" ? { commandRunner: nodeWikispineCommandRunner } : {}
+        },
+        workspace: job.workspace
       }
     );
     await reporter.updatePhase({
@@ -8769,7 +9948,7 @@ async function executeGenerationBuildJob(job, reporter, context) {
       total: 1,
       unit: "item"
     });
-    await new WikiGraphArchiveFile7(job.archivePath).write(async (document) => {
+    await new WikiGraphArchiveFile8(job.archive).write(async (document) => {
       assertJobStillRunning(await getBuildJob2(job.jobId));
       await assertCurrentBuildInputRevision(job, document);
       await commitChapterKnowledgeGraphArtifact(document, artifact);
@@ -8791,7 +9970,7 @@ async function executeGenerationBuildJob(job, reporter, context) {
       extractionPrompt,
       llm,
       sourceText,
-      workspacePath: job.workspacePath,
+      workspace: job.workspace,
       progressTracker: {
         async advance(wordsCount) {
           graphWords += wordsCount;
@@ -8810,7 +9989,7 @@ async function executeGenerationBuildJob(job, reporter, context) {
       total: 1,
       unit: "item"
     });
-    details = await new WikiGraphArchiveFile7(job.archivePath).write(
+    details = await new WikiGraphArchiveFile8(job.archive).write(
       async (document) => {
         assertJobStillRunning(await getBuildJob2(job.jobId));
         await assertCurrentBuildInputRevision(job, document);
@@ -8823,8 +10002,8 @@ async function executeGenerationBuildJob(job, reporter, context) {
       total: 1,
       unit: "item"
     });
-    const nextBuildInput = await new WikiGraphArchiveFile7(
-      job.archivePath
+    const nextBuildInput = await new WikiGraphArchiveFile8(
+      job.archive
     ).readDocument(
       async (document) => await readChapterBuildInput(document, job.chapterId)
     );
@@ -8843,7 +10022,7 @@ async function executeGenerationBuildJob(job, reporter, context) {
     return;
   }
   if (details.stage !== "graphed") {
-    ({ details } = await new WikiGraphArchiveFile7(job.archivePath).readDocument(
+    ({ details } = await new WikiGraphArchiveFile8(job.archive).readDocument(
       async (document) => await readChapterBuildInput(document, job.chapterId)
     ));
   }
@@ -8853,20 +10032,20 @@ async function executeGenerationBuildJob(job, reporter, context) {
     );
   }
   await reporter.stepStarted("reading-summary");
-  const summaryInput = await new WikiGraphArchiveFile7(
-    job.archivePath
-  ).readDocument(async (document) => {
-    await assertCurrentBuildInputRevision(job, document);
-    return await snapshotChapterSummaryInput(
-      document,
-      job.chapterId,
-      job.workspacePath
-    );
-  });
+  const summaryInput = await new WikiGraphArchiveFile8(job.archive).readDocument(
+    async (document) => {
+      await assertCurrentBuildInputRevision(job, document);
+      return await snapshotChapterSummaryInput(
+        document,
+        job.chapterId,
+        job.workspace
+      );
+    }
+  );
   const summary = await buildChapterSummaryArtifactFromSnapshot(job.chapterId, {
     llm,
-    snapshotPath: summaryInput.filePath,
-    workspacePath: job.workspacePath
+    snapshotFile: summaryInput.file,
+    workspace: job.workspace
   });
   await reporter.updatePhase({
     done: 0,
@@ -8874,7 +10053,7 @@ async function executeGenerationBuildJob(job, reporter, context) {
     total: 1,
     unit: "item"
   });
-  details = await new WikiGraphArchiveFile7(job.archivePath).write(
+  details = await new WikiGraphArchiveFile8(job.archive).write(
     async (document) => {
       assertJobStillRunning(await getBuildJob2(job.jobId));
       await assertCurrentBuildInputRevision(job, document);
@@ -8910,9 +10089,9 @@ async function executeIndexArtifactBuildJob(job, reporter, context) {
     unit: "item"
   });
   if (job.target === "index-fts") {
-    const outputPath2 = resolveIndexArtifactOutputPath(job);
+    const outputFile2 = await resolveIndexArtifactOutputFile(job);
     await writeIndexArtifactOutput(
-      outputPath2,
+      outputFile2,
       createFtsIndexArtifactInput({
         chapterTitles: snapshot.chapterTitles,
         chunks: snapshot.chunks,
@@ -8923,12 +10102,12 @@ async function executeIndexArtifactBuildJob(job, reporter, context) {
         summarySentences: snapshot.summarySentences
       })
     );
-    const artifact2 = await readIndexArtifactOutput(outputPath2);
+    const artifact2 = await readIndexArtifactOutput(outputFile2);
     assertIndexArtifactOutputMatchesJob(job, snapshot.revision, artifact2);
     if (!("lexicalRows" in artifact2)) {
       throw new Error("Index artifact output is not an FTS artifact.");
     }
-    await new WikiGraphArchiveFile7(job.archivePath).write(async (document) => {
+    await new WikiGraphArchiveFile8(job.archive).write(async (document) => {
       assertJobStillRunning(await getBuildJob2(job.jobId));
       await assertJobChapterExists(document, job.chapterId);
       await assertCurrentBuildInputRevision(job, document);
@@ -8946,7 +10125,7 @@ async function executeIndexArtifactBuildJob(job, reporter, context) {
       )
     );
   }
-  const outputPath = resolveIndexArtifactOutputPath(job);
+  const outputFile = await resolveIndexArtifactOutputFile(job);
   const artifact = await createEmbeddingIndexArtifactInput({
     embeddingProvider: buildSearchIndexEmbeddingProvider(config.embedding),
     kind: job.target === "index-embedding-source" ? "embedding-source" : "embedding-summary",
@@ -8955,13 +10134,13 @@ async function executeIndexArtifactBuildJob(job, reporter, context) {
     signal: context.signal,
     sourceRevision: snapshot.revision
   });
-  await writeIndexArtifactOutput(outputPath, artifact);
-  const output = await readIndexArtifactOutput(outputPath);
+  await writeIndexArtifactOutput(outputFile, artifact);
+  const output = await readIndexArtifactOutput(outputFile);
   assertIndexArtifactOutputMatchesJob(job, snapshot.revision, output);
   if ("lexicalRows" in output) {
     throw new Error("Index artifact output is not an embedding artifact.");
   }
-  await new WikiGraphArchiveFile7(job.archivePath).write(async (document) => {
+  await new WikiGraphArchiveFile8(job.archive).write(async (document) => {
     assertJobStillRunning(await getBuildJob2(job.jobId));
     await assertJobChapterExists(document, job.chapterId);
     await assertCurrentBuildInputRevision(job, document);
@@ -8980,7 +10159,7 @@ async function completeIndexArtifactStep(job, reporter) {
   assertJobStillRunning(await getBuildJob2(job.jobId));
 }
 async function readIndexArtifactJobSnapshot(job) {
-  return await new WikiGraphArchiveFile7(job.archivePath).readDocument(
+  return await new WikiGraphArchiveFile8(job.archive).readDocument(
     async (document) => {
       await assertJobChapterExists(document, job.chapterId);
       const revision = await document.serials.getRevision(job.chapterId);
@@ -9043,8 +10222,8 @@ async function readChapterTitles(document, serialId) {
 function collectTocItems(items) {
   return items.flatMap((item) => [item, ...collectTocItems(item.children)]);
 }
-function resolveIndexArtifactOutputPath(job) {
-  return join5(job.workspacePath, "index-artifact-output.jsonl");
+async function resolveIndexArtifactOutputFile(job) {
+  return await ensureRelativeFile(job.workspace, "index-artifact-output.jsonl");
 }
 function assertIndexArtifactOutputMatchesJob(job, inputRevision, artifact) {
   if (artifact.serialId !== job.chapterId) {
@@ -9124,6 +10303,7 @@ var init_worker = __esm({
     init_runtime();
     init_embedding();
     init_support();
+    init_wikispine();
   }
 });
 
@@ -9137,7 +10317,7 @@ import {
   boostBuildJob,
   cancelBuildJob,
   cleanBuildJobs,
-  formatLocatedChapterUri as formatLocatedChapterUri2,
+  formatLocatedChapterUri as formatLocatedChapterUri4,
   formatLocatedWikiGraphUri as formatLocatedWikiGraphUri4,
   getBuildJob as getBuildJob3,
   listBuildJobs,
@@ -9146,7 +10326,7 @@ import {
   resolveBuildJobId,
   resumeBuildJob,
   updateBuildJobTarget,
-  WikiGraphArchiveFile as WikiGraphArchiveFile8
+  WikiGraphArchiveFile as WikiGraphArchiveFile9
 } from "wiki-graph-core";
 async function runQueueCommand(args) {
   switch (args.action) {
@@ -9184,6 +10364,7 @@ async function runQueueCommand(args) {
           target: args.target ?? "reading-summary"
         });
         await writeJobSummary(await addChapterJob(args, chapterId), {
+          chapter,
           estimate,
           json: args.json ?? false,
           watch: true
@@ -9199,7 +10380,7 @@ async function runQueueCommand(args) {
         await listBuildJobs({
           ...args.activeOnly === void 0 ? {} : { activeOnly: args.activeOnly },
           ...args.all === void 0 ? {} : { all: args.all },
-          ...args.archivePath === void 0 ? {} : { archivePath: args.archivePath }
+          ...args.archivePath === void 0 ? {} : { archive: new NodeFile(args.archivePath) }
         }),
         { json: args.json ?? false }
       );
@@ -9262,7 +10443,7 @@ async function resolveQueueChapterIds(args) {
     return void 0;
   }
   let chapterIds;
-  await new WikiGraphArchiveFile8(args.archivePath).readDocument(
+  await new WikiGraphArchiveFile9(new NodeFile(args.archivePath)).readDocument(
     async (document) => {
       if (args.chapterPath === void 0) {
         chapterIds = (await resolveArchiveChapterScope(document, {
@@ -9275,7 +10456,7 @@ async function resolveQueueChapterIds(args) {
         return;
       }
       chapterIds = (await resolveArchiveChapterScope(document, {
-        archivePath: formatLocatedChapterUri2(
+        archivePath: formatLocatedChapterUri4(
           args.archivePath,
           args.chapterPath
         ),
@@ -9299,6 +10480,7 @@ var init_queue = __esm({
     init_watch();
     init_worker();
     init_scope();
+    init_node_platform();
     init_worker();
   }
 });
@@ -9307,8 +10489,8 @@ var init_queue = __esm({
 export * from "wiki-graph-core";
 
 // src/app/runner.ts
-import { Readable as Readable2, Writable as Writable2 } from "stream";
-import { withWikiGraphRuntimeStateDirectoryPath } from "wiki-graph-core";
+init_node_platform();
+import { Readable as Readable2, Writable as Writable3 } from "stream";
 
 // src/args/help.ts
 init_support();
@@ -9316,7 +10498,6 @@ init_support();
 init_support();
 import {
   formatWikiGraphLibraryUri,
-  parseLocatedWikiGraphUri,
   parseWikiGraphLibraryUri,
   resolveDataDirPath
 } from "wiki-graph-core";
@@ -9435,6 +10616,9 @@ function parseChapterTarget(objectUri) {
       kind: "chapter-index-artifact"
     };
   }
+  if (suffix === "source/locators") {
+    return { chapterPath, kind: "source-locator-scope" };
+  }
   const resource = parseChapterResourceSuffix(suffix);
   if (suffix !== void 0 && resource === void 0) {
     return void 0;
@@ -9524,6 +10708,8 @@ function parseChapterResourceSuffix(suffix) {
 // src/args/help.ts
 var HELP_TOPICS = [
   "format",
+  "file-import",
+  "source-locators",
   "config",
   "runtime",
   "uri",
@@ -9536,6 +10722,7 @@ var URI_HELP_TARGETS = [
     name: "archive-scope",
     predicates: ["create", "export", "inspect"]
   },
+  { name: "artifact-object", predicates: [] },
   {
     name: "chapter-collection-scope",
     predicates: ["add"]
@@ -9545,6 +10732,7 @@ var URI_HELP_TARGETS = [
     predicates: ["move", "remove", "reset"]
   },
   { name: "chapter-source-range-object", predicates: [] },
+  { name: "chapter-source-locator-scope", predicates: [] },
   { name: "chapter-source-object", predicates: ["set"] },
   { name: "chapter-summary-range-object", predicates: [] },
   { name: "chapter-summary-object", predicates: ["set"] },
@@ -9598,6 +10786,16 @@ var HELP_TOPIC_METADATA = [
     name: "format",
     summary: "Supported formats, inference rules, and IO constraints."
   },
+  {
+    name: "file-import",
+    rootVisible: false,
+    summary: "Advanced source-file import and source-text provenance behavior."
+  },
+  {
+    name: "source-locators",
+    rootVisible: false,
+    summary: "Source artifact URIs and source-text locator mappings."
+  },
   {
     name: "config",
     summary: "Configuration overview, precedence, and when each layer applies."
@@ -9639,6 +10837,8 @@ var ARCHIVE_MAINTENANCE_COMMAND_METADATA = [
 ];
 var HELP_TOPIC_TEMPLATE_NAMES = {
   format: "help/topics/format",
+  "file-import": "help/topics/file-import",
+  "source-locators": "help/topics/source-locators",
   config: "help/topics/config",
   runtime: "help/topics/runtime",
   uri: "help/topics/uri",
@@ -9674,10 +10874,11 @@ function renderHelpTopicText(topic) {
 }
 function renderUriHelpText(targetName, uri) {
   return renderHelpTemplate("help/commands/uri", {
+    displayUri: uri,
     libraryContext: getLibraryHelpContext(uri),
     target: requireUriHelpTarget(targetName),
     uriContext: getUriHelpContext(uri),
-    uri
+    uri: formatHelpCommandUri(uri)
   });
 }
 function renderUriPredicateHelpText(targetName, predicate, uri) {
@@ -9691,26 +10892,33 @@ function renderUriPredicateHelpText(targetName, predicate, uri) {
     );
   }
   return renderHelpTemplate("help/commands/predicate", {
+    displayUri: uri,
     libraryContext: getLibraryHelpContext(uri),
     predicate,
     target,
     uriContext: getUriHelpContext(uri),
-    uri
+    uri: formatHelpCommandUri(uri)
   });
 }
 function renderLibraryUriHelpText(uri, target) {
+  const helpUri = formatLibraryHelpUri(uri, target);
   return renderHelpTemplate("help/commands/library", {
     target,
-    uri: formatLibraryHelpUri(uri, target)
+    uri: formatHelpCommandUri(helpUri)
   });
 }
 function renderLibraryPredicateHelpText(uri, target, predicate) {
+  const helpUri = formatLibraryHelpUri(uri, target);
   return renderHelpTemplate("help/commands/library-predicate", {
+    displayUri: helpUri,
     predicate,
     target,
-    uri: formatLibraryHelpUri(uri, target)
+    uri: formatHelpCommandUri(helpUri)
   });
 }
+function formatHelpCommandUri(uri) {
+  return formatShellArgument(uri);
+}
 function formatLibraryHelpUri(fallbackUri, target) {
   const scopeUri = formatWikiGraphLibraryUri(target.publicId);
   switch (target.kind) {
@@ -9844,10 +11052,7 @@ function getHelpTemplateEnvironment() {
 
 // src/args/archive.ts
 init_support();
-init_support();
-import {
-  parseLocatedWikiGraphUri as parseLocatedWikiGraphUri4
-} from "wiki-graph-core";
+import "wiki-graph-core";
 
 // src/args/helper/actions.ts
 init_support();
@@ -9862,17 +11067,12 @@ function isArchiveMaintenanceCommand(value) {
 
 // src/args/helper/chapter/ids.ts
 init_support();
-import {
-  parseChapterPath as parseChapterPath2,
-  parseChapterUriPath,
-  parseLocatedWikiGraphUri as parseLocatedWikiGraphUri3
-} from "wiki-graph-core";
+import { parseChapterPath as parseChapterPath2, parseChapterUriPath } from "wiki-graph-core";
 
 // src/args/helper/uri.ts
 init_support();
 init_local_config();
 import {
-  parseLocatedWikiGraphUri as parseLocatedWikiGraphUri2,
   parseWikiGraphUriSyntax,
   WIKI_GRAPH_URI_PREFIX
 } from "wiki-graph-core";
@@ -9881,7 +11081,7 @@ function validateArchiveCommandUriInput(action, value) {
     return;
   }
   if (isWikiGraphUri(value)) {
-    if (parseLocatedWikiGraphUri2(value).archivePath === void 0) {
+    if (parseLocatedWikiGraphUri(value).archivePath === void 0) {
       throw new Error(formatMissingArchiveLocatorMessage(value));
     }
     return;
@@ -9895,12 +11095,12 @@ function parseArchiveInspectChapterId(uri) {
   if (uri === void 0 || !isWikiGraphUri(uri)) {
     return void 0;
   }
-  const objectUri = parseLocatedWikiGraphUri2(uri).objectUri;
+  const objectUri = parseLocatedWikiGraphUri(uri).objectUri;
   const match = objectUri === void 0 ? void 0 : /^wikg:\/\/chapter\/([1-9][0-9]*)$/u.exec(objectUri);
   return match?.[1] === void 0 ? void 0 : Number(match[1]);
 }
 function validatePackTargetUri(uri, helpRoute) {
-  const parsed = parseLocatedWikiGraphUri2(uri);
+  const parsed = parseLocatedWikiGraphUri(uri);
   if (parsed.archivePath === void 0) {
     throw new Error(
       withHelpRoute(formatMissingArchiveLocatorMessage(uri), helpRoute)
@@ -9918,7 +11118,7 @@ function validatePackTargetUri(uri, helpRoute) {
   }
 }
 function validateRelatedTargetUri(uri, helpRoute) {
-  const parsed = parseLocatedWikiGraphUri2(uri);
+  const parsed = parseLocatedWikiGraphUri(uri);
   if (parsed.archivePath === void 0) {
     throw new Error(
       withHelpRoute(formatMissingArchiveLocatorMessage(uri), helpRoute)
@@ -9944,7 +11144,7 @@ function validateRelatedTargetUri(uri, helpRoute) {
   return targetType;
 }
 function validateEvidenceTargetUri(uri, helpRoute) {
-  const parsed = parseLocatedWikiGraphUri2(uri);
+  const parsed = parseLocatedWikiGraphUri(uri);
   if (parsed.archivePath === void 0) {
     throw new Error(
       withHelpRoute(formatMissingArchiveLocatorMessage(uri), helpRoute)
@@ -10142,7 +11342,7 @@ function parseWikiGraphPath(value) {
   }
 }
 function requireArchiveUriPath(uri, helpRoute) {
-  const parsed = parseLocatedWikiGraphUri2(uri);
+  const parsed = parseLocatedWikiGraphUri(uri);
   if (parsed.archivePath === void 0 || parsed.objectUri !== void 0) {
     throw new Error(
       withHelpRoute(`Expected an archive Wiki Graph URI: ${uri}`, helpRoute)
@@ -10158,7 +11358,7 @@ function parseChapterPathRef(value, flag, archivePath, helpRoute) {
     if (!isWikiGraphUri(normalized)) {
       return parseChapterPath2(normalized, flag);
     }
-    const parsed = parseLocatedWikiGraphUri3(normalized);
+    const parsed = parseLocatedWikiGraphUri(normalized);
     if (parsed.archivePath !== void 0 && parsed.archivePath !== archivePath) {
       throw new Error(
         `Invalid ${flag}: ${value}. Chapter URI belongs to a different archive.`
@@ -10522,12 +11722,14 @@ function normalizeArchiveChapterArguments(action, path, values, helpRoute, treeA
       rejectActionFlag(values.after, "--after", action, helpRoute);
       rejectActionFlag(values.before, "--before", action, helpRoute);
       rejectActionFlag(values.import, "--import", action, helpRoute);
-      rejectActionFlag(
-        values["input-format"],
-        "--input-format",
-        action,
-        helpRoute
-      );
+      if (values["input-format"] !== void 0 && values["input-format"] !== "jsonl") {
+        throw new Error(
+          withHelpRoute(
+            "`--input-format` for chapter source set only accepts `jsonl`.",
+            helpRoute
+          )
+        );
+      }
       rejectActionFlag(values.parent, "--parent", action, helpRoute);
       rejectActionFlag(values.prompt, "--prompt", action, helpRoute);
       rejectActionFlag(values.title, "--title", action, helpRoute);
@@ -10555,6 +11757,7 @@ function normalizeArchiveChapterArguments(action, path, values, helpRoute, treeA
         ...values.json === void 0 ? {} : { json: values.json },
         path,
         ...values.input === void 0 ? {} : { inputPath: values.input },
+        ...values["input-format"] === void 0 ? {} : { inputFormat: "jsonl" },
         ...values.llm === void 0 ? {} : { llmJSON: values.llm }
       };
     case "set-summary":
@@ -11392,7 +12595,7 @@ function parseArchiveArguments(action, positionals, values, helpRoute = `wg ${ac
       };
     case "inspect": {
       const chapterId = parseArchiveInspectChapterId(positionals[0]);
-      const parsedArchivePath = parseLocatedWikiGraphUri4(archivePath).archivePath ?? archivePath;
+      const parsedArchivePath = parseLocatedWikiGraphUri(archivePath).archivePath ?? archivePath;
       rejectArchiveExtraPositionals(action, positionals, 1, helpRoute);
       rejectArchiveNonReadFlags(action, values, helpRoute);
       rejectArchiveFlag(action, "--budget", values.budget, helpRoute);
@@ -11711,7 +12914,7 @@ function rejectNonChapterDepthFlag(action, archivePath, depth, helpRoute) {
   if (depth === void 0) {
     return;
   }
-  const objectUri = parseLocatedWikiGraphUri4(archivePath).objectUri;
+  const objectUri = parseLocatedWikiGraphUri(archivePath).objectUri;
   if (objectUri === "wikg://chapter" || objectUri?.startsWith("wikg://chapter/") === true) {
     return;
   }
@@ -11739,7 +12942,6 @@ init_support();
 
 // src/args/queue.ts
 init_support();
-import { parseLocatedWikiGraphUri as parseLocatedWikiGraphUri6 } from "wiki-graph-core";
 
 // src/args/uri/chapter/routing.ts
 import {
@@ -11844,7 +13046,36 @@ function parseArchiveChapterUriArguments(uri, archivePath, target, action, tail,
         values,
         helpRoute
       );
+    case "source-locator-scope":
+      return parseSourceLocatorScopeUriArguments(
+        uri,
+        action,
+        tail,
+        values,
+        helpRoute
+      );
+  }
+}
+function parseSourceLocatorScopeUriArguments(uri, action, tail, values, helpRoute) {
+  if (action !== "list") {
+    throw new Error(
+      withHelpRoute(
+        "The source locator scope is read-only. Read it directly to enumerate locator mappings.",
+        "wg <chapter-uri>/source/locators --help"
+      )
+    );
   }
+  rejectArchiveChapterFlag("backlinks", values.backlinks, helpRoute);
+  rejectArchiveChapterFlag("context", values.context, helpRoute);
+  rejectArchiveChapterFlag("depth", values.depth, helpRoute);
+  rejectArchiveChapterFlag("evidence", values.evidence, helpRoute);
+  rejectArchiveChapterFlag("reverse", values.reverse, helpRoute);
+  rejectArchiveChapterFlag(
+    "skip-unindexed",
+    values["skip-unindexed"],
+    helpRoute
+  );
+  return parseArchiveArguments("list", [uri, ...tail], values, helpRoute);
 }
 function parseChapterIndexArtifactUriArguments(archivePath, chapterPath, indexArtifactKind, action, tail, values, helpRoute) {
   rejectArchiveChapterMetaFlags(values, helpRoute);
@@ -12205,8 +13436,7 @@ function parseArchiveChapterLikeArguments(action, archivePath, tail, values, hel
 
 // src/args/uri/entry.ts
 import {
-  parseWikiGraphLibraryUri as parseWikiGraphLibraryUri2,
-  parseLocatedWikiGraphUri as parseLocatedWikiGraphUri5
+  parseWikiGraphLibraryUri as parseWikiGraphLibraryUri2
 } from "wiki-graph-core";
 init_support();
 
@@ -12525,14 +13755,14 @@ function normalizeArchiveUriAction(uri, action) {
   if (action !== "apply") {
     return action;
   }
-  const parsed = parseLocatedWikiGraphUri5(uri);
+  const parsed = parseLocatedWikiGraphUri(uri);
   if (parsed.objectUri === "wikg://chapter/tree") {
     return "set";
   }
   return action;
 }
 function resolveImplicitArchiveUriAction(uri, query) {
-  const parsed = parseLocatedWikiGraphUri5(uri);
+  const parsed = parseLocatedWikiGraphUri(uri);
   if (parsed.archivePath === void 0) {
     throw new Error(formatMissingArchiveLocatorMessage(uri));
   }
@@ -12564,6 +13794,7 @@ function classifyArchiveUri(objectUri) {
       case "triple-pattern-lens":
       case "chapter-lens":
       case "chapter-triple-pattern-lens":
+      case "source-locator-scope":
         return "scope";
       case "tree":
       case "chapter-resource":
@@ -12580,7 +13811,7 @@ function classifyArchiveUri(objectUri) {
   return "object";
 }
 function classifyArchiveUriHelpTarget(uri) {
-  const parsed = parseLocatedWikiGraphUri5(uri);
+  const parsed = parseLocatedWikiGraphUri(uri);
   const objectUri = parsed.objectUri;
   if (objectUri === void 0) {
     return "archive-scope";
@@ -12596,6 +13827,9 @@ function classifyArchiveUriHelpTarget(uri) {
   if (path === "index") {
     return "index-object";
   }
+  if (/^artifact\/[0-9a-f]{12,64}(?:#.+)?$/iu.test(path)) {
+    return "artifact-object";
+  }
   const chapterTarget = parseChapterTarget(objectUri);
   if (chapterTarget !== void 0) {
     switch (chapterTarget.kind) {
@@ -12609,6 +13843,8 @@ function classifyArchiveUriHelpTarget(uri) {
         return "chapter-state-object";
       case "chapter-index-artifact":
         return "chapter-index-artifact";
+      case "source-locator-scope":
+        return "chapter-source-locator-scope";
       case "chapter-resource":
         switch (chapterTarget.resource) {
           case "source":
@@ -12707,7 +13943,7 @@ function hasUriFragment(uri) {
   return uri.includes("#");
 }
 function parseArchiveUriTargetArguments(uri, action, tail, values) {
-  const parsed = parseLocatedWikiGraphUri5(uri);
+  const parsed = parseLocatedWikiGraphUri(uri);
   const libraryArchiveObjectTarget = parseLibraryArchiveObjectTarget(uri);
   const archivePath = libraryArchiveObjectTarget === void 0 ? parsed.archivePath : formatLibraryArchiveLocator(libraryArchiveObjectTarget);
   const objectUri = libraryArchiveObjectTarget?.objectUri ?? parsed.objectUri;
@@ -13014,7 +14250,7 @@ function parseQueueAddArguments(tail, values, helpRoute) {
   };
 }
 function parseQueueAddInput(uri, helpRoute) {
-  const parsed = parseLocatedWikiGraphUri6(uri);
+  const parsed = parseLocatedWikiGraphUri(uri);
   if (parsed.archivePath === void 0) {
     throw new Error(
       withHelpRoute(
@@ -15046,6 +16282,7 @@ async function runQueueCommand2(args) {
 // src/app/dispatch.ts
 init_support();
 init_support();
+init_home_target();
 import {
   ensureWikiGraphHomeSchemaCurrent,
   formatError as formatError3,
@@ -15070,7 +16307,9 @@ async function dispatchWikiGraphCLI(input) {
 `);
         return { exitCode: 0 };
     }
-    await ensureWikiGraphHomeSchemaCurrent();
+    if (parsed.kind !== "maintenance-command" || !isWikiGraphHomeTarget(parsed.args.target)) {
+      await ensureWikiGraphHomeSchemaCurrent();
+    }
     switch (parsed.kind) {
       case "convert":
         await runConvertCommand2(parsed.args);
@@ -15114,14 +16353,18 @@ async function dispatchWikiGraphCLI(input) {
     }
   } catch (error) {
     if (shouldWriteJSONError(input.argv)) {
-      input.stdout.write(formatCLIJSON(createCLIErrorObject(error)));
+      input.stdout.write(
+        formatCLIJSON(createCLIErrorObject(error, input.argv))
+      );
       return { exitCode: 1 };
     }
     if (shouldWriteJSONLError(input.argv)) {
-      input.stdout.write(formatCLIJSONLine(createCLIErrorObject(error)));
+      input.stdout.write(
+        formatCLIJSONLine(createCLIErrorObject(error, input.argv))
+      );
       return { exitCode: 1 };
     }
-    input.stderr.write(`${formatCLIError(error)}
+    input.stderr.write(`${formatCLIError(error, input.argv)}
 `);
     return { exitCode: 1 };
   }
@@ -15129,20 +16372,42 @@ async function dispatchWikiGraphCLI(input) {
 function shouldPrintDefaultHelp(argv, stdinIsTTY) {
   return argv.length === 0 && stdinIsTTY === true;
 }
-function formatCLIError(error) {
+function formatCLIError(error, argv) {
   if (error instanceof LLMPaymentRequiredError) {
     return "LLM payment required. Check your provider billing status or account balance.";
   }
-  return formatError3(error);
+  const message = formatError3(error);
+  const relativeResolution = hasErrorCode(error, "ENOENT") ? getRelativeArchiveUriResolution(argv[0] ?? "") : void 0;
+  if (relativeResolution === void 0) {
+    return message;
+  }
+  return `${message}
+Archive URI \`${relativeResolution.inputUri}\` is relative to the current working directory:
+  ${relativeResolution.workingDirectory}
+Resolved archive path:
+  ${relativeResolution.resolvedArchivePath}
+See: wg help uri`;
 }
-function createCLIErrorObject(error) {
+function createCLIErrorObject(error, argv) {
   return {
     error: {
-      message: formatCLIError(error),
+      message: formatCLIError(error, argv),
       type: error instanceof LLMPaymentRequiredError ? "llm_payment_required" : "error"
     }
   };
 }
+function hasErrorCode(error, code) {
+  const visited = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current !== void 0 && !visited.has(current)) {
+    visited.add(current);
+    if (current instanceof Error && "code" in current && current.code === code) {
+      return true;
+    }
+    current = current instanceof Error ? current.cause : void 0;
+  }
+  return false;
+}
 function shouldWriteJSONError(argv) {
   return argv.some((item) => item === "--json" || item.startsWith("--json="));
 }
@@ -15194,7 +16459,7 @@ async function runWikiGraphCLIWithEntryPolicy(input = {}, envPolicy) {
     stdout,
     stdoutIsTTY: input.stdoutIsTTY
   };
-  return await withWikiGraphRuntimeStateDirectoryPath(
+  return await withNodeWikiGraphStorage(
     entryContext.stateDir,
     async () => withWikiGraphCLIRuntimeContext(context, async () => {
       const result = await dispatchWikiGraphCLI({
@@ -15259,7 +16524,7 @@ function throwIfAborted(signal) {
   }
   throw signal.reason instanceof Error ? signal.reason : new Error("The Wiki Graph CLI run was aborted.");
 }
-var CaptureWritable = class extends Writable2 {
+var CaptureWritable = class extends Writable3 {
   #chunks = [];
   constructor(isTTY) {
     super();
@@ -15284,6 +16549,9 @@ var CaptureWritable = class extends Writable2 {
     callback();
   }
 };
+
+// src/app/main.ts
+init_node_platform();
 export {
   createWikiGraphCLI,
   runWikiGraphCLI,