wiki-graph-core 0.3.1 → 0.4.0

package/dist/index.d.cts

@@ -1,10 +1,9 @@
 import { LanguageModel, ModelMessage } from 'ai';
 import { Environment } from 'nunjucks';
-import * as Sqlite3Namespace from 'sqlite3';
 import { z } from 'zod';
-import { a as GcContext, d as GcJobResult } from './types-FVIqiLC9.cjs';
-import { B as BuildJobProgressReporter } from './worker-BgQ0Xl8T.cjs';
-export { A as AddBuildJobOptions, a as BuildJob, b as BuildJobConflictScope, c as BuildJobEvent, d as BuildJobExecutionContext, e as BuildJobListOptions, f as BuildJobProgressCounter, g as BuildJobState, h as BuildJobTarget, i as BuildJobWorkerOptions, j as addBuildJob, k as assertBuildJobInputRevision, l as assertNoActiveBuildJobConflicts, m as assertNoActiveBuildJobs, n as boostBuildJob, o as cancelBuildJob, p as cleanBuildJobs, q as getBuildJob, r as listBuildJobs, s as pauseBuildJob, t as readBuildJobEvents, u as recordBuildJobInputRevision, v as resolveBuildJobId, w as resumeBuildJob, x as runBuildJobWorker, y as runBuildQueueGc, z as updateBuildJobTarget } from './worker-BgQ0Xl8T.cjs';
+import * as Sqlite3Namespace from 'sqlite3';
+import { A as AddBuildJobOptions, B as BuildJob, a as BuildJobListOptions, b as BuildJobTarget, c as BuildJobConflictScope, d as BuildJobEvent, e as BuildJobState, f as BuildJobProgressReporter } from './worker-DWasYKWW.cjs';
+export { g as BuildJobExecutionContext, h as BuildJobProgressCounter, i as BuildJobWorkerOptions, r as runBuildJobWorker } from './worker-DWasYKWW.cjs';
 
 declare enum Language {
     Arabic = "Arabic",
@@ -232,12 +231,90 @@ declare function createEnv(dirPath: string, options?: {
     readonly trimBlocks?: boolean;
 }): Environment;
 
-declare function resolveWikiGraphHomeDirectoryPath(): string;
-declare function resolveWikiGraphCoreDatabasePath(): string;
-
-type WikiGraphTempCategory = "archive-open" | "archive-write" | "cli-output" | "sdpub-upgrade" | "stdin-create" | "url-create";
-declare function resolveWikiGraphStateRootPath(): string;
-declare function createWikiGraphTempDirectory(category: WikiGraphTempCategory): Promise<string>;
+interface WikiGraphLibraryRecord {
+    readonly id: number;
+    readonly publicId: string;
+    readonly uri: string;
+    readonly folderPath: string;
+    readonly isDefault: boolean;
+    readonly stagingPath: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface ParsedWikiGraphLibraryUri {
+    readonly archivePublicId?: string;
+    readonly kind: "archive" | "archive-collection" | "archive-path" | "archive-tree" | "metadata" | "path" | "registry" | "scope";
+    readonly objectUri?: string;
+    readonly publicId?: string;
+    readonly isDefault: boolean;
+}
+declare function isWikiGraphLibraryUri(uri: string | undefined): uri is string;
+declare function parseWikiGraphLibraryUri(uri: string): ParsedWikiGraphLibraryUri | undefined;
+declare function formatWikiGraphLibraryUri(publicId?: string): string;
+declare function resolveDefaultWikiGraphLibraryDirectoryPath(): string;
+declare function resolveWikiGraphLibraryStagingDirectoryPath(id: number): string;
+declare function ensureDefaultWikiGraphLibrary(): Promise<WikiGraphLibraryRecord>;
+declare function createWikiGraphLibrary(input: {
+    readonly folderPath: string;
+}): Promise<WikiGraphLibraryRecord>;
+declare function listWikiGraphLibraries(): Promise<readonly WikiGraphLibraryRecord[]>;
+declare function resolveWikiGraphLibrary(target: ParsedWikiGraphLibraryUri): Promise<WikiGraphLibraryRecord>;
+declare function resolveWikiGraphLibraryById(id: number): Promise<WikiGraphLibraryRecord>;
+declare function listWikiGraphLibraryScope(target: ParsedWikiGraphLibraryUri): Promise<readonly []>;
+declare function removeWikiGraphLibrary(target: ParsedWikiGraphLibraryUri): Promise<WikiGraphLibraryRecord>;
+declare function getWikiGraphLibraryMetadata(target: ParsedWikiGraphLibraryUri): Promise<Readonly<Record<string, unknown>>>;
+declare function replaceWikiGraphLibraryMetadata(target: ParsedWikiGraphLibraryUri, map: Readonly<Record<string, unknown>>): Promise<Readonly<Record<string, unknown>>>;
+declare function putWikiGraphLibraryMetadata(target: ParsedWikiGraphLibraryUri, key: string, value: unknown): Promise<Readonly<Record<string, unknown>>>;
+declare function deleteWikiGraphLibraryMetadataKey(target: ParsedWikiGraphLibraryUri, key: string): Promise<Readonly<Record<string, unknown>>>;
+declare function clearWikiGraphLibraryMetadata(target: ParsedWikiGraphLibraryUri): Promise<Readonly<Record<string, unknown>>>;
+
+type WikiGraphLibraryArchiveStatus = "conflict" | "missing" | "present";
+interface WikiGraphLibraryArchiveRecord {
+    readonly id: number;
+    readonly publicId: string;
+    readonly uri: string;
+    readonly libraryId: number;
+    readonly libraryUri: string;
+    readonly relativePath: string;
+    readonly path: string;
+    readonly exists: boolean;
+    readonly status: WikiGraphLibraryArchiveStatus;
+    readonly lastSeenMutationToken?: string;
+    readonly lastSeenSize?: number;
+    readonly lastSeenMtimeMs?: number;
+    readonly lastScannedAt?: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+interface WikiGraphLibraryScanResult {
+    readonly library: WikiGraphLibraryRecord;
+    readonly archives: readonly WikiGraphLibraryArchiveRecord[];
+}
+declare function scanWikiGraphLibrary(target: ParsedWikiGraphLibraryUri): Promise<WikiGraphLibraryScanResult>;
+declare function rebindWikiGraphLibrary(input: {
+    readonly target: ParsedWikiGraphLibraryUri;
+    readonly folderPath: string;
+}): Promise<WikiGraphLibraryScanResult>;
+declare function listWikiGraphLibraryArchives(target: ParsedWikiGraphLibraryUri): Promise<readonly WikiGraphLibraryArchiveRecord[]>;
+declare function getWikiGraphLibraryArchive(target: ParsedWikiGraphLibraryUri): Promise<WikiGraphLibraryArchiveRecord>;
+declare function getWikiGraphLibraryArchiveById(library: WikiGraphLibraryRecord, archiveId: number): Promise<WikiGraphLibraryArchiveRecord>;
+declare function resolveWikiGraphLibraryArchivePath(archiveLocator: string): Promise<string>;
+declare function addWikiGraphLibraryArchive(input: {
+    readonly target: ParsedWikiGraphLibraryUri;
+    readonly inputPath: string;
+    readonly to?: string;
+}): Promise<WikiGraphLibraryArchiveRecord>;
+declare function finalizeWikiGraphLibraryArchiveWrite(input: {
+    readonly target: ParsedWikiGraphLibraryUri;
+}): Promise<boolean>;
+declare function ensureLibraryManagedArchiveHasNoSearchIndex(archivePath: string): Promise<boolean>;
+declare function removeWikiGraphLibraryArchive(input: {
+    readonly target: ParsedWikiGraphLibraryUri;
+}): Promise<WikiGraphLibraryArchiveRecord>;
+declare function moveWikiGraphLibraryArchive(input: {
+    readonly target: ParsedWikiGraphLibraryUri;
+    readonly to: string;
+}): Promise<WikiGraphLibraryArchiveRecord>;
 
 type SqliteDatabase = Sqlite3Namespace.Database;
 type SqlBindValue = Buffer | Uint8Array | number | string | null;
@@ -266,7 +343,6 @@ declare class Database {
 declare function openSharedStateDatabase(databasePath: string, schemaSql: string, options?: {
     readonly readonly?: boolean;
 }): Promise<Database>;
-declare function ensureSharedStateDatabaseInitialized(databasePath: string, schemaSql: string): Promise<void>;
 
 declare enum ChunkRetention {
     Verbatim = "verbatim",
@@ -274,15 +350,11 @@ declare enum ChunkRetention {
     Focused = "focused",
     Relevant = "relevant"
 }
-declare const isChunkRetention: (value: string) => value is ChunkRetention;
-declare const expectChunkRetention: (value: string) => ChunkRetention;
 declare enum ChunkImportance {
     Critical = "critical",
     Important = "important",
     Helpful = "helpful"
 }
-declare const isChunkImportance: (value: string) => value is ChunkImportance;
-declare const expectChunkImportance: (value: string) => ChunkImportance;
 type SentenceId = readonly [chapterId: number, sentenceIndex: number];
 interface SentenceRecord {
     readonly text: string;
@@ -406,6 +478,23 @@ interface ObjectMetadataTarget {
     readonly tripleObjectQid?: string;
 }
 
+declare class TextStreamDraft {
+    #private;
+    constructor(serialId: number, startSentenceIndex: number, callbacks: {
+        readonly discard: () => void;
+        readonly finalize: (startSentenceIndex: number, summary: string, sentences: readonly SentenceRecord[]) => Promise<FragmentRecord | undefined>;
+    });
+    addSentence(text: string, wordsCount: number, location?: {
+        readonly byteOffset: number;
+        readonly byteLength: number;
+    }): SentenceId;
+    commit(): Promise<FragmentRecord | undefined>;
+    commitWithText(text: string): Promise<FragmentRecord | undefined>;
+    discard(): void;
+    setSummary(summary: string): void;
+    get fragmentId(): number;
+}
+
 declare const TEXT_STREAM_KIND: {
     readonly source: 1;
     readonly summary: 2;
@@ -446,14 +535,7 @@ interface ReadonlySerialTextStream {
     readonly path: string;
     readonly serialId: number;
 }
-declare class TextStreams implements ReadonlyTextStreams {
-    #private;
-    constructor(documentPath: string, database: Database, fileAccess?: TextStreamFileAccess);
-    ensureCreated(): Promise<void>;
-    getSentence(sentenceId: SentenceId): Promise<string>;
-    getSerial(serialId: number): SerialTextStream;
-    getSummarySerial(serialId: number): SerialTextStream;
-}
+
 declare class SerialTextStream implements ReadonlySerialTextStream {
     #private;
     constructor(documentPath: string, database: Database, fileAccess: TextStreamFileAccess, stream: TextStreamName, serialId: number);
@@ -470,81 +552,14 @@ declare class SerialTextStream implements ReadonlySerialTextStream {
     get path(): string;
     get serialId(): number;
 }
-declare class TextStreamDraft {
-    #private;
-    constructor(serialId: number, startSentenceIndex: number, callbacks: {
-        readonly discard: () => void;
-        readonly finalize: (startSentenceIndex: number, summary: string, sentences: readonly SentenceRecord[]) => Promise<FragmentRecord | undefined>;
-    });
-    addSentence(text: string, wordsCount: number, location?: {
-        readonly byteOffset: number;
-        readonly byteLength: number;
-    }): SentenceId;
-    commit(): Promise<FragmentRecord | undefined>;
-    commitWithText(text: string): Promise<FragmentRecord | undefined>;
-    discard(): void;
-    setSummary(summary: string): void;
-    get fragmentId(): number;
-}
 
-interface FragmentWriter {
-    write(path: string, content: string): Promise<void>;
-}
-interface FragmentFileAccess {
-    ensureDirectory(path: string): Promise<void>;
-    listFileContents?(path: string): Promise<ReadonlyMap<string, Uint8Array>>;
-    listFiles(path: string): Promise<readonly string[]>;
-    readFile(path: string): Promise<Uint8Array | undefined>;
-}
-interface ReadonlyFragments {
-    getSerial(serialId: number): ReadonlySerialFragments;
-    getSummarySerial(serialId: number): ReadonlySerialFragments;
-    getSentence(sentenceId: SentenceId): Promise<string>;
-    getSummary(serialId: number, fragmentId: number): Promise<string>;
-    getWordsCount(serialId: number, fragmentId: number): Promise<number>;
-    readonly path: string;
-}
-interface TextStreamWriteOptions {
-    readonly maxWordsCount?: number;
-}
-interface ReadonlySerialFragments {
-    getFragment(fragmentId: number): Promise<FragmentRecord>;
-    listFragmentIds(): Promise<readonly number[]>;
-    readonly serialId: number;
-    readonly path: string;
-}
-declare class Fragments implements ReadonlyFragments {
+declare class TextStreams implements ReadonlyTextStreams {
     #private;
-    constructor(documentPath: string, writer?: FragmentWriter, fileAccess?: FragmentFileAccess);
+    constructor(documentPath: string, database: Database, fileAccess?: TextStreamFileAccess);
     ensureCreated(): Promise<void>;
-    getSerial(serialId: number): SerialFragments;
-    getSummarySerial(serialId: number): SerialFragments;
     getSentence(sentenceId: SentenceId): Promise<string>;
-    getSummary(serialId: number, fragmentId: number): Promise<string>;
-    getWordsCount(serialId: number, fragmentId: number): Promise<number>;
-    get path(): string;
-}
-declare class SerialFragments implements ReadonlySerialFragments {
-    #private;
-    constructor(documentPath: string, serialId: number, rootDirectoryName?: string, writer?: FragmentWriter, fileAccess?: FragmentFileAccess);
-    createDraft(): Promise<FragmentDraft>;
-    getFragment(fragmentId: number): Promise<FragmentRecord>;
-    listFragmentIds(): Promise<readonly number[]>;
-    writeTextStream(text: string, options?: TextStreamWriteOptions): Promise<void>;
-    get serialId(): number;
-    get path(): string;
-}
-declare class FragmentDraft {
-    #private;
-    constructor(serialId: number, fragmentId: number, startSentenceIndex: number, callbacks: {
-        readonly discard: () => void;
-        readonly finalize: (fragmentId: number, startSentenceIndex: number, summary: string, sentences: readonly SentenceRecord[]) => Promise<FragmentRecord | undefined>;
-    });
-    addSentence(text: string, wordsCount: number): SentenceId;
-    commit(): Promise<FragmentRecord | undefined>;
-    discard(): void;
-    setSummary(summary: string): void;
-    get fragmentId(): number;
+    getSerial(serialId: number): SerialTextStream;
+    getSummarySerial(serialId: number): SerialTextStream;
 }
 
 declare const bookMetaSchema: z.ZodObject<{
@@ -567,6 +582,7 @@ type BookMeta = z.infer<typeof bookMetaSchema>;
 
 declare const TOC_FILE_VERSION = 1;
 interface TocItem {
+    readonly key?: string | undefined;
     readonly title?: string | null | undefined;
     readonly serialId?: number | undefined;
     readonly children: readonly TocItem[];
@@ -613,16 +629,38 @@ interface ReadonlyReadingEdgeStore {
     listOutgoing(chunkId: number): Promise<ReadingEdgeRecord[]>;
 }
 interface ReadonlyMentionStore {
+    countByQid(qid: string, options?: {
+        readonly chapterId?: number;
+    }): Promise<number>;
     getById(mentionId: string): Promise<MentionRecord | undefined>;
     listAll(): Promise<MentionRecord[]>;
     listBySurfaceTerms(terms: readonly string[]): Promise<MentionRecord[]>;
     listBySurfaces(surfaces: readonly string[]): Promise<MentionRecord[]>;
-    listByQid(qid: string): Promise<MentionRecord[]>;
+    listByQid(qid: string, options?: {
+        readonly chapterId?: number;
+        readonly limit?: number;
+        readonly offset?: number;
+        readonly order?: "asc" | "desc";
+    }): Promise<MentionRecord[]>;
+    listLabelsByQid(qid: string, options?: {
+        readonly chapterId?: number;
+    }): Promise<string[]>;
     listByChapter(chapterId: number): Promise<MentionRecord[]>;
 }
 interface ReadonlyMentionLinkStore {
+    countByTriple(input: {
+        readonly chapterId?: number;
+        readonly objectQid: string;
+        readonly predicate: string;
+        readonly subjectQid: string;
+    }): Promise<number>;
     getById(linkId: string): Promise<MentionLinkRecord | undefined>;
+    listAll(): Promise<MentionLinkRecord[]>;
     listByTriple(input: {
+        readonly chapterId?: number;
+        readonly limit?: number;
+        readonly offset?: number;
+        readonly order?: "asc" | "desc";
         readonly objectQid: string;
         readonly predicate: string;
         readonly subjectQid: string;
@@ -652,6 +690,94 @@ interface ReadonlyFragmentGroupStore {
 interface ReadonlyObjectMetadataStore {
     getMap(objectPath: string): Promise<Readonly<Record<string, unknown>>>;
 }
+
+declare class ChunkStore implements ReadonlyChunkStore {
+    #private;
+    constructor(database: Database);
+    countAll(): Promise<number>;
+    create(record: CreateChunkRecord): Promise<ChunkRecord>;
+    save(record: ChunkRecord): Promise<void>;
+    getById(chunkId: number): Promise<ChunkRecord | undefined>;
+    listAll(): Promise<ChunkRecord[]>;
+    listBySentenceStartIndexes(serialId: number, sentenceStartIndexes: readonly number[]): Promise<ChunkRecord[]>;
+    listBySentenceRange(serialId: number, startSentenceIndex: number, endSentenceIndex: number): Promise<ChunkRecord[]>;
+    listBySerial(serialId: number): Promise<ChunkRecord[]>;
+    getMaxId(): Promise<number>;
+    listFragmentPairs(): Promise<ReadonlyArray<readonly [number, number]>>;
+}
+
+declare class FragmentGroupStore implements ReadonlyFragmentGroupStore {
+    #private;
+    constructor(database: Database);
+    save(record: SentenceGroupRecord): Promise<void>;
+    saveMany(records: readonly SentenceGroupRecord[]): Promise<void>;
+    listBySerial(serialId: number): Promise<SentenceGroupRecord[]>;
+    listSerialIds(): Promise<number[]>;
+    listGroupIdsForSerial(serialId: number): Promise<number[]>;
+}
+
+declare class GraphBuildParameterStore implements ReadonlyGraphBuildParameterStore {
+    #private;
+    constructor(database: Database);
+    save(input: {
+        readonly language?: string;
+        readonly prompt: string;
+    }): Promise<GraphBuildParameterRecord>;
+    getByHash(hash: string): Promise<GraphBuildParameterRecord | undefined>;
+    deleteUnreferenced(): Promise<void>;
+}
+
+declare class MentionLinkStore implements ReadonlyMentionLinkStore {
+    #private;
+    constructor(database: Database);
+    save(record: MentionLinkRecord): Promise<void>;
+    saveMany(records: readonly MentionLinkRecord[]): Promise<void>;
+    getById(linkId: string): Promise<MentionLinkRecord | undefined>;
+    listAll(): Promise<MentionLinkRecord[]>;
+    countByTriple(input: {
+        readonly chapterId?: number;
+        readonly objectQid: string;
+        readonly predicate: string;
+        readonly subjectQid: string;
+    }): Promise<number>;
+    listByTriple(input: {
+        readonly chapterId?: number;
+        readonly limit?: number;
+        readonly offset?: number;
+        readonly order?: "asc" | "desc";
+        readonly objectQid: string;
+        readonly predicate: string;
+        readonly subjectQid: string;
+    }): Promise<MentionLinkRecord[]>;
+    listByChapter(chapterId: number): Promise<MentionLinkRecord[]>;
+    deleteByChapter(chapterId: number): Promise<void>;
+}
+
+declare class MentionStore implements ReadonlyMentionStore {
+    #private;
+    constructor(database: Database);
+    save(record: MentionRecord): Promise<void>;
+    saveMany(records: readonly MentionRecord[]): Promise<void>;
+    getById(mentionId: string): Promise<MentionRecord | undefined>;
+    listAll(): Promise<MentionRecord[]>;
+    countByQid(qid: string, options?: {
+        readonly chapterId?: number;
+    }): Promise<number>;
+    listByQid(qid: string, options?: {
+        readonly chapterId?: number;
+        readonly limit?: number;
+        readonly offset?: number;
+        readonly order?: "asc" | "desc";
+    }): Promise<MentionRecord[]>;
+    listLabelsByQid(qid: string, options?: {
+        readonly chapterId?: number;
+    }): Promise<string[]>;
+    listBySurfaces(surfaces: readonly string[]): Promise<MentionRecord[]>;
+    listBySurfaceTerms(terms: readonly string[]): Promise<MentionRecord[]>;
+    listByChapter(chapterId: number): Promise<MentionRecord[]>;
+    deleteByChapter(chapterId: number): Promise<void>;
+}
+
 declare class ObjectMetadataStore implements ReadonlyObjectMetadataStore {
     #private;
     constructor(database: Database);
@@ -664,6 +790,18 @@ declare class ObjectMetadataStore implements ReadonlyObjectMetadataStore {
     deleteDeletedChunks(): Promise<void>;
     deleteDeletedEntitiesAndTriples(): Promise<void>;
 }
+
+declare class ReadingEdgeStore implements ReadonlyReadingEdgeStore {
+    #private;
+    constructor(database: Database);
+    countAll(): Promise<number>;
+    save(record: ReadingEdgeRecord): Promise<void>;
+    listAll(): Promise<ReadingEdgeRecord[]>;
+    listBySerial(serialId: number): Promise<ReadingEdgeRecord[]>;
+    listIncoming(chunkId: number): Promise<ReadingEdgeRecord[]>;
+    listOutgoing(chunkId: number): Promise<ReadingEdgeRecord[]>;
+}
+
 declare class SerialStore implements ReadonlySerialStore {
     #private;
     constructor(database: Database);
@@ -686,40 +824,15 @@ declare class SerialStore implements ReadonlySerialStore {
         readonly serialId: number;
     }[]): Promise<void>;
 }
-declare class GraphBuildParameterStore implements ReadonlyGraphBuildParameterStore {
-    #private;
-    constructor(database: Database);
-    save(input: {
-        readonly language?: string;
-        readonly prompt: string;
-    }): Promise<GraphBuildParameterRecord>;
-    getByHash(hash: string): Promise<GraphBuildParameterRecord | undefined>;
-    deleteUnreferenced(): Promise<void>;
-}
-declare class ChunkStore implements ReadonlyChunkStore {
-    #private;
-    constructor(database: Database);
-    countAll(): Promise<number>;
-    create(record: CreateChunkRecord): Promise<ChunkRecord>;
-    save(record: ChunkRecord): Promise<void>;
-    getById(chunkId: number): Promise<ChunkRecord | undefined>;
-    listAll(): Promise<ChunkRecord[]>;
-    listBySentenceStartIndexes(serialId: number, sentenceStartIndexes: readonly number[]): Promise<ChunkRecord[]>;
-    listBySentenceRange(serialId: number, startSentenceIndex: number, endSentenceIndex: number): Promise<ChunkRecord[]>;
-    listBySerial(serialId: number): Promise<ChunkRecord[]>;
-    getMaxId(): Promise<number>;
-    listFragmentPairs(): Promise<ReadonlyArray<readonly [number, number]>>;
-}
-declare class ReadingEdgeStore implements ReadonlyReadingEdgeStore {
+
+declare class SnakeChunkStore implements ReadonlySnakeChunkStore {
     #private;
     constructor(database: Database);
-    countAll(): Promise<number>;
-    save(record: ReadingEdgeRecord): Promise<void>;
-    listAll(): Promise<ReadingEdgeRecord[]>;
-    listBySerial(serialId: number): Promise<ReadingEdgeRecord[]>;
-    listIncoming(chunkId: number): Promise<ReadingEdgeRecord[]>;
-    listOutgoing(chunkId: number): Promise<ReadingEdgeRecord[]>;
+    save(record: SnakeChunkRecord): Promise<void>;
+    listChunkIds(snakeId: number): Promise<number[]>;
+    listBySnake(snakeId: number): Promise<SnakeChunkRecord[]>;
 }
+
 declare class SnakeStore implements ReadonlySnakeStore {
     #private;
     constructor(database: Database);
@@ -728,40 +841,7 @@ declare class SnakeStore implements ReadonlySnakeStore {
     listIdsByGroup(serialId: number, groupId: number): Promise<number[]>;
     listBySerial(serialId: number): Promise<SnakeRecord[]>;
 }
-declare class MentionStore implements ReadonlyMentionStore {
-    #private;
-    constructor(database: Database);
-    save(record: MentionRecord): Promise<void>;
-    saveMany(records: readonly MentionRecord[]): Promise<void>;
-    getById(mentionId: string): Promise<MentionRecord | undefined>;
-    listAll(): Promise<MentionRecord[]>;
-    listByQid(qid: string): Promise<MentionRecord[]>;
-    listBySurfaces(surfaces: readonly string[]): Promise<MentionRecord[]>;
-    listBySurfaceTerms(terms: readonly string[]): Promise<MentionRecord[]>;
-    listByChapter(chapterId: number): Promise<MentionRecord[]>;
-    deleteByChapter(chapterId: number): Promise<void>;
-}
-declare class MentionLinkStore implements ReadonlyMentionLinkStore {
-    #private;
-    constructor(database: Database);
-    save(record: MentionLinkRecord): Promise<void>;
-    saveMany(records: readonly MentionLinkRecord[]): Promise<void>;
-    getById(linkId: string): Promise<MentionLinkRecord | undefined>;
-    listByTriple(input: {
-        readonly objectQid: string;
-        readonly predicate: string;
-        readonly subjectQid: string;
-    }): Promise<MentionLinkRecord[]>;
-    listByChapter(chapterId: number): Promise<MentionLinkRecord[]>;
-    deleteByChapter(chapterId: number): Promise<void>;
-}
-declare class SnakeChunkStore implements ReadonlySnakeChunkStore {
-    #private;
-    constructor(database: Database);
-    save(record: SnakeChunkRecord): Promise<void>;
-    listChunkIds(snakeId: number): Promise<number[]>;
-    listBySnake(snakeId: number): Promise<SnakeChunkRecord[]>;
-}
+
 declare class SnakeEdgeStore implements ReadonlySnakeEdgeStore {
     #private;
     constructor(database: Database);
@@ -771,15 +851,6 @@ declare class SnakeEdgeStore implements ReadonlySnakeEdgeStore {
     listWithin(snakeIds: readonly number[]): Promise<SnakeEdgeRecord[]>;
     listBySerial(serialId: number): Promise<SnakeEdgeRecord[]>;
 }
-declare class FragmentGroupStore implements ReadonlyFragmentGroupStore {
-    #private;
-    constructor(database: Database);
-    save(record: SentenceGroupRecord): Promise<void>;
-    saveMany(records: readonly SentenceGroupRecord[]): Promise<void>;
-    listBySerial(serialId: number): Promise<SentenceGroupRecord[]>;
-    listSerialIds(): Promise<number[]>;
-    listGroupIdsForSerial(serialId: number): Promise<number[]>;
-}
 
 interface DocumentFileStore {
     close(): Promise<void>;
@@ -861,6 +932,19 @@ interface Document extends ReadonlyDocument {
     writeToc(toc: TocFile): Promise<void>;
     writeSearchIndexDatabase<T>(operation: (database: Database) => Promise<T> | T): Promise<T>;
 }
+
+declare class DirectoryDocumentContext implements DocumentContext {
+    #private;
+    constructor(document: DirectoryDocument);
+    complete(): void;
+    dispose(): Promise<void>;
+    ownSerial(serialId: number): void;
+    run<T>(operation: () => Promise<T> | T): Promise<T>;
+    listCreatedFilePaths(): readonly string[];
+    listOwnedSerialIds(): readonly number[];
+    registerCreatedFile(path: string): void;
+}
+
 declare class DirectoryDocument implements Document {
     #private;
     readonly chunks: ChunkStore;
@@ -911,1295 +995,1233 @@ declare class DirectoryDocument implements Document {
     runWithContext<T>(context: DirectoryDocumentContext, operation: () => Promise<T> | T): Promise<T>;
     rollbackContext(context: DirectoryDocumentContext): Promise<void>;
 }
-declare class DirectoryDocumentContext implements DocumentContext {
-    #private;
-    constructor(document: DirectoryDocument);
-    complete(): void;
-    dispose(): Promise<void>;
-    ownSerial(serialId: number): void;
-    run<T>(operation: () => Promise<T> | T): Promise<T>;
-    listCreatedFilePaths(): readonly string[];
-    listOwnedSerialIds(): readonly number[];
-    registerCreatedFile(path: string): void;
-}
-
-declare const SCHEMA_SQL = "\n  CREATE TABLE IF NOT EXISTS serials (\n    id INTEGER PRIMARY KEY,\n    document_order INTEGER NOT NULL DEFAULT 0\n  );\n\n  CREATE TABLE IF NOT EXISTS serial_states (\n    serial_id INTEGER PRIMARY KEY,\n    revision INTEGER NOT NULL DEFAULT 0,\n    topology_ready INTEGER NOT NULL DEFAULT 0,\n    topology_parameter_hash TEXT,\n    knowledge_graph_ready INTEGER NOT NULL DEFAULT 0,\n    knowledge_graph_parameter_hash TEXT,\n    FOREIGN KEY (serial_id) REFERENCES serials(id)\n  );\n\n  CREATE TABLE IF NOT EXISTS archive_revisions (\n    key TEXT PRIMARY KEY,\n    value INTEGER NOT NULL\n  );\n\n  CREATE TABLE IF NOT EXISTS archive_index_settings (\n    id INTEGER PRIMARY KEY CHECK (id = 1),\n    fts_embedded INTEGER NOT NULL DEFAULT 0\n  );\n\n  CREATE TABLE IF NOT EXISTS graph_build_parameters (\n    hash TEXT PRIMARY KEY,\n    prompt TEXT NOT NULL,\n    language TEXT,\n    created_at TEXT NOT NULL\n  );\n\n  CREATE TABLE IF NOT EXISTS chunks (\n    id INTEGER PRIMARY KEY,\n    generation INTEGER NOT NULL,\n    serial_id INTEGER NOT NULL,\n    sentence_index INTEGER NOT NULL,\n    label TEXT NOT NULL,\n    content TEXT NOT NULL,\n    retention TEXT,\n    importance TEXT,\n    wordsCount INTEGER NOT NULL DEFAULT 0,\n    weight REAL NOT NULL DEFAULT 0.0\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_chunks_sentence\n  ON chunks(serial_id, sentence_index);\n\n  CREATE INDEX IF NOT EXISTS idx_chunks_serial_id\n  ON chunks(serial_id, id);\n\n  CREATE TABLE IF NOT EXISTS chunk_sentences (\n    chunk_id INTEGER NOT NULL,\n    serial_id INTEGER NOT NULL,\n    sentence_index INTEGER NOT NULL,\n    FOREIGN KEY (chunk_id) REFERENCES chunks(id),\n    PRIMARY KEY (chunk_id, serial_id, sentence_index)\n  );\n\n  CREATE TABLE IF NOT EXISTS reading_edges (\n    from_id INTEGER NOT NULL,\n    to_id INTEGER NOT NULL,\n    strength TEXT,\n    weight REAL NOT NULL DEFAULT 0.1,\n    PRIMARY KEY (from_id, to_id),\n    FOREIGN KEY (from_id) REFERENCES chunks(id),\n    FOREIGN KEY (to_id) REFERENCES chunks(id)\n  );\n\n  CREATE TABLE IF NOT EXISTS snakes (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    serial_id INTEGER NOT NULL,\n    group_id INTEGER NOT NULL,\n    local_snake_id INTEGER NOT NULL,\n    size INTEGER NOT NULL,\n    first_label TEXT NOT NULL,\n    last_label TEXT NOT NULL,\n    wordsCount INTEGER NOT NULL DEFAULT 0,\n    weight REAL NOT NULL DEFAULT 0.0,\n    UNIQUE(serial_id, group_id, local_snake_id)\n  );\n\n  CREATE TABLE IF NOT EXISTS snake_chunks (\n    snake_id INTEGER NOT NULL,\n    chunk_id INTEGER NOT NULL,\n    position INTEGER NOT NULL,\n    FOREIGN KEY (snake_id) REFERENCES snakes(id),\n    FOREIGN KEY (chunk_id) REFERENCES chunks(id),\n    PRIMARY KEY (snake_id, chunk_id)\n  );\n\n  CREATE TABLE IF NOT EXISTS snake_edges (\n    from_snake_id INTEGER NOT NULL,\n    to_snake_id INTEGER NOT NULL,\n    weight REAL NOT NULL DEFAULT 0.1,\n    PRIMARY KEY (from_snake_id, to_snake_id),\n    FOREIGN KEY (from_snake_id) REFERENCES snakes(id),\n    FOREIGN KEY (to_snake_id) REFERENCES snakes(id)\n  );\n\n  CREATE TABLE IF NOT EXISTS sentence_groups (\n    serial_id INTEGER NOT NULL,\n    group_id INTEGER NOT NULL,\n    start_sentence_index INTEGER NOT NULL,\n    end_sentence_index INTEGER NOT NULL,\n    PRIMARY KEY (serial_id, group_id, start_sentence_index, end_sentence_index)\n  );\n\n  CREATE TABLE IF NOT EXISTS mentions (\n    id TEXT PRIMARY KEY,\n    chapter_id INTEGER NOT NULL,\n    sentence_index INTEGER,\n    range_start INTEGER NOT NULL,\n    range_end INTEGER NOT NULL,\n    surface TEXT NOT NULL,\n    qid TEXT NOT NULL,\n    confidence REAL,\n    note TEXT,\n    FOREIGN KEY (chapter_id) REFERENCES serials(id)\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_chapter\n  ON mentions(chapter_id);\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_chapter_position\n  ON mentions(chapter_id, sentence_index, range_start, range_end, id);\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_chapter_qid\n  ON mentions(chapter_id, qid);\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_qid\n  ON mentions(qid);\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_qid_position\n  ON mentions(qid, chapter_id, sentence_index, range_start, range_end, id);\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_surface\n  ON mentions(surface);\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_surface_position\n  ON mentions(surface, chapter_id, sentence_index, range_start, range_end, id);\n\n  CREATE INDEX IF NOT EXISTS idx_mentions_sentence\n  ON mentions(chapter_id, sentence_index);\n\n  CREATE TABLE IF NOT EXISTS mention_links (\n    id TEXT PRIMARY KEY,\n    source_mention_id TEXT NOT NULL,\n    target_mention_id TEXT NOT NULL,\n    predicate TEXT NOT NULL,\n    confidence REAL,\n    note TEXT,\n    FOREIGN KEY (source_mention_id) REFERENCES mentions(id),\n    FOREIGN KEY (target_mention_id) REFERENCES mentions(id)\n  );\n\n  CREATE TABLE IF NOT EXISTS mention_link_evidence_sentences (\n    link_id TEXT NOT NULL,\n    chapter_id INTEGER NOT NULL,\n    sentence_index INTEGER NOT NULL,\n    FOREIGN KEY (link_id) REFERENCES mention_links(id),\n    PRIMARY KEY (link_id, chapter_id, sentence_index)\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_mention_link_evidence_sentences_sentence\n  ON mention_link_evidence_sentences(chapter_id, sentence_index);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_source\n  ON mention_links(source_mention_id);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_target\n  ON mention_links(target_mention_id);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_predicate\n  ON mention_links(predicate);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_predicate_source_target\n  ON mention_links(predicate, source_mention_id, target_mention_id);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_predicate_target_source\n  ON mention_links(predicate, target_mention_id, source_mention_id);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_source_predicate_target\n  ON mention_links(source_mention_id, predicate, target_mention_id);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_target_predicate_source\n  ON mention_links(target_mention_id, predicate, source_mention_id);\n\n  CREATE INDEX IF NOT EXISTS idx_mention_links_source_target_predicate\n  ON mention_links(source_mention_id, target_mention_id, predicate);\n\n  CREATE INDEX IF NOT EXISTS idx_reading_edges_target\n  ON reading_edges(to_id, from_id);\n\n  CREATE INDEX IF NOT EXISTS idx_snake_edges_target\n  ON snake_edges(to_snake_id, from_snake_id);\n\n  CREATE VIEW IF NOT EXISTS chapter_entities AS\n  SELECT\n    chapter_id,\n    qid,\n    COUNT(*) AS mention_count\n  FROM mentions\n  GROUP BY chapter_id, qid;\n\n  CREATE VIEW IF NOT EXISTS book_entities AS\n  SELECT\n    qid,\n    SUM(mention_count) AS mention_count\n  FROM chapter_entities\n  GROUP BY qid;\n\n  CREATE VIEW IF NOT EXISTS chapter_entity_relations AS\n  SELECT\n    source_mentions.chapter_id AS chapter_id,\n    source_mentions.qid AS subject_qid,\n    mention_links.predicate AS predicate,\n    target_mentions.qid AS object_qid,\n    COUNT(*) AS evidence_count\n  FROM mention_links\n  JOIN mentions AS source_mentions\n    ON source_mentions.id = mention_links.source_mention_id\n  JOIN mentions AS target_mentions\n    ON target_mentions.id = mention_links.target_mention_id\n  WHERE source_mentions.chapter_id = target_mentions.chapter_id\n  GROUP BY\n    source_mentions.chapter_id,\n    source_mentions.qid,\n    mention_links.predicate,\n    target_mentions.qid;\n\n  CREATE VIEW IF NOT EXISTS book_entity_relations AS\n  SELECT\n    subject_qid,\n    predicate,\n    object_qid,\n    SUM(evidence_count) AS evidence_count\n  FROM chapter_entity_relations\n  GROUP BY subject_qid, predicate, object_qid;\n\n  CREATE TABLE IF NOT EXISTS text_sentence_records (\n    id INTEGER PRIMARY KEY,\n    kind INTEGER NOT NULL,\n    chapter_id INTEGER NOT NULL,\n    sentence_index INTEGER NOT NULL,\n    words_count INTEGER NOT NULL DEFAULT 0,\n    byte_offset INTEGER NOT NULL DEFAULT 0,\n    byte_length INTEGER NOT NULL DEFAULT 0,\n    UNIQUE(kind, chapter_id, sentence_index)\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_text_sentence_records_chapter\n  ON text_sentence_records(kind, chapter_id, sentence_index);\n\n  CREATE TABLE IF NOT EXISTS object_metadata (\n    id INTEGER PRIMARY KEY,\n    object_kind INTEGER NOT NULL,\n    object_path TEXT NOT NULL,\n    key TEXT NOT NULL,\n    value_json TEXT NOT NULL,\n    updated_at TEXT NOT NULL,\n    chapter_id INTEGER,\n    chunk_id INTEGER,\n    entity_qid TEXT,\n    triple_subject_qid TEXT,\n    triple_predicate TEXT,\n    triple_object_qid TEXT,\n    UNIQUE(object_path, key)\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_object_metadata_object\n  ON object_metadata(object_path);\n\n  CREATE INDEX IF NOT EXISTS idx_object_metadata_chapter\n  ON object_metadata(chapter_id);\n\n  CREATE INDEX IF NOT EXISTS idx_object_metadata_chunk\n  ON object_metadata(chunk_id);\n\n  CREATE INDEX IF NOT EXISTS idx_object_metadata_entity\n  ON object_metadata(entity_qid);\n\n  CREATE INDEX IF NOT EXISTS idx_object_metadata_triple\n  ON object_metadata(\n    triple_subject_qid,\n    triple_predicate,\n    triple_object_qid\n  );\n";
-
-declare const EVIDENCE_SELECTION_PROMPT_FRAGMENT: string;
-declare const EVIDENCE_SELECTION_JSON_SHAPE: readonly [{
-    readonly quote: "exact short source quote copied from the selected sentence";
-    readonly sentence_id: "sentence id from the source context, such as S1";
-}];
-declare function formatEvidenceSelectionChoicePrompt(input: {
-    readonly evidenceLabel: string;
-    readonly generatedEvidence: unknown;
-    readonly candidates: readonly {
-        readonly nextText: string;
-        readonly occurrenceId: string;
-        readonly prevText: string;
-        readonly score: number;
-        readonly text: string;
-    }[];
-}): string;
 
-type EvidenceQuoteMatchStrategy = "empty" | "exact" | "normalized_exact" | "normalized_substring" | "fuzzy_window";
-interface EvidenceQuoteScore {
-    readonly exactRaw: boolean;
-    readonly exactNormalized: boolean;
-    readonly exactSubstring: boolean;
-    readonly matchEnd: number;
-    readonly matchStart: number;
-    readonly normalizedQuote: string;
-    readonly normalizedSentence: string;
-    readonly score: number;
-    readonly strategy: EvidenceQuoteMatchStrategy;
+interface GraphNode {
+    readonly content: string;
+    readonly id: number;
+    readonly importance?: ChunkImportance;
+    readonly label: string;
+    readonly retention?: ChunkRetention;
+    readonly sentenceIds: readonly SentenceId[];
+    readonly weight: number;
+    readonly wordsCount: number;
 }
-declare function normalizeEvidenceDisplayText(text: string): string;
-declare function normalizeEvidenceText(text: string): string;
-declare function scoreEvidenceQuote(input: {
-    readonly quote: string;
-    readonly sentence: string;
-}): EvidenceQuoteScore;
-
-type EvidenceSentenceId = readonly [number, number];
-interface EvidenceSelectionSentence {
-    readonly id: string;
-    readonly sentenceId: EvidenceSentenceId;
-    readonly text: string;
+interface GraphEdge {
+    readonly fromId: number;
+    readonly strength?: string;
+    readonly toId: number;
+    readonly weight: number;
 }
-interface EvidenceSelection {
-    readonly quote?: string;
-    readonly sentence_id?: string;
+interface GraphNeighbor {
+    readonly direction: "incoming" | "outgoing";
+    readonly edge: GraphEdge;
+    readonly node: GraphNode;
 }
-type EvidenceSelectionList = EvidenceSelection | readonly EvidenceSelection[];
-interface EvidenceSelectionCandidate {
-    readonly exactNormalized: boolean;
-    readonly exactRaw: boolean;
-    readonly exactSubstring: boolean;
-    readonly index: number;
-    readonly nextText: string;
-    readonly occurrenceId: string;
-    readonly prevText: string;
-    readonly score: number;
-    readonly sentence: EvidenceSelectionSentence;
-    readonly strategy: string;
+
+declare const CHAPTER_STAGES: readonly ["planned", "sourced", "graphed", "summarized"];
+type ChapterStage = (typeof CHAPTER_STAGES)[number];
+interface ChapterEntry {
+    readonly chapterId: number;
+    readonly childCount: number;
+    readonly depth: number;
+    readonly documentOrder: number;
+    readonly fragmentCount: number;
+    readonly key: string;
+    readonly path: string;
+    readonly stage: ChapterStage;
+    readonly title: string | null;
+    readonly tocPath: readonly string[];
+    readonly uri: string;
+    readonly words: number;
 }
-interface EvidenceSelectionResolution {
-    readonly candidate: EvidenceSelectionCandidate;
-    readonly confidence: number;
-    readonly sentenceIds: readonly EvidenceSentenceId[];
-    readonly strategy: string;
+interface ChapterDetails extends ChapterEntry {
+    readonly graphReady: boolean;
+    readonly hasSummary: boolean;
+    readonly words: number;
 }
-interface EvidenceSelectionFailure {
-    readonly candidates: readonly EvidenceSelectionCandidate[];
-    readonly code: "ambiguous" | "invalid" | "low_confidence" | "missing_sentence" | "none";
-    readonly message: string;
+interface ChapterTree {
+    readonly chapters: readonly ChapterTreeNode[];
+}
+interface ChapterTreeNode {
+    readonly children: readonly ChapterTreeNode[];
+    readonly title: string | null;
+    readonly uri: string;
 }
 
-declare function resolveEvidenceSelection(input: {
-    readonly evidence: EvidenceSelection;
-    readonly sentences: readonly EvidenceSelectionSentence[];
-}): readonly [
-    resolution: EvidenceSelectionResolution | undefined,
-    failure: EvidenceSelectionFailure | undefined
-];
-declare function resolveEvidenceSelectionList(input: {
-    readonly evidence: EvidenceSelectionList;
-    readonly sentences: readonly EvidenceSelectionSentence[];
-}): readonly [
-    resolution: EvidenceSelectionResolution | undefined,
-    failure: EvidenceSelectionFailure | undefined
-];
-declare function rankEvidenceQuote(quote: string, sentences: readonly EvidenceSelectionSentence[]): EvidenceSelectionCandidate[];
+declare function getChapterDetails(document: ReadonlyDocument, chapterId: number): Promise<ChapterDetails>;
+declare function listChapters(document: ReadonlyDocument): Promise<readonly ChapterEntry[]>;
+declare function getChapterTree(document: ReadonlyDocument): Promise<ChapterTree>;
 
-interface WikipageResolverOptions {
-    readonly cacheDatabasePath?: string;
-    readonly concurrency?: number;
-    readonly fetch?: typeof fetch;
-    readonly language?: string;
-    readonly logDirPath?: string;
-    readonly maxBatchSize?: number;
-    readonly minRequestIntervalMs?: number;
-    readonly normalizer?: DisambiguationProfileNormalizer;
-    readonly progress?: WikipageResolveProgressReporter;
-    readonly retryBaseDelayMs?: number;
-    readonly retryTimes?: number;
-    readonly userAgent?: string;
-    readonly wiki?: string;
+type ArchiveObjectType = "chapter" | "chapter-title" | "chapter-tree" | "edge" | "entity" | "fragment" | "meta" | "node" | "source" | "state" | "summary" | "triple";
+type ChapterStateTarget = "knowledge-graph" | "reading-graph" | "reading-summary" | "source";
+type ChapterStateValue = "missing" | "ready";
+type ChapterState = Record<ChapterStateTarget, ChapterStateValue>;
+type ArchiveCollectionType = "chapter" | "chapter-title" | "entity" | "fragment" | "meta" | "node" | "source" | "summary" | "triple";
+type ArchiveFindObjectType = "chapter" | "chapter-title" | "chapter-tree" | "entity" | "fragment" | "meta" | "node" | "source" | "summary" | "triple";
+type ArchiveFindFilterType = "chapter" | "chapter-title" | "entity" | "fragment" | "meta" | "node" | "source" | "summary" | "triple";
+interface ArchiveIndex {
+    readonly chapters: readonly ChapterEntry[];
+    readonly edgeCount: number;
+    readonly meta: BookMeta | undefined;
+    readonly nodeCount: number;
+    readonly summaryCount: number;
 }
-type WikipageResolveProgressDetail = "disambiguation-page" | "entity" | "linked-page" | "page" | "qid";
-interface WikipageResolveProgress {
-    readonly detail: WikipageResolveProgressDetail;
-    readonly done: number;
-    readonly total: number;
+interface ArchiveLibrarySourceFields {
+    readonly archiveId?: number;
+    readonly libraryArchiveUri?: string;
+    readonly sources?: readonly ArchiveLibrarySource[];
 }
-type WikipageResolveProgressReporter = (event: WikipageResolveProgress) => Promise<void> | void;
-interface QidResolution {
-    readonly description?: string;
-    readonly disambiguation?: DisambiguationExpansion;
-    readonly disambiguationPages?: readonly DisambiguationPageText[];
-    readonly isDisambiguation: boolean;
-    readonly label?: string;
-    readonly qid: string;
-    readonly sitelink?: WikipageSitelink;
-    readonly sitelinks?: readonly WikipageSitelink[];
+interface ArchiveLibrarySource {
+    readonly archiveId: number;
+    readonly libraryArchiveUri: string;
 }
-interface WikipageSitelink {
+interface ArchiveFindHit extends ArchiveLibrarySourceFields {
+    readonly backlinks?: ArchiveBacklinks;
+    readonly chapter?: number;
+    readonly evidence?: ArchiveFindEvidencePreview;
+    readonly evidenceLinks?: readonly MentionLinkRecord[];
+    readonly evidenceMentions?: readonly EntityEvidenceMention[];
+    readonly field: ArchiveFindField;
+    readonly id: string;
+    readonly matchCount?: number;
+    readonly matchedTerms?: readonly string[];
+    readonly missingTerms?: readonly string[];
+    readonly position?: ArchiveFindPosition;
+    readonly score?: number;
+    readonly snippet: string;
+    readonly state?: ChapterState;
     readonly title: string;
-    readonly wiki: string;
+    readonly triple?: {
+        readonly objectLabel: string;
+        readonly predicate: string;
+        readonly subjectLabel: string;
+    };
+    readonly type: ArchiveFindObjectType;
 }
-interface DisambiguationExpansion {
-    readonly checkedAt: string;
-    readonly disambiguationQid: string;
-    readonly linkedQids: readonly DisambiguationLinkedQid[];
-    readonly pages: readonly DisambiguationPageText[];
-    readonly profile?: DisambiguationProfile;
+interface EntityEvidenceMention {
+    readonly match: Pick<ArchiveFindHit, "matchCount" | "matchedTerms" | "missingTerms" | "score">;
+    readonly mention: MentionRecord;
 }
-interface DisambiguationPageText {
-    readonly linkedQids: readonly DisambiguationLinkedQid[];
-    readonly pageId?: number;
-    readonly text: string;
-    readonly title: string;
-    readonly wiki: "enwiki" | "zhwiki";
+interface ArchiveFindEvidencePreview {
+    readonly nextCursor: string | null;
+    readonly shown: number;
+    readonly sources: readonly ArchiveEvidenceItem[];
+    readonly total: number;
 }
-interface DisambiguationLinkedQid {
-    readonly qid: string;
-    readonly title: string;
+type ArchiveFindField = "content" | "metadata" | "source" | "summary" | "title";
+interface ArchiveFindOptions {
+    readonly archiveKey?: string;
+    readonly backlinks?: boolean;
+    readonly chapters?: readonly number[];
+    readonly cursor?: string;
+    readonly evidenceLimit?: number;
+    readonly ids?: readonly string[];
+    readonly limit?: number;
+    readonly match?: ArchiveFindMatch;
+    readonly order?: ArchiveFindOrder;
+    readonly sourceContext?: number;
+    readonly triplePattern?: ArchiveTriplePattern;
+    readonly types?: readonly ArchiveFindFilterType[];
 }
-interface CachedQidRecord {
-    readonly checkedAt: string;
-    readonly description?: string;
-    readonly label?: string;
-    readonly qid: string;
-    readonly sitelinks: readonly CachedPageRecord[];
-    readonly updatedAt: string;
-}
-interface CachedDisambiguationRecord {
-    readonly checkedAt: string;
-    readonly disambiguationQid: string;
-    readonly pages: readonly DisambiguationPageText[];
-    readonly profile?: DisambiguationProfile;
-}
-interface CachedPageRecord {
-    readonly isDisambiguation: boolean;
-    readonly pageId?: number;
-    readonly title: string;
-    readonly wiki: "enwiki" | "zhwiki";
-}
-type DisambiguationMeaningPriority = "other" | "primary" | "secondary";
-interface DisambiguationProfile {
-    readonly meanings: readonly DisambiguationProfileMeaning[];
-    readonly sourceQid: string;
-    readonly surface?: string;
-}
-interface DisambiguationProfileMeaning {
-    readonly category?: string;
-    readonly information: string;
-    readonly name: string;
-    readonly priority: DisambiguationMeaningPriority;
-    readonly qid: string;
-}
-type DisambiguationProfileNormalizer = (input: DisambiguationProfileNormalizerInput) => Promise<DisambiguationProfile>;
-interface DisambiguationProfileNormalizerInput {
-    readonly pageQidLinks: readonly DisambiguationLinkedQid[];
-    readonly pages: readonly DisambiguationPageText[];
-    readonly sourceQid: string;
-    readonly surface?: string;
-}
-
-declare class WikipageCache {
-    #private;
-    constructor(database: Database);
-    static open(path?: string): Promise<WikipageCache>;
-    close(): Promise<void>;
-    getQids(qids: readonly string[], language: string): Promise<ReadonlyMap<string, CachedQidRecord>>;
-    putQids(records: readonly CachedQidRecord[], language: string): Promise<void>;
-    getDisambiguations(qids: readonly string[], wiki: string): Promise<ReadonlyMap<string, CachedDisambiguationRecord>>;
-    putDisambiguations(records: readonly CachedDisambiguationRecord[], wiki: string): Promise<void>;
+type ArchiveFindOrder = "doc-asc" | "doc-desc";
+type ArchiveFindMatch = "all" | "any";
+interface ArchiveFindPosition {
+    readonly chapter: number;
+    readonly documentOrder?: number;
+    readonly fragment?: number;
+    readonly sentence?: number;
 }
-
-type GuaranteedRequest = (messages: readonly LLMessage[], index: number, maxRetries: number) => Promise<string | undefined>;
-type GuaranteedLazyRequest = <T>(operation: (request: GuaranteedRequest) => Promise<T>) => Promise<T>;
-type GuaranteedRequestController = GuaranteedRequest & {
-    lazy?: GuaranteedLazyRequest;
-};
-
-interface CreateDisambiguationProfileNormalizerOptions {
-    readonly maxMeanings?: number;
-    readonly maxRetries?: number;
-    readonly request: GuaranteedRequest;
+interface ArchiveFindResult {
+    readonly chapters: readonly number[] | null;
+    readonly items: readonly ArchiveFindHit[];
+    readonly lens: ArchiveFindLens;
+    readonly lensHint: ArchiveFindLensHint | null;
+    readonly limit: number;
+    readonly match: ArchiveFindMatch;
+    readonly nextCursor: string | null;
+    readonly order: ArchiveFindOrder;
+    readonly query: string;
+    readonly terms: readonly string[];
+    readonly types: readonly ArchiveFindFilterType[] | null;
 }
-declare function createDisambiguationProfileNormalizer(options: CreateDisambiguationProfileNormalizerOptions): DisambiguationProfileNormalizer;
-
-interface RateLimiterOptions {
-    readonly concurrency: number;
-    readonly minRequestIntervalMs: number;
+type ArchiveFindLens = "broad" | "exact" | "typed";
+interface ArchiveFindLensHint {
+    readonly lenses: {
+        readonly chapter: string;
+        readonly chunk: string;
+        readonly entity: string;
+        readonly node: string;
+        readonly triple: string;
+    };
+    readonly message: string;
 }
-declare class RateLimiter {
-    #private;
-    constructor(options: RateLimiterOptions);
-    use<T>(operation: () => Promise<T>): Promise<T>;
-    blockFor(ms: number): void;
+interface ArchiveCollectionOptions {
+    readonly backlinks?: boolean;
+    readonly chapters?: readonly number[];
+    readonly cursor?: string;
+    readonly evidenceLimit?: number;
+    readonly ids?: readonly string[];
+    readonly limit?: number;
+    readonly order?: ArchiveFindOrder;
+    readonly sourceContext?: number;
+    readonly triplePattern?: ArchiveTriplePattern;
+    readonly types?: readonly ArchiveCollectionType[];
 }
-declare function parseRetryAfterMs(value: string | null): number | undefined;
-
-interface WikipageFetchLog {
-    readonly filePath: string | undefined;
-    append(entry: WikipageFetchLogEntry): Promise<void>;
-    warnFailed(): void;
+interface ArchiveTriplePattern {
+    readonly objectQid?: string;
+    readonly predicate?: string;
+    readonly subjectQid?: string;
 }
-interface WikipageFetchLogEntry {
-    readonly attempt: number;
-    readonly durationMs: number;
-    readonly error?: unknown;
-    readonly response?: Response;
-    readonly responseText?: string;
-    readonly startedAt: number;
-    readonly url: URL;
+interface ArchiveCollectionResult {
+    readonly chapters: readonly number[] | null;
+    readonly ids: readonly string[] | null;
+    readonly items: readonly ArchiveFindHit[];
+    readonly limit: number;
+    readonly nextCursor: string | null;
+    readonly order: ArchiveFindOrder;
+    readonly types: readonly ArchiveCollectionType[] | null;
 }
-
-type SupportedWiki = "enwiki" | "zhwiki";
-interface WikimediaClientOptions {
-    readonly concurrency: number;
-    readonly fetch?: typeof fetch;
-    readonly language: string;
-    readonly minRequestIntervalMs: number;
-    readonly requestLog: WikipageFetchLog;
-    readonly retryBaseDelayMs: number;
-    readonly retryTimes: number;
-    readonly userAgent?: string;
-    readonly wiki: string;
+interface ArchiveBacklinks {
+    readonly chunks: ArchiveBacklinkBucket;
+    readonly entities: ArchiveBacklinkBucket;
+    readonly triples: ArchiveBacklinkBucket;
 }
-interface WikidataEntityInfo {
-    readonly description?: string;
-    readonly label?: string;
-    readonly qid: string;
-    readonly sitelinks: readonly WikidataSitelinkInfo[];
+interface ArchiveBacklinkBucket {
+    readonly items: readonly ArchiveFindHit[];
+    readonly limit: number;
+    readonly nextCursor: string | null;
 }
-interface WikidataSitelinkInfo {
+type ArchiveListKind = "chapters" | "edges" | "fragments" | "meta" | "nodes" | "summaries";
+type ArchiveListItem = ArchiveLibrarySourceFields & ({
+    readonly evidence?: ArchiveFindEvidencePreview;
+    readonly id: string;
+    readonly label: string;
+    readonly score?: number;
+    readonly state?: ChapterState;
+    readonly summary: string;
+    readonly type: Exclude<ArchiveObjectType, "triple">;
+} | {
+    readonly evidence?: ArchiveFindEvidencePreview;
+    readonly id: string;
+    readonly label: string;
+    readonly evidenceLinks?: readonly MentionLinkRecord[];
+    readonly objectLabel: string;
+    readonly objectQid: string;
+    readonly predicate: string;
+    readonly score?: number;
+    readonly subjectLabel: string;
+    readonly subjectQid: string;
+    readonly summary: string;
+    readonly type: "triple";
+});
+type ArchivePage = ArchiveLibrarySourceFields & ({
+    readonly id: string;
+    readonly state: ChapterState;
     readonly title: string;
-    readonly wiki: SupportedWiki;
-}
-interface WikiPageInfo {
-    readonly isDisambiguation: boolean;
-    readonly pageId?: number;
+    readonly type: "chapter";
+} | {
+    readonly id: string;
     readonly title: string;
-    readonly wiki: SupportedWiki;
-    readonly wikibaseItem?: string;
-}
-interface ParsedDisambiguationPage {
-    readonly linkedTitles: readonly string[];
-    readonly pageId?: number;
-    readonly text: string;
+    readonly type: "chapter-title";
+} | {
+    readonly id: string;
     readonly title: string;
-    readonly wiki: SupportedWiki;
-}
-declare class WikimediaClient {
-    #private;
-    constructor(options: WikimediaClientOptions);
-    getEntities(qids: readonly string[]): Promise<ReadonlyMap<string, WikidataEntityInfo>>;
-    getPagesByTitles(titles: readonly string[], wiki?: SupportedWiki): Promise<ReadonlyMap<string, WikiPageInfo>>;
-    parseDisambiguationPage(title: string, wiki: SupportedWiki): Promise<ParsedDisambiguationPage>;
-}
-
-declare class WikipageResolver {
-    #private;
-    constructor(input: {
-        readonly cache: WikipageCache;
-        readonly client: WikimediaClient;
-        readonly language: string;
-        readonly maxBatchSize: number;
-        readonly normalizer: DisambiguationProfileNormalizer | undefined;
-        readonly ownsCache: boolean;
-        readonly progress: WikipageResolveProgressReporter | undefined;
-        readonly wiki: string;
-    });
-    static open(options?: WikipageResolverOptions): Promise<WikipageResolver>;
-    close(): Promise<void>;
-    resolveQids(qids: readonly string[]): Promise<readonly QidResolution[]>;
-}
-
-interface WikimatchCandidate {
-    readonly hasMoreOptions?: boolean;
+    readonly tree: ChapterTree;
+    readonly type: "chapter-tree";
+} | {
+    readonly generatedNodeSummary: string;
     readonly id: string;
-    readonly qidOptions: readonly WikimatchQidOption[];
-    readonly range: WikimatchTextRange;
-    readonly surface: string;
-}
-interface WikimatchSentence {
-    readonly id?: string;
-    readonly range: WikimatchTextRange;
-    readonly text: string;
-}
-interface WikimatchQidOption {
-    readonly description?: string;
-    readonly disambiguation?: DisambiguationExpansion;
-    readonly isDisambiguation?: boolean;
-    readonly label?: string;
+    readonly incoming: readonly GraphNeighbor[];
+    readonly neighbors: readonly GraphNeighbor[];
+    readonly outgoing: readonly GraphNeighbor[];
+    readonly position: ArchiveFindPosition | undefined;
+    readonly sourceFragments: readonly ArchiveNodeSourceFragment[];
+    readonly title: string;
+    readonly type: "node";
+} | {
+    readonly backlinks?: ArchiveBacklinks;
+    readonly fragment: ArchiveSourceFragment;
+    readonly id: string;
+    readonly nextFragmentId: string | undefined;
+    readonly nodes: readonly ArchiveNodeLabel[];
+    readonly previousFragmentId: string | undefined;
+    readonly title: string;
+    readonly type: "fragment";
+} | {
+    readonly content: string;
+    readonly id: string;
+    readonly title: string;
+    readonly type: "summary";
+} | {
+    readonly evidence: ArchiveFindEvidencePreview;
+    readonly id: string;
+    readonly label: string;
+    readonly labels: readonly string[];
+    readonly mentionCount: number;
     readonly qid: string;
-}
-interface WikimatchTextRange {
-    readonly end: number;
-    readonly start: number;
-}
-interface WikimatchWindow {
-    readonly baseOffset: number;
-    readonly candidates: readonly WikimatchCandidate[];
-    readonly groups: readonly WikimatchConflictGroup[];
-    readonly text: string;
-}
-interface WikimatchSurface {
+    readonly type: "entity";
+} | {
+    readonly en: ArchiveEntityWikipageLocale | null;
     readonly id: string;
-    readonly count: number;
-    readonly text: string;
-}
-interface WikimatchConflictGroup {
-    readonly candidateIds: readonly string[];
+    readonly type: "entity-wikipage";
+    readonly zh: ArchiveEntityWikipageLocale | null;
+} | {
+    readonly evidence: ArchiveFindEvidencePreview;
     readonly id: string;
-    readonly range: WikimatchTextRange;
+    readonly label: string;
+    readonly objectQid: string;
+    readonly predicate: string;
+    readonly subjectQid: string;
+    readonly type: "triple";
+} | {
+    readonly authors?: readonly string[];
+    readonly description?: string;
+    readonly id: string;
+    readonly publisher?: string;
+    readonly title: string;
+    readonly type: "meta";
+} | {
+    readonly id: string;
+    readonly state: ChapterState;
+    readonly type: "state";
+} | {
+    readonly id: string;
+    readonly target: ChapterStateTarget;
+    readonly type: "state";
+    readonly value: ChapterStateValue;
+});
+interface ArchiveEntityWikipageLocale {
+    readonly description?: string;
+    readonly title: string;
+    readonly url: string;
 }
-interface BuildWikimatchWindowsOptions {
-    readonly candidates: readonly WikimatchCandidate[];
-    readonly contextWords: number;
-    readonly optionBudget: number;
-    readonly text: string;
+interface ArchivePack {
+    readonly anchor: ArchivePage;
+    readonly budget: number;
+    readonly related: readonly ArchiveListItem[];
 }
-interface NarrowWikimatchCandidateOptionsInput {
-    readonly candidate: WikimatchCandidate;
-    readonly policyPrompt: string;
-    readonly text: string;
+type ArchiveRelatedRole = "any" | "object" | "self" | "subject";
+interface ArchiveRelatedOptions {
+    readonly cursor?: string;
+    readonly evidenceLimit?: number;
+    readonly limit?: number;
+    readonly order?: ArchiveFindOrder;
+    readonly query?: string;
+    readonly role?: ArchiveRelatedRole;
+    readonly sourceContext?: number;
 }
-interface WikimatchCandidateOptionNarrowingResult {
-    readonly candidate: WikimatchCandidate;
-    readonly fallback?: WikimatchCandidateOptionNarrowingFallback;
+interface ArchiveRelatedResult {
+    readonly items: readonly ArchiveListItem[];
+    readonly limit: number;
+    readonly nextCursor: string | null;
 }
-interface WikimatchCandidateOptionNarrowingFallback {
-    readonly issues: readonly string[];
-    readonly reason: "guaranteed_json_failed";
+interface ArchiveEvidence {
+    readonly items: readonly ArchiveEvidenceItem[];
+    readonly limit: number;
+    readonly nextCursor: string | null;
 }
-interface WikimatchCandidateOptionNarrowingResponse {
-    readonly qids: readonly WikimatchCandidateOptionNarrowingItemOutput[];
+interface ArchiveEvidenceItem extends ArchiveLibrarySourceFields {
+    readonly chapterId: number;
+    readonly endSentenceIndex: number;
+    readonly fragmentId?: number;
+    readonly id: string;
+    readonly score?: number;
+    readonly source: string;
+    readonly startSentenceIndex: number;
+    readonly title: string;
+    readonly type: "source";
 }
-interface WikimatchCandidateOptionNarrowingItemOutput {
-    readonly decision: "keep" | "reject";
-    readonly qid: string;
+interface ArchiveNodeLabel {
+    readonly id: string;
+    readonly title: string;
 }
-interface BuildWikimatchSurfaceProtectionInputOptions {
-    readonly candidates: readonly WikimatchCandidate[];
-    readonly percentile: number;
+interface ArchiveSourceFragment {
+    readonly fragmentId?: number;
+    readonly id: string;
+    readonly preview: string;
+    readonly sentenceCount: number;
     readonly text: string;
+    readonly wordsCount: number;
 }
-interface WikimatchSurfaceProtectionInput {
-    readonly policyPrompt: string;
-    readonly suspiciousSurfaces: readonly WikimatchSurface[];
-}
-interface WikimatchSurfaceProtectionBuildResult {
-    readonly candidates: readonly WikimatchCandidate[];
-    readonly suppressedCandidates: readonly WikimatchCandidate[];
-    readonly suspiciousSurfaces: readonly WikimatchSurface[];
-}
-interface WikimatchSurfaceProtectionResult {
-    readonly fallback?: WikimatchSurfaceProtectionFallback;
-    readonly protectedSurfaces: readonly WikimatchProtectedSurface[];
-}
-interface WikimatchProtectedSurface {
-    readonly note?: string;
-    readonly surfaceId: string;
+interface ArchiveNodeSourceFragment {
+    readonly id: string;
     readonly text: string;
+    readonly truncated: boolean;
 }
-interface WikimatchSurfaceProtectionFallback {
-    readonly issues: readonly string[];
-    readonly reason: "guaranteed_json_failed";
-}
-interface WikimatchProtectedSurfaceOutput {
-    readonly note?: string;
-    readonly surfaceId: string;
-}
-interface WikimatchSurfaceProtectionResponse {
-    readonly protectedSurfaces: readonly WikimatchProtectedSurfaceOutput[];
-}
-type WikimatchPolicyDecision = "continue" | "never_recall" | "recall" | "skip_this_time";
-interface WikimatchPolicyJudgeInput {
-    readonly candidates: readonly WikimatchCandidate[];
-    readonly policyPrompt: string;
-    readonly window: WikimatchWindow;
-}
-interface WikimatchPolicyJudgeResult {
-    readonly continuations: readonly WikimatchPolicyContinuation[];
-    readonly fallback?: WikimatchPolicyFallback;
-    readonly mentions: readonly WikimatchAcceptedMention[];
-    readonly policyUpdates: readonly WikimatchPolicyUpdate[];
-}
-interface WikimatchAcceptedMention {
-    readonly candidateId: string;
-    readonly confidence?: number;
-    readonly qid: string;
-    readonly range: WikimatchTextRange;
-    readonly note?: string;
-    readonly surface: string;
-}
-interface WikimatchPolicyUpdate {
-    readonly candidateId: string;
-    readonly decision: Exclude<WikimatchPolicyDecision, "recall" | "continue">;
-    readonly note?: string;
-    readonly qid?: string;
-    readonly surface: string;
-}
-interface WikimatchPolicyContinuation {
-    readonly candidateIds: readonly string[];
-    readonly groupId: string;
-}
-interface WikimatchPolicyFallback {
-    readonly issues: readonly string[];
-    readonly reason: "guaranteed_json_failed";
-}
-interface WikimatchPolicyDecisionOutput {
-    readonly candidateId: string;
-    readonly confidence?: number;
-    readonly decision: WikimatchPolicyDecision;
-    readonly qid?: string;
+interface ArchiveEvidenceOptions {
+    readonly cursor?: string;
+    readonly limit?: number;
+    readonly order?: ArchiveFindOrder;
+    readonly query?: string;
+    readonly sourceContext?: number;
 }
-interface WikimatchPolicyGroupOutput {
-    readonly decisions: readonly WikimatchPolicyDecisionOutput[];
-    readonly groupId: string;
+
+declare function findArchiveObjects(document: ReadonlyDocument, query: string, options?: ArchiveFindOptions): Promise<ArchiveFindResult>;
+declare function grepArchiveObjects(document: ReadonlyDocument, query: string, options?: ArchiveFindOptions): Promise<ArchiveFindResult>;
+
+declare const TEXT_SENTENCE_KIND: {
+    readonly source: 1;
+    readonly summary: 2;
+};
+type TextSentenceKind = (typeof TEXT_SENTENCE_KIND)[keyof typeof TEXT_SENTENCE_KIND];
+declare const SEARCH_OBJECT_PROPERTY_OWNER_KIND: {
+    readonly chapter: 1;
+    readonly chunk: 2;
+    readonly entity: 3;
+};
+type SearchObjectPropertyOwnerKind = (typeof SEARCH_OBJECT_PROPERTY_OWNER_KIND)[keyof typeof SEARCH_OBJECT_PROPERTY_OWNER_KIND];
+declare const SEARCH_OBJECT_PROPERTY_KIND: {
+    readonly title: 1;
+    readonly label: 1;
+    readonly content: 2;
+    readonly surface: 1;
+};
+type SearchObjectPropertyKind = (typeof SEARCH_OBJECT_PROPERTY_KIND)[keyof typeof SEARCH_OBJECT_PROPERTY_KIND];
+type SearchIndexProgressPhase = "checking" | "clearing" | "collecting" | "finalizing" | "indexing-objects" | "indexing-text";
+interface SearchIndexProgressEvent {
+    readonly done?: number;
+    readonly phase: SearchIndexProgressPhase;
+    readonly total?: number;
+    readonly unit?: "chapter" | "object" | "sentence";
 }
-interface WikimatchPolicyResponse {
-    readonly groups: readonly WikimatchPolicyGroupOutput[];
+type SearchIndexProgressReporter = (event: SearchIndexProgressEvent) => void | Promise<void>;
+interface SearchIndexTextHit {
+    readonly archiveId: number;
+    readonly chapterId: number;
+    readonly kind: TextSentenceKind;
+    readonly rank: number;
+    readonly score: number;
+    readonly sentenceIndex: number;
+    readonly wordsCount: number;
 }
-
-interface JudgeWikimatchPolicyOptions extends WikimatchPolicyJudgeInput {
-    readonly maxRetries?: number;
-    readonly request: GuaranteedRequest;
+interface SearchIndexObjectHit {
+    readonly archiveId: number;
+    readonly chapterId?: number;
+    readonly ownerId: string;
+    readonly ownerKind: SearchObjectPropertyOwnerKind;
+    readonly propertyKind: SearchObjectPropertyKind;
+    readonly score: number;
 }
-declare function judgeWikimatchPolicy(options: JudgeWikimatchPolicyOptions): Promise<WikimatchPolicyJudgeResult>;
-declare function parsePolicyResponse(candidates: readonly WikimatchCandidate[], response: WikimatchPolicyResponse, groups?: readonly WikimatchConflictGroup[]): WikimatchPolicyJudgeResult;
-declare function validatePolicyResponse(candidates: readonly WikimatchCandidate[], response: WikimatchPolicyResponse, groups?: readonly WikimatchConflictGroup[]): readonly string[];
-declare function formatCandidateForPrompt(candidate: WikimatchCandidate, _group?: WikimatchConflictGroup): object;
-
-interface NarrowWikimatchCandidateOptionsOptions extends NarrowWikimatchCandidateOptionsInput {
-    readonly maxRetries?: number;
-    readonly optionBudget: number;
-    readonly request: GuaranteedRequest;
+interface ArchiveIndexSettings {
+    readonly ftsEmbedded: boolean;
 }
-declare function narrowWikimatchCandidateOptions(options: NarrowWikimatchCandidateOptionsOptions): Promise<WikimatchCandidateOptionNarrowingResult>;
-declare function parseNarrowingResponse(candidate: WikimatchCandidate, response: WikimatchCandidateOptionNarrowingResponse): WikimatchCandidateOptionNarrowingResult;
-declare function validateNarrowingResponse(candidate: WikimatchCandidate, response: WikimatchCandidateOptionNarrowingResponse): readonly string[];
-
-declare function countWikimatchCandidateOptions(candidate: WikimatchCandidate): number;
-declare function countWikimatchQidOption(option: WikimatchQidOption): number;
-declare function listCandidateSelectableQids(candidate: WikimatchCandidate): readonly string[];
-declare function filterCandidateQidOptions(candidate: WikimatchCandidate, allowedQids: ReadonlySet<string>): WikimatchCandidate;
-declare function splitCandidateByOptionBudget(candidate: WikimatchCandidate, optionBudget: number): readonly WikimatchCandidate[];
-declare function sliceCandidateByOptionBudget(candidate: WikimatchCandidate, optionBudget: number, offset: number): {
-    readonly candidate: WikimatchCandidate;
-    readonly nextOffset?: number;
-};
 
-declare function enrichWikimatchCandidates(candidates: readonly WikimatchCandidate[], options?: {
-    readonly progress?: WikipageResolveProgressReporter;
-    readonly resolverOptions?: Omit<WikipageResolverOptions, "progress">;
-}): Promise<readonly WikimatchCandidate[]>;
-declare function applyQidResolutions(candidates: readonly WikimatchCandidate[], resolutions: readonly QidResolution[]): readonly WikimatchCandidate[];
+declare function readArchiveIndexSettings(document: ReadonlyDocument): Promise<ArchiveIndexSettings>;
+declare function setFtsIndexEmbedded(document: Document, embedded: boolean): Promise<void>;
 
-interface JudgeWikimatchSurfaceProtectionOptions extends WikimatchSurfaceProtectionInput {
-    readonly maxRetries?: number;
-    readonly request: GuaranteedRequest;
+interface WikipageFetchLog {
+    readonly filePath: string | undefined;
+    append(entry: WikipageFetchLogEntry): Promise<void>;
+    warnFailed(): void;
 }
-declare function judgeWikimatchSurfaceProtection(options: JudgeWikimatchSurfaceProtectionOptions): Promise<WikimatchSurfaceProtectionResult>;
-declare function parseSurfaceProtectionResponse(surfaces: readonly WikimatchSurface[], response: WikimatchSurfaceProtectionResponse): WikimatchSurfaceProtectionResult;
-declare function validateSurfaceProtectionResponse(surfaces: readonly WikimatchSurface[], response: WikimatchSurfaceProtectionResponse): readonly string[];
-
-declare function buildWikimatchSurfaceProtectionInput(options: BuildWikimatchSurfaceProtectionInputOptions): WikimatchSurfaceProtectionBuildResult;
-
-interface SuppressContainedRangeInput {
-    readonly range: {
-        readonly end: number;
-        readonly start: number;
-    };
+interface WikipageFetchLogEntry {
+    readonly attempt: number;
+    readonly durationMs: number;
+    readonly error?: unknown;
+    readonly response?: Response;
+    readonly responseText?: string;
+    readonly startedAt: number;
+    readonly url: URL;
 }
-declare function suppressContainedRanges<T extends SuppressContainedRangeInput>(items: readonly T[]): readonly T[];
 
-interface MatchWikispineSentenceCandidatesOptions {
-    readonly command?: string;
-    readonly dataDir?: string;
-    readonly endpoint?: string;
+type SupportedWiki = "enwiki" | "zhwiki";
+interface WikimediaClientOptions {
+    readonly concurrency: number;
     readonly fetch?: typeof fetch;
-    readonly includeDisambiguation?: boolean;
-    readonly maxCandidatesPerSurface?: number;
-    readonly onProgress?: (progress: WikispineMatchProgress) => Promise<void> | void;
-    readonly provider?: WikispineProvider;
-    readonly sentences: readonly WikimatchSentence[];
+    readonly language: string;
+    readonly minRequestIntervalMs: number;
+    readonly requestLog: WikipageFetchLog;
+    readonly retryBaseDelayMs: number;
+    readonly retryTimes: number;
+    readonly userAgent?: string;
+    readonly wiki: string;
 }
-type WikispineProvider = "cli" | "fetch";
-interface WikispineMatchProgress {
-    readonly coveredRangeEnd: number;
+interface WikidataEntityInfo {
+    readonly description?: string;
+    readonly label?: string;
+    readonly qid: string;
+    readonly sitelinks: readonly WikidataSitelinkInfo[];
 }
-interface TestWikispineRuntimeOptions {
-    readonly command?: string;
-    readonly dataDir?: string;
-    readonly endpoint?: string;
-    readonly fetch?: typeof fetch;
-    readonly provider?: WikispineProvider;
+interface WikidataSitelinkInfo {
+    readonly title: string;
+    readonly wiki: SupportedWiki;
 }
-interface WikispineRuntimeTestResult {
-    readonly durationMs: number;
-    readonly metadata?: WikispineMetadata;
-    readonly ok: true;
-    readonly provider: WikispineProvider;
+interface WikiPageInfo {
+    readonly isDisambiguation: boolean;
+    readonly pageId?: number;
+    readonly title: string;
+    readonly wiki: SupportedWiki;
+    readonly wikibaseItem?: string;
 }
-interface WikispineMetadata {
-    readonly automaton_shard_count: number;
-    readonly format: string;
-    readonly qid_count: number;
-    readonly surface_count: number;
-    readonly surface_normalization: string;
+interface ParsedDisambiguationPage {
+    readonly linkedTitles: readonly string[];
+    readonly pageId?: number;
+    readonly text: string;
+    readonly title: string;
+    readonly wiki: SupportedWiki;
 }
-declare const DEFAULT_WIKISPINE_FETCH_ENDPOINT = "https://wikispi-service-cxbfjlteab.cn-hangzhou.fcapp.run";
-declare function matchWikispineSentenceCandidates(options: MatchWikispineSentenceCandidatesOptions): Promise<readonly WikimatchCandidate[]>;
-declare function testWikispineRuntime(options: TestWikispineRuntimeOptions): Promise<WikispineRuntimeTestResult>;
-
-declare function buildWikimatchWindows(options: BuildWikimatchWindowsOptions): readonly WikimatchWindow[];
 
-interface WordBoundary {
-    readonly end: number;
-    readonly start: number;
+declare class WikimediaClient implements WikiClient {
+    #private;
+    constructor(options: WikimediaClientOptions);
+    getEntities(qids: readonly string[]): Promise<ReadonlyMap<string, WikidataEntityInfo>>;
+    getPagesByTitles(titles: readonly string[], wiki?: SupportedWiki): Promise<ReadonlyMap<string, WikiPageInfo>>;
+    parseDisambiguationPage(title: string, wiki: SupportedWiki): Promise<ParsedDisambiguationPage>;
 }
-declare function listWordBoundaries(text: string): readonly WordBoundary[];
-declare function expandRangeByWords(input: {
-    readonly rangeEnd: number;
-    readonly rangeStart: number;
-    readonly text: string;
-    readonly words: number;
-}): {
-    readonly end: number;
-    readonly start: number;
-};
-
-type WikiGraphSamplingConfig = SamplingScopeConfig<WikiGraphScope>;
-declare function createDefaultWikiGraphSampling(input?: {
-    readonly temperature?: TemperatureSetting;
-    readonly topP?: TemperatureSetting;
-}): WikiGraphSamplingConfig;
 
-type WikiGraphOperation = "digest-epub" | "digest-markdown" | "digest-text-stream" | "digest-txt";
-interface SerialDiscoveryItem {
-    readonly id: number;
-    readonly fragments?: number | undefined;
-    readonly title?: string | undefined;
-    readonly words: number;
+interface WikipageResolverOptions {
+    readonly cacheDatabasePath?: string;
+    readonly concurrency?: number;
+    readonly fetch?: typeof fetch;
+    readonly language?: string;
+    readonly logDirPath?: string;
+    readonly maxBatchSize?: number;
+    readonly minRequestIntervalMs?: number;
+    readonly normalizer?: DisambiguationProfileNormalizer;
+    readonly progress?: WikipageResolveProgressReporter;
+    readonly retryBaseDelayMs?: number;
+    readonly retryTimes?: number;
+    readonly userAgent?: string;
+    readonly wiki?: string;
 }
-interface SerialsDiscoveredEvent {
-    readonly type: "serials-discovered";
-    readonly available: boolean;
-    readonly serials: readonly SerialDiscoveryItem[];
+interface WikiClient {
+    /** Runtime adapter for reading Wikimedia/Wikidata data; local CLI uses WikimediaClient. */
+    readonly getEntities: (qids: readonly string[]) => Promise<ReadonlyMap<string, WikidataEntityInfo>>;
+    readonly getPagesByTitles: (titles: readonly string[], wiki?: SupportedWiki) => Promise<ReadonlyMap<string, WikiPageInfo>>;
+    readonly parseDisambiguationPage: (title: string, wiki: SupportedWiki) => Promise<ParsedDisambiguationPage>;
 }
-interface SerialProgressEvent {
-    readonly type: "serial-progress";
-    readonly id: number;
-    readonly completedWords: number;
-    readonly completedFragments: number;
+interface EnrichmentStore {
+    /** Runtime adapter for enrichment cache reads and writes; local CLI uses WikipageCache. */
+    readonly getQids: (qids: readonly string[], language: string) => Promise<ReadonlyMap<string, CachedQidRecord>>;
+    readonly putQids: (records: readonly CachedQidRecord[], language: string) => Promise<void>;
+    readonly getDisambiguations: (qids: readonly string[], wiki: string) => Promise<ReadonlyMap<string, CachedDisambiguationRecord>>;
+    readonly putDisambiguations: (records: readonly CachedDisambiguationRecord[], wiki: string) => Promise<void>;
 }
-interface DigestProgressEvent {
-    readonly type: "digest-progress";
-    readonly completedWords: number;
-    readonly totalWords: number;
+type WikipageResolveProgressDetail = "disambiguation-page" | "entity" | "linked-page" | "page" | "qid";
+interface WikipageResolveProgress {
+    readonly detail: WikipageResolveProgressDetail;
+    readonly done: number;
+    readonly total: number;
 }
-type WikiGraphProgressEventType = WikiGraphProgressEvent["type"];
-type WikiGraphProgressEvent = SerialsDiscoveredEvent | SerialProgressEvent | DigestProgressEvent;
-type WikiGraphProgressCallback = (event: WikiGraphProgressEvent) => void | Promise<void>;
-
-type TextStream = AsyncIterable<string> | Iterable<string>;
-
-type ReaderTextStream = TextStream;
-
-interface SerialProgressSink {
-    begin?(input?: {
-        readonly fragments: number;
-        readonly words: number;
-    }): Promise<void>;
-    advance(wordsCount: number): Promise<void>;
-    complete(finalWordsCount?: number): Promise<void>;
+type WikipageResolveProgressReporter = (event: WikipageResolveProgress) => Promise<void> | void;
+interface QidResolution {
+    readonly description?: string;
+    readonly disambiguation?: DisambiguationExpansion;
+    readonly disambiguationPages?: readonly DisambiguationPageText[];
+    readonly isDisambiguation: boolean;
+    readonly label?: string;
+    readonly qid: string;
+    readonly sitelink?: WikipageSitelink;
+    readonly sitelinks?: readonly WikipageSitelink[];
 }
-
-declare const CHAPTER_STAGES: readonly ["planned", "sourced", "graphed", "summarized"];
-type ChapterStage = (typeof CHAPTER_STAGES)[number];
-interface ChapterEntry {
-    readonly chapterId: number;
-    readonly childCount: number;
-    readonly depth: number;
-    readonly documentOrder: number;
-    readonly fragmentCount: number;
-    readonly stage: ChapterStage;
-    readonly title: string | null;
-    readonly tocPath: readonly string[];
-    readonly words: number;
+interface WikipageSitelink {
+    readonly title: string;
+    readonly wiki: string;
+}
+interface DisambiguationExpansion {
+    readonly checkedAt: string;
+    readonly disambiguationQid: string;
+    readonly linkedQids: readonly DisambiguationLinkedQid[];
+    readonly pages: readonly DisambiguationPageText[];
+    readonly profile?: DisambiguationProfile;
+}
+interface DisambiguationPageText {
+    readonly linkedQids: readonly DisambiguationLinkedQid[];
+    readonly pageId?: number;
+    readonly text: string;
+    readonly title: string;
+    readonly wiki: "enwiki" | "zhwiki";
+}
+interface DisambiguationLinkedQid {
+    readonly qid: string;
+    readonly title: string;
+}
+interface CachedQidRecord {
+    readonly checkedAt: string;
+    readonly description?: string;
+    readonly label?: string;
+    readonly qid: string;
+    readonly sitelinks: readonly CachedPageRecord[];
+    readonly updatedAt: string;
+}
+interface CachedDisambiguationRecord {
+    readonly checkedAt: string;
+    readonly disambiguationQid: string;
+    readonly pages: readonly DisambiguationPageText[];
+    readonly profileError?: DisambiguationProfileError;
+    readonly profile?: DisambiguationProfile;
 }
-interface ChapterDetails extends ChapterEntry {
-    readonly graphReady: boolean;
-    readonly hasSummary: boolean;
-    readonly words: number;
+interface DisambiguationProfileError {
+    readonly failedAt: string;
+    readonly message: string;
+    readonly retryAfter: string;
 }
-interface ChapterTree {
-    readonly chapters: readonly ChapterTreeNode[];
+interface CachedPageRecord {
+    readonly isDisambiguation: boolean;
+    readonly pageId?: number;
+    readonly title: string;
+    readonly wiki: "enwiki" | "zhwiki";
 }
-interface ChapterTreeNode {
-    readonly children: readonly ChapterTreeNode[];
-    readonly id: number;
-    readonly title: string | null;
+type DisambiguationMeaningPriority = "other" | "primary" | "secondary";
+interface DisambiguationProfile {
+    readonly meanings: readonly DisambiguationProfileMeaning[];
+    readonly sourceQid: string;
+    readonly surface?: string;
 }
-interface ChapterTreeInput {
-    readonly chapters: readonly ChapterTreeInputNode[];
+interface DisambiguationProfileMeaning {
+    readonly category?: string;
+    readonly information: string;
+    readonly name: string;
+    readonly priority: DisambiguationMeaningPriority;
+    readonly qid: string;
 }
-interface ChapterTreeInputNode {
-    readonly children: readonly ChapterTreeInputNode[];
-    readonly id: number;
-    readonly title?: string | null | undefined;
+type DisambiguationProfileNormalizer = (input: DisambiguationProfileNormalizerInput) => Promise<DisambiguationProfile>;
+interface DisambiguationProfileNormalizerInput {
+    readonly pageQidLinks: readonly DisambiguationLinkedQid[];
+    readonly pages: readonly DisambiguationPageText[];
+    readonly sourceQid: string;
+    readonly surface?: string;
 }
-interface ChapterTreeApplyResult {
-    readonly changed: boolean;
-    readonly moved: readonly ChapterTreeMoveChange[];
-    readonly renamed: readonly ChapterTreeTitleChange[];
-    readonly unchanged: number;
+
+declare class WikipageCache implements EnrichmentStore {
+    #private;
+    constructor(database: Database);
+    static open(path?: string): Promise<WikipageCache>;
+    close(): Promise<void>;
+    getQids(qids: readonly string[], language: string): Promise<ReadonlyMap<string, CachedQidRecord>>;
+    putQids(records: readonly CachedQidRecord[], language: string): Promise<void>;
+    getDisambiguations(qids: readonly string[], wiki: string): Promise<ReadonlyMap<string, CachedDisambiguationRecord>>;
+    putDisambiguations(records: readonly CachedDisambiguationRecord[], wiki: string): Promise<void>;
 }
-interface ChapterTreeMoveChange {
-    readonly chapterId: number;
-    readonly newIndex: number;
-    readonly newParentChapterId: number | null;
-    readonly newPath: readonly string[];
-    readonly oldIndex: number;
-    readonly oldParentChapterId: number | null;
-    readonly oldPath: readonly string[];
+
+type GuaranteedRequest = (messages: readonly LLMessage[], index: number, maxRetries: number) => Promise<string | undefined>;
+type GuaranteedLazyRequest = <T>(operation: (request: GuaranteedRequest) => Promise<T>) => Promise<T>;
+type GuaranteedRequestController = GuaranteedRequest & {
+    lazy?: GuaranteedLazyRequest;
+};
+
+interface CreateDisambiguationProfileNormalizerOptions {
+    readonly maxMeanings?: number;
+    readonly maxRetries?: number;
+    readonly request: GuaranteedRequest;
 }
-interface ChapterTreeTitleChange {
-    readonly chapterId: number;
-    readonly newTitle: string | null;
-    readonly oldTitle: string | null;
+declare function createDisambiguationProfileNormalizer(options: CreateDisambiguationProfileNormalizerOptions): DisambiguationProfileNormalizer;
+
+interface RateLimiterOptions {
+    readonly concurrency: number;
+    readonly minRequestIntervalMs: number;
 }
-interface MoveChapterOptions {
-    readonly afterChapterId?: number;
-    readonly beforeChapterId?: number;
-    readonly first?: boolean;
-    readonly last?: boolean;
-    readonly parentChapterId?: number;
-    readonly root?: boolean;
+declare class RateLimiter {
+    #private;
+    constructor(options: RateLimiterOptions);
+    use<T>(operation: () => Promise<T>): Promise<T>;
+    blockFor(ms: number): void;
 }
-interface AdvanceChapterStagesOptions {
-    readonly chapterId?: number;
-    readonly extractionPrompt: string;
-    readonly llm: LLM<WikiGraphScope>;
-    readonly logDirPath?: string;
-    readonly onProgress?: AdvanceChapterStagesProgressCallback;
-    readonly targetStage: ChapterStage;
-    readonly userLanguage?: Language;
+declare function parseRetryAfterMs(value: string | null): number | undefined;
+
+declare class WikipageResolver {
+    #private;
+    constructor(input: {
+        readonly client: WikiClient;
+        readonly language: string;
+        readonly maxBatchSize: number;
+        readonly normalizer: DisambiguationProfileNormalizer | undefined;
+        readonly ownsStore?: boolean;
+        readonly progress: WikipageResolveProgressReporter | undefined;
+        readonly store: EnrichmentStore;
+        readonly wiki: string;
+    });
+    static open(options?: WikipageResolverOptions): Promise<WikipageResolver>;
+    close(): Promise<void>;
+    resolveQids(qids: readonly string[]): Promise<readonly QidResolution[]>;
 }
-interface AdvanceChapterStagesProgressState {
-    readonly graphWords: number;
-    readonly summaryWords: number;
-    readonly totalGraphWords: number;
-    readonly totalSummaryWords: number;
+
+interface ArchivePageOptions {
+    readonly backlinks?: boolean;
+    readonly evidenceLimit?: number;
+    readonly order?: ArchiveFindOrder;
+    readonly sourceContext?: number;
+    readonly wikipageResolverOptions?: WikipageResolverOptions;
 }
-type AdvanceChapterStagesProgressCallback = (event: AdvanceChapterStagesProgressEvent) => void | Promise<void>;
-type AdvanceChapterStagesProgressEvent = {
-    readonly type: "selected";
-    readonly state: AdvanceChapterStagesProgressState;
-    readonly targetStage: ChapterStage;
-    readonly totalChapters: number;
-} | {
-    readonly type: "skipped";
-    readonly chapter: ChapterEntry;
-    readonly reason: "planned";
-    readonly targetStage: ChapterStage;
-} | {
-    readonly type: "progress";
-    readonly state: AdvanceChapterStagesProgressState;
-    readonly targetStage: ChapterStage;
-} | {
-    readonly type: "started";
-    readonly chapter: ChapterEntry;
-    readonly step: "graph" | "summary";
-    readonly targetStage: ChapterStage;
-} | {
-    readonly type: "completed";
-    readonly chapter: ChapterEntry;
-    readonly step: "graph" | "summary";
-    readonly targetStage: ChapterStage;
+declare function readArchiveText(document: ReadonlyDocument, id: string): Promise<string>;
+declare function readArchivePage(document: ReadonlyDocument, id: string, options?: ArchivePageOptions): Promise<ArchivePage>;
+
+declare function listArchiveLinks(document: ReadonlyDocument, id: string, direction: "backlinks" | "links"): Promise<readonly GraphNeighbor[]>;
+declare function listAllArchiveLinks(document: ReadonlyDocument, id: string): Promise<readonly GraphNeighbor[]>;
+declare function listRelatedArchiveObjects(document: ReadonlyDocument, id: string, options?: ArchiveRelatedOptions): Promise<ArchiveRelatedResult>;
+
+declare function formatChapterId(chapterId: number): string;
+declare function formatEdgeId(edge: ReadingEdgeRecord): string;
+declare function formatNodeId(nodeId: number): string;
+declare function formatSummaryId(chapterId: number): string;
+
+declare function rebuildArchiveSearchIndex(document: Document, progress?: SearchIndexProgressReporter): Promise<void>;
+declare function isArchiveSearchIndexCurrent(document: ReadonlyDocument): Promise<boolean>;
+
+declare function getArchiveIndex(document: ReadonlyDocument): Promise<ArchiveIndex>;
+declare function listArchiveObjects(document: ReadonlyDocument, kind: ArchiveListKind): Promise<readonly ArchiveListItem[]>;
+declare function listArchiveCollection(document: ReadonlyDocument, options?: ArchiveCollectionOptions): Promise<ArchiveCollectionResult>;
+
+declare function listArchiveEvidence(document: ReadonlyDocument, uri: string, options?: ArchiveEvidenceOptions): Promise<ArchiveEvidence>;
+
+declare function packArchiveContext(document: ReadonlyDocument, id: string, budget: number): Promise<ArchivePack>;
+
+declare function findWikiGraphLibraryObjects(target: ParsedWikiGraphLibraryUri, query: string, options?: ArchiveFindOptions): Promise<ArchiveFindResult>;
+declare function listWikiGraphLibraryObjects(target: ParsedWikiGraphLibraryUri, options?: ArchiveCollectionOptions): Promise<ArchiveCollectionResult>;
+declare function readWikiGraphLibraryPage(target: ParsedWikiGraphLibraryUri, objectUri: string, options?: Parameters<typeof readArchivePage>[2]): Promise<ArchivePage>;
+declare function listWikiGraphLibraryEvidence(target: ParsedWikiGraphLibraryUri, objectUri: string, options?: ArchiveEvidenceOptions): Promise<ArchiveEvidence>;
+declare function listRelatedWikiGraphLibraryObjects(target: ParsedWikiGraphLibraryUri, objectUri: string, options?: ArchiveRelatedOptions): Promise<ArchiveRelatedResult>;
+declare function packWikiGraphLibraryContext(target: ParsedWikiGraphLibraryUri, objectUri: string, budget: number): Promise<ArchivePack>;
+declare function resolveWikiGraphLibraryQueryTargetById(libraryId: number): Promise<ParsedWikiGraphLibraryUri>;
+
+type WikiGraphLibraryIndexStatus = "current" | "dirty" | "disabled" | "missing";
+interface WikiGraphLibraryIndexSource {
+    readonly archiveId: number;
+    readonly archiveUri: string;
+    readonly exists: boolean;
+    readonly lastSeenMutationToken?: string;
+    readonly relativePath: string;
+    readonly status: string;
+}
+interface WikiGraphLibraryIndexState {
+    readonly enabled: boolean;
+    readonly fingerprint?: string;
+    readonly sourceFingerprint: string;
+    readonly sources: readonly WikiGraphLibraryIndexSource[];
+    readonly status: WikiGraphLibraryIndexStatus;
+}
+interface WikiGraphLibraryIndexQueryResult {
+    readonly objectHits: readonly WikiGraphLibraryIndexObjectHit[];
+    readonly terms: readonly string[];
+    readonly textHits: readonly WikiGraphLibraryIndexTextHit[];
+}
+interface WikiGraphLibraryIndexQueryOptions {
+    readonly chapters?: readonly number[];
+    readonly match?: ArchiveFindMatch;
+    readonly objectHitLimit?: number;
+    readonly textAfter?: {
+        readonly archiveId: number;
+        readonly chapterId: number;
+        readonly kind: TextSentenceKind;
+        readonly rank: number;
+        readonly sentenceIndex: number;
+    };
+    readonly textHitLimit?: number;
+    readonly types?: readonly ArchiveFindObjectType[] | null;
+}
+type WikiGraphLibraryIndexObjectHit = SearchIndexObjectHit & {
+    readonly archiveUri: string;
+    readonly libraryArchiveUri: string;
 };
-interface AdvanceChapterStagesResult {
-    readonly advanced: readonly ChapterEntry[];
-    readonly pending: readonly ChapterEntry[];
-    readonly skipped: readonly ChapterEntry[];
+type WikiGraphLibraryIndexTextHit = SearchIndexTextHit & {
+    readonly archiveUri: string;
+    readonly libraryArchiveUri: string;
+};
+declare function readWikiGraphLibraryIndexState(target: ParsedWikiGraphLibraryUri): Promise<WikiGraphLibraryIndexState>;
+declare function rebuildWikiGraphLibraryIndex(target: ParsedWikiGraphLibraryUri, progress?: SearchIndexProgressReporter): Promise<WikiGraphLibraryIndexState>;
+declare function disableWikiGraphLibraryIndex(target: ParsedWikiGraphLibraryUri): Promise<WikiGraphLibraryIndexState>;
+declare function markWikiGraphLibraryIndexDirty(targetOrLibrary: ParsedWikiGraphLibraryUri | WikiGraphLibraryRecord): Promise<void>;
+declare function queryWikiGraphLibrarySearchIndex(target: ParsedWikiGraphLibraryUri, query: string, options?: WikiGraphLibraryIndexQueryOptions): Promise<WikiGraphLibraryIndexQueryResult | undefined>;
+declare function listWikiGraphLibraryIndexArchiveIdsForObject(target: ParsedWikiGraphLibraryUri, objectUri: string): Promise<readonly number[]>;
+
+declare function resolveWikiGraphHomeDirectoryPath(): string;
+declare function withWikiGraphRuntimeStateDirectoryPath<T>(path: string | undefined, operation: () => Promise<T> | T): Promise<T>;
+/**
+ * @deprecated Runtime state overrides are no longer read from process-style
+ * environment objects. Use `withWikiGraphRuntimeStateDirectoryPath` instead.
+ */
+declare function withWikiGraphRuntimeEnvironment<T>(_environment: NodeJS.ProcessEnv, operation: () => Promise<T> | T): Promise<T>;
+declare function resolveWikiGraphCoreDatabasePath(): string;
+
+type WikiGraphTempCategory = "archive-open" | "archive-write" | "cli-output" | "sdpub-upgrade" | "stdin-create" | "url-create";
+declare function resolveWikiGraphStateRootPath(): string;
+declare function createWikiGraphTempDirectory(category: WikiGraphTempCategory): Promise<string>;
+
+declare const EVIDENCE_SELECTION_PROMPT_FRAGMENT: string;
+declare const EVIDENCE_SELECTION_JSON_SHAPE: readonly [{
+    readonly quote: "exact short source quote copied from the selected sentence";
+    readonly sentence_id: "sentence id from the source context, such as S1";
+}];
+declare function formatEvidenceSelectionChoicePrompt(input: {
+    readonly evidenceLabel: string;
+    readonly generatedEvidence: unknown;
+    readonly candidates: readonly {
+        readonly nextText: string;
+        readonly occurrenceId: string;
+        readonly prevText: string;
+        readonly score: number;
+        readonly text: string;
+    }[];
+}): string;
+
+type EvidenceQuoteMatchStrategy = "empty" | "exact" | "normalized_exact" | "normalized_substring" | "fuzzy_window";
+interface EvidenceQuoteScore {
+    readonly exactRaw: boolean;
+    readonly exactNormalized: boolean;
+    readonly exactSubstring: boolean;
+    readonly matchEnd: number;
+    readonly matchStart: number;
+    readonly normalizedQuote: string;
+    readonly normalizedSentence: string;
+    readonly score: number;
+    readonly strategy: EvidenceQuoteMatchStrategy;
 }
-interface AddChapterOptions {
-    readonly parentChapterId?: number;
-    readonly title?: string | null | undefined;
+declare function normalizeEvidenceDisplayText(text: string): string;
+declare function normalizeEvidenceText(text: string): string;
+declare function scoreEvidenceQuote(input: {
+    readonly quote: string;
+    readonly sentence: string;
+}): EvidenceQuoteScore;
+
+type EvidenceSentenceId = readonly [number, number];
+interface EvidenceSelectionSentence {
+    readonly id: string;
+    readonly sentenceId: EvidenceSentenceId;
+    readonly text: string;
 }
-declare function parseChapterTreeInput(input: unknown): ChapterTreeInput;
-interface GenerateChapterGraphOptions {
-    readonly extractionPrompt: string;
-    readonly llm: LLM<WikiGraphScope>;
-    readonly logDirPath?: string;
-    readonly progressTracker?: SerialProgressSink;
-    readonly userLanguage?: Language;
+interface EvidenceSelection {
+    readonly quote?: string;
+    readonly sentence_id?: string;
+}
+type EvidenceSelectionList = EvidenceSelection | readonly EvidenceSelection[];
+interface EvidenceSelectionCandidate {
+    readonly exactNormalized: boolean;
+    readonly exactRaw: boolean;
+    readonly exactSubstring: boolean;
+    readonly index: number;
+    readonly nextText: string;
+    readonly occurrenceId: string;
+    readonly prevText: string;
+    readonly score: number;
+    readonly sentence: EvidenceSelectionSentence;
+    readonly strategy: string;
 }
-interface GenerateChapterSummaryOptions {
-    readonly llm: LLM<WikiGraphScope>;
-    readonly logDirPath?: string;
-    readonly userLanguage?: Language;
+interface EvidenceSelectionResolution {
+    readonly candidate: EvidenceSelectionCandidate;
+    readonly confidence: number;
+    readonly sentenceIds: readonly EvidenceSentenceId[];
+    readonly strategy: string;
 }
-declare function advanceChapterStages(document: Document, options: AdvanceChapterStagesOptions): Promise<AdvanceChapterStagesResult>;
-declare function addChapter(document: Document, options: AddChapterOptions): Promise<ChapterDetails>;
-declare function generateChapterGraph(document: Document, chapterId: number, options: GenerateChapterGraphOptions): Promise<ChapterDetails>;
-declare function generateChapterSummary(document: Document, chapterId: number, options: GenerateChapterSummaryOptions): Promise<ChapterDetails>;
-declare function getChapterDetails(document: ReadonlyDocument, chapterId: number): Promise<ChapterDetails>;
-declare function listChapters(document: ReadonlyDocument): Promise<readonly ChapterEntry[]>;
-declare function getChapterTree(document: ReadonlyDocument): Promise<ChapterTree>;
-declare function applyChapterTree(document: Document, tree: ChapterTreeInput, options?: {
-    readonly dryRun?: boolean;
-}): Promise<ChapterTreeApplyResult>;
-declare function moveChapter(document: Document, chapterId: number, options: MoveChapterOptions): Promise<ChapterDetails>;
-declare function removeChapter(document: Document, chapterId: number, options?: {
-    readonly recursive?: boolean;
-}): Promise<void>;
-declare function resetChapter(document: Document, chapterId: number, stage: Exclude<ChapterStage, "summarized">): Promise<ChapterDetails>;
-declare function setChapterSource(document: Document, chapterId: number, stream: ReaderTextStream): Promise<ChapterDetails>;
-declare function setChapterSummary(document: Document, chapterId: number, summary: string): Promise<ChapterDetails>;
-declare function setChapterTitle(document: Document, chapterId: number, title: string | null | undefined): Promise<ChapterDetails>;
-
-interface WikiGraphSerialEntry {
-    readonly fragmentCount: number;
-    readonly serialId: number;
-    readonly title: string | null;
-    readonly tocPath: readonly string[];
+interface EvidenceSelectionFailure {
+    readonly candidates: readonly EvidenceSelectionCandidate[];
+    readonly code: "ambiguous" | "invalid" | "low_confidence" | "missing_sentence" | "none";
+    readonly message: string;
 }
 
-declare class WikiGraphArchive {
-    #private;
-    constructor(document: ReadonlyDocument, documentDirectoryPath: string);
-    exportEpub(path: string): Promise<void>;
-    exportText(path: string): Promise<void>;
-    readCover(): Promise<SourceAsset | undefined>;
-    readMeta(): Promise<BookMeta | undefined>;
-    readToc(): Promise<TocFile | undefined>;
-    readArchiveFormatVersion(): Promise<number>;
-    readChapterStage(serialId: number): Promise<ChapterStage>;
-    listSerials(): Promise<readonly WikiGraphSerialEntry[]>;
-    readSerialSummary(serialId: number): Promise<string>;
-    saveAs(path: string): Promise<void>;
-}
+declare function resolveEvidenceSelection(input: {
+    readonly evidence: EvidenceSelection;
+    readonly sentences: readonly EvidenceSelectionSentence[];
+}): readonly [
+    resolution: EvidenceSelectionResolution | undefined,
+    failure: EvidenceSelectionFailure | undefined
+];
+declare function resolveEvidenceSelectionList(input: {
+    readonly evidence: EvidenceSelectionList;
+    readonly sentences: readonly EvidenceSelectionSentence[];
+}): readonly [
+    resolution: EvidenceSelectionResolution | undefined,
+    failure: EvidenceSelectionFailure | undefined
+];
+declare function rankEvidenceQuote(quote: string, sentences: readonly EvidenceSelectionSentence[]): EvidenceSelectionCandidate[];
 
-interface DigestDocumentSessionOptions {
-    readonly documentDirPath?: string;
+interface WikimatchCandidate {
+    readonly hasMoreOptions?: boolean;
+    readonly id: string;
+    readonly qidOptions: readonly WikimatchQidOption[];
+    readonly range: WikimatchTextRange;
+    readonly surface: string;
 }
-
-interface WikiGraphLLMOptions {
-    readonly cacheDirPath?: string;
-    readonly concurrent?: number;
-    readonly logDirPath?: string;
-    readonly model: LanguageModel;
-    readonly retryIntervalSeconds?: number;
-    readonly retryTimes?: number;
-    readonly stream?: boolean;
-    readonly temperature?: number | readonly number[];
-    readonly timeout?: number;
-    readonly topP?: number | readonly number[];
+interface WikimatchSentence {
+    readonly id?: string;
+    readonly range: WikimatchTextRange;
+    readonly text: string;
 }
-interface WikiGraphOptions {
-    readonly debugLogDirPath?: string;
-    readonly llm?: LanguageModel | WikiGraphLLMOptions;
-    readonly verbose?: boolean;
+interface WikimatchQidOption {
+    readonly description?: string;
+    readonly disambiguation?: DisambiguationExpansion;
+    readonly isDisambiguation?: boolean;
+    readonly label?: string;
+    readonly qid: string;
 }
-type WikiGraphOpenSessionOptions = DigestDocumentSessionOptions;
-interface WikiGraphSourceSessionOptions extends DigestDocumentSessionOptions {
-    readonly extractionPrompt?: string;
-    readonly onProgress?: WikiGraphProgressCallback;
-    readonly path: string;
-    readonly targetStage?: ChapterStage;
-    readonly userLanguage?: Language;
+interface WikimatchTextRange {
+    readonly end: number;
+    readonly start: number;
 }
-interface WikiGraphTextStreamSessionOptions extends DigestDocumentSessionOptions {
-    readonly bookLanguage?: string | null;
-    readonly extractionPrompt?: string;
-    readonly onProgress?: WikiGraphProgressCallback;
-    readonly sourceFormat?: "markdown" | "txt";
-    readonly stream: AsyncIterable<string> | Iterable<string>;
-    readonly targetStage?: ChapterStage;
-    readonly title?: string | null;
-    readonly userLanguage?: Language;
+interface WikimatchWindow {
+    readonly baseOffset: number;
+    readonly candidates: readonly WikimatchCandidate[];
+    readonly groups: readonly WikimatchConflictGroup[];
+    readonly text: string;
 }
-declare class WikiGraph {
-    #private;
-    constructor(options: WikiGraphOptions);
-    digestEpubSession<T>(options: WikiGraphSourceSessionOptions, operation: (digest: WikiGraphArchive) => Promise<T> | T): Promise<T>;
-    digestMarkdownSession<T>(options: WikiGraphSourceSessionOptions, operation: (digest: WikiGraphArchive) => Promise<T> | T): Promise<T>;
-    digestTextStreamSession<T>(options: WikiGraphTextStreamSessionOptions, operation: (digest: WikiGraphArchive) => Promise<T> | T): Promise<T>;
-    digestTxtSession<T>(options: WikiGraphSourceSessionOptions, operation: (digest: WikiGraphArchive) => Promise<T> | T): Promise<T>;
-    openSession<T>(path: string, operation: (digest: WikiGraphArchive) => Promise<T> | T, options?: WikiGraphOpenSessionOptions): Promise<T>;
+interface WikimatchConflictGroup {
+    readonly candidateIds: readonly string[];
+    readonly id: string;
+    readonly range: WikimatchTextRange;
 }
-
-interface GraphNode {
-    readonly content: string;
-    readonly id: number;
-    readonly importance?: ChunkImportance;
-    readonly label: string;
-    readonly retention?: ChunkRetention;
-    readonly sentenceIds: readonly SentenceId[];
-    readonly weight: number;
-    readonly wordsCount: number;
+interface BuildWikimatchWindowsOptions {
+    readonly candidates: readonly WikimatchCandidate[];
+    readonly contextWords: number;
+    readonly optionBudget: number;
+    readonly text: string;
 }
-interface GraphEdge {
-    readonly fromId: number;
-    readonly strength?: string;
-    readonly toId: number;
-    readonly weight: number;
+type WikimatchPolicyDecision = "continue" | "never_recall" | "recall" | "skip_this_time";
+interface WikimatchPolicyJudgeInput {
+    readonly candidates: readonly WikimatchCandidate[];
+    readonly policyPrompt: string;
+    readonly window: WikimatchWindow;
 }
-interface GraphEvidenceLine {
-    readonly sentenceId: SentenceId;
-    readonly text: string;
+interface WikimatchPolicyJudgeResult {
+    readonly continuations: readonly WikimatchPolicyContinuation[];
+    readonly fallback?: WikimatchPolicyFallback;
+    readonly mentions: readonly WikimatchAcceptedMention[];
+    readonly policyUpdates: readonly WikimatchPolicyUpdate[];
 }
-interface GraphStatus {
-    readonly chapterId: number;
-    readonly edgeCount: number;
-    readonly graphReady: boolean;
-    readonly nodeCount: number;
+interface WikimatchAcceptedMention {
+    readonly candidateId: string;
+    readonly confidence?: number;
+    readonly qid: string;
+    readonly range: WikimatchTextRange;
+    readonly note?: string;
+    readonly surface: string;
 }
-interface GraphSearchHit {
-    readonly node: GraphNode;
-    readonly matchedFields: readonly GraphSearchField[];
+interface WikimatchPolicyUpdate {
+    readonly candidateId: string;
+    readonly decision: Exclude<WikimatchPolicyDecision, "recall" | "continue">;
+    readonly note?: string;
+    readonly qid?: string;
+    readonly surface: string;
 }
-type GraphSearchField = "content" | "evidence" | "label";
-interface GraphNeighbor {
-    readonly direction: "incoming" | "outgoing";
-    readonly edge: GraphEdge;
-    readonly node: GraphNode;
+interface WikimatchPolicyContinuation {
+    readonly candidateIds: readonly string[];
+    readonly groupId: string;
 }
-interface GraphPathStep {
-    readonly edge?: GraphEdge;
-    readonly node: GraphNode;
+interface WikimatchPolicyFallback {
+    readonly issues: readonly string[];
+    readonly reason: "guaranteed_json_failed";
 }
-declare function getGraphStatus(document: ReadonlyDocument, chapterId: number): Promise<GraphStatus>;
-declare function listGraphNodes(document: ReadonlyDocument, chapterId: number): Promise<readonly GraphNode[]>;
-declare function getGraphNode(document: ReadonlyDocument, chapterId: number, nodeId: number): Promise<GraphNode>;
-declare function searchGraphNodes(document: ReadonlyDocument, chapterId: number, pattern: string): Promise<readonly GraphSearchHit[]>;
-declare function listGraphNeighbors(document: ReadonlyDocument, chapterId: number, nodeId: number): Promise<readonly GraphNeighbor[]>;
-declare function getGraphEvidence(document: ReadonlyDocument, chapterId: number, nodeId: number): Promise<readonly GraphEvidenceLine[]>;
-declare function findGraphPath(document: ReadonlyDocument, chapterId: number, fromNodeId: number, toNodeId: number): Promise<readonly GraphPathStep[]>;
-
-declare const TEXT_SENTENCE_KIND: {
-    readonly source: 1;
-    readonly summary: 2;
-};
-type TextSentenceKind = (typeof TEXT_SENTENCE_KIND)[keyof typeof TEXT_SENTENCE_KIND];
-declare const SEARCH_OBJECT_PROPERTY_OWNER_KIND: {
-    readonly chapter: 1;
-    readonly chunk: 2;
-    readonly entity: 3;
-};
-type SearchObjectPropertyOwnerKind = (typeof SEARCH_OBJECT_PROPERTY_OWNER_KIND)[keyof typeof SEARCH_OBJECT_PROPERTY_OWNER_KIND];
-declare const SEARCH_OBJECT_PROPERTY_KIND: {
-    readonly title: 1;
-    readonly label: 1;
-    readonly content: 2;
-    readonly surface: 1;
-};
-type SearchObjectPropertyKind = (typeof SEARCH_OBJECT_PROPERTY_KIND)[keyof typeof SEARCH_OBJECT_PROPERTY_KIND];
-interface TextSentenceRecordInput {
-    readonly chapterId: number;
-    readonly kind: TextSentenceKind;
-    readonly sentenceIndex: number;
-    readonly text: string;
-    readonly wordsCount: number;
+interface WikimatchPolicyDecisionOutput {
+    readonly candidateId: string;
+    readonly confidence?: number;
+    readonly decision: WikimatchPolicyDecision;
+    readonly qid?: string;
 }
-interface SearchObjectPropertyRecordInput {
-    readonly chapterId?: number;
-    readonly ownerId: string;
-    readonly ownerKind: SearchObjectPropertyOwnerKind;
-    readonly propertyKind: SearchObjectPropertyKind;
-    readonly text: string;
+interface WikimatchPolicyGroupOutput {
+    readonly decisions: readonly WikimatchPolicyDecisionOutput[];
+    readonly groupId: string;
 }
-interface SearchIndexInput {
-    readonly objectProperties: readonly SearchObjectPropertyRecordInput[];
-    readonly textSentences: readonly TextSentenceRecordInput[];
+interface WikimatchPolicyResponse {
+    readonly groups: readonly WikimatchPolicyGroupOutput[];
 }
-type SearchIndexProgressPhase = "checking" | "clearing" | "collecting" | "finalizing" | "indexing-objects" | "indexing-text";
-interface SearchIndexProgressEvent {
-    readonly done?: number;
-    readonly phase: SearchIndexProgressPhase;
-    readonly total?: number;
-    readonly unit?: "chapter" | "object" | "sentence";
+
+interface JudgeWikimatchPolicyOptions extends WikimatchPolicyJudgeInput {
+    readonly maxRetries?: number;
+    readonly request: GuaranteedRequest;
 }
-type SearchIndexProgressReporter = (event: SearchIndexProgressEvent) => void | Promise<void>;
-type SearchIndexStatus = "current" | "dirty" | "missing";
-interface SearchIndexTextHit {
-    readonly chapterId: number;
-    readonly kind: TextSentenceKind;
-    readonly rank: number;
-    readonly score: number;
-    readonly sentenceIndex: number;
-    readonly wordsCount: number;
+declare function judgeWikimatchPolicy(options: JudgeWikimatchPolicyOptions): Promise<WikimatchPolicyJudgeResult>;
+declare function parsePolicyResponse(candidates: readonly WikimatchCandidate[], response: WikimatchPolicyResponse, groups?: readonly WikimatchConflictGroup[]): WikimatchPolicyJudgeResult;
+declare function validatePolicyResponse(candidates: readonly WikimatchCandidate[], response: WikimatchPolicyResponse, groups?: readonly WikimatchConflictGroup[]): readonly string[];
+
+interface MatchWikispineSentenceCandidatesOptions {
+    readonly command?: string;
+    readonly dataDir?: string;
+    readonly endpoint?: string;
+    readonly fetch?: typeof fetch;
+    readonly includeDisambiguation?: boolean;
+    readonly maxCandidatesPerSurface?: number;
+    readonly onProgress?: (progress: WikispineMatchProgress) => Promise<void> | void;
+    readonly provider?: WikispineProvider;
+    readonly sentences: readonly WikimatchSentence[];
 }
-interface SearchIndexObjectHit {
-    readonly chapterId?: number;
-    readonly ownerId: string;
-    readonly ownerKind: SearchObjectPropertyOwnerKind;
-    readonly propertyKind: SearchObjectPropertyKind;
-    readonly score: number;
+type WikispineProvider = "cli" | "fetch";
+interface WikispineMatchProgress {
+    readonly coveredRangeEnd: number;
 }
-interface SearchIndexQueryResult {
-    readonly objectHits: readonly SearchIndexObjectHit[];
-    readonly terms: readonly string[];
-    readonly textHits: readonly SearchIndexTextHit[];
+interface TestWikispineRuntimeOptions {
+    readonly command?: string;
+    readonly dataDir?: string;
+    readonly endpoint?: string;
+    readonly fetch?: typeof fetch;
+    readonly provider?: WikispineProvider;
 }
-declare const SEARCH_INDEX_FTS_HIT_LIMIT = 32000;
-interface ArchiveIndexSettings {
-    readonly ftsEmbedded: boolean;
+interface WikispineRuntimeTestResult {
+    readonly durationMs: number;
+    readonly metadata?: WikispineMetadata;
+    readonly ok: true;
+    readonly provider: WikispineProvider;
 }
-declare function readArchiveIndexSettings(document: ReadonlyDocument): Promise<ArchiveIndexSettings>;
-declare function setFtsIndexEmbedded(document: Document, embedded: boolean): Promise<void>;
-declare function isSearchIndexCurrent(document: ReadonlyDocument, input?: SearchIndexInput): Promise<boolean>;
-declare function readSearchIndexStatus(document: ReadonlyDocument, input?: SearchIndexInput): Promise<SearchIndexStatus>;
-declare function ensureSearchIndex(document: Document, input: SearchIndexInput, progress?: SearchIndexProgressReporter): Promise<void>;
-declare function querySearchIndex(document: ReadonlyDocument, query: string, options?: {
-    readonly chapters?: readonly number[];
-    readonly match?: ArchiveFindMatch;
-    readonly objectHitLimit?: number;
-    readonly textAfter?: {
-        readonly chapterId: number;
-        readonly kind: TextSentenceKind;
-        readonly rank: number;
-        readonly sentenceIndex: number;
-    };
-    readonly textHitLimit?: number;
-    readonly types?: readonly ArchiveFindObjectType[] | null;
-}): Promise<SearchIndexQueryResult | undefined>;
-declare function createSearchIndexFingerprint(input: SearchIndexInput): string;
-declare function readSearchIndexFingerprintFromDatabase(database: Database): Promise<string | undefined>;
-
-type ArchiveObjectType = "chapter" | "chapter-title" | "chapter-tree" | "edge" | "entity" | "fragment" | "meta" | "node" | "source" | "state" | "summary" | "triple";
-type ChapterStateTarget = "knowledge-graph" | "reading-graph" | "reading-summary" | "source";
-type ChapterStateValue = "missing" | "ready";
-type ChapterState = Record<ChapterStateTarget, ChapterStateValue>;
-type ArchiveCollectionType = "chapter" | "chapter-title" | "entity" | "fragment" | "meta" | "node" | "source" | "summary" | "triple";
-type ArchiveFindObjectType = "chapter" | "chapter-title" | "chapter-tree" | "entity" | "fragment" | "meta" | "node" | "source" | "summary" | "triple";
-type ArchiveFindFilterType = "chapter" | "chapter-title" | "entity" | "fragment" | "meta" | "node" | "source" | "summary" | "triple";
-interface ArchiveIndex {
-    readonly chapters: readonly ChapterEntry[];
-    readonly edgeCount: number;
-    readonly meta: BookMeta | undefined;
-    readonly nodeCount: number;
-    readonly summaryCount: number;
+interface WikispineMetadata {
+    readonly automaton_shard_count: number;
+    readonly format: string;
+    readonly qid_count: number;
+    readonly surface_count: number;
+    readonly surface_normalization: string;
 }
-interface ArchiveFindHit {
-    readonly backlinks?: ArchiveBacklinks;
-    readonly chapter?: number;
-    readonly evidence?: ArchiveFindEvidencePreview;
-    readonly evidenceLinks?: readonly MentionLinkRecord[];
-    readonly evidenceMentions?: readonly EntityEvidenceMention[];
-    readonly field: ArchiveFindField;
-    readonly id: string;
-    readonly matchCount?: number;
-    readonly matchedTerms?: readonly string[];
-    readonly missingTerms?: readonly string[];
-    readonly position?: ArchiveFindPosition;
-    readonly score?: number;
-    readonly snippet: string;
-    readonly state?: ChapterState;
-    readonly title: string;
-    readonly triple?: {
-        readonly objectLabel: string;
-        readonly predicate: string;
-        readonly subjectLabel: string;
-    };
-    readonly type: ArchiveFindObjectType;
+declare const DEFAULT_WIKISPINE_FETCH_ENDPOINT = "https://wikispi-service-cxbfjlteab.cn-hangzhou.fcapp.run";
+declare function testWikispineRuntime(options: TestWikispineRuntimeOptions): Promise<WikispineRuntimeTestResult>;
+
+declare function buildWikimatchWindows(options: BuildWikimatchWindowsOptions): readonly WikimatchWindow[];
+
+type WikiGraphSamplingConfig = SamplingScopeConfig<WikiGraphScope>;
+declare function createDefaultWikiGraphSampling(input?: {
+    readonly temperature?: TemperatureSetting;
+    readonly topP?: TemperatureSetting;
+}): WikiGraphSamplingConfig;
+
+type WikiGraphOperation = "digest-epub" | "digest-markdown" | "digest-text-stream" | "digest-txt";
+interface SerialDiscoveryItem {
+    readonly id: number;
+    readonly fragments?: number | undefined;
+    readonly title?: string | undefined;
+    readonly words: number;
 }
-interface EntityEvidenceMention {
-    readonly match: Pick<ArchiveFindHit, "matchCount" | "matchedTerms" | "missingTerms" | "score">;
-    readonly mention: MentionRecord;
+interface SerialsDiscoveredEvent {
+    readonly type: "serials-discovered";
+    readonly available: boolean;
+    readonly serials: readonly SerialDiscoveryItem[];
 }
-interface ArchiveFindEvidencePreview {
-    readonly nextCursor: string | null;
-    readonly shown: number;
-    readonly sources: readonly ArchiveEvidenceItem[];
-    readonly total: number;
+interface SerialProgressEvent {
+    readonly type: "serial-progress";
+    readonly id: number;
+    readonly completedWords: number;
+    readonly completedFragments: number;
 }
-type ArchiveFindField = "content" | "metadata" | "source" | "summary" | "title";
-interface ArchiveFindOptions {
-    readonly archiveKey?: string;
-    readonly backlinks?: boolean;
-    readonly chapters?: readonly number[];
-    readonly cursor?: string;
-    readonly evidenceLimit?: number;
-    readonly ids?: readonly string[];
-    readonly limit?: number;
-    readonly match?: ArchiveFindMatch;
-    readonly order?: ArchiveFindOrder;
-    readonly sourceContext?: number;
-    readonly triplePattern?: ArchiveTriplePattern;
-    readonly types?: readonly ArchiveFindFilterType[];
+interface DigestProgressEvent {
+    readonly type: "digest-progress";
+    readonly completedWords: number;
+    readonly totalWords: number;
 }
-type ArchiveFindOrder = "doc-asc" | "doc-desc";
-type ArchiveFindMatch = "all" | "any";
-interface ArchiveFindPosition {
-    readonly chapter: number;
-    readonly documentOrder?: number;
-    readonly fragment?: number;
-    readonly sentence?: number;
+type WikiGraphProgressEventType = WikiGraphProgressEvent["type"];
+type WikiGraphProgressEvent = SerialsDiscoveredEvent | SerialProgressEvent | DigestProgressEvent;
+type WikiGraphProgressCallback = (event: WikiGraphProgressEvent) => void | Promise<void>;
+
+type TextStream = AsyncIterable<string> | Iterable<string>;
+
+type ReaderTextStream = TextStream;
+
+interface ChapterTreeInput {
+    readonly chapters: readonly ChapterTreeInputNode[];
 }
-interface ArchiveFindResult {
-    readonly chapters: readonly number[] | null;
-    readonly items: readonly ArchiveFindHit[];
-    readonly lens: ArchiveFindLens;
-    readonly lensHint: ArchiveFindLensHint | null;
-    readonly limit: number;
-    readonly match: ArchiveFindMatch;
-    readonly nextCursor: string | null;
-    readonly order: ArchiveFindOrder;
-    readonly query: string;
-    readonly terms: readonly string[];
-    readonly types: readonly ArchiveFindFilterType[] | null;
+interface ChapterTreeInputNode {
+    readonly children: readonly ChapterTreeInputNode[];
+    readonly uri: string;
+    readonly title?: string | null | undefined;
 }
-type ArchiveFindLens = "broad" | "exact" | "typed";
-interface ArchiveFindLensHint {
-    readonly lenses: {
-        readonly chapter: string;
-        readonly chunk: string;
-        readonly entity: string;
-        readonly node: string;
-        readonly triple: string;
-    };
-    readonly message: string;
+interface ChapterTreeApplyResult {
+    readonly changed: boolean;
+    readonly moved: readonly ChapterTreeMoveChange[];
+    readonly renamed: readonly ChapterTreeTitleChange[];
+    readonly unchanged: number;
 }
-interface ArchiveCollectionOptions {
-    readonly backlinks?: boolean;
-    readonly chapters?: readonly number[];
-    readonly cursor?: string;
-    readonly evidenceLimit?: number;
-    readonly ids?: readonly string[];
-    readonly limit?: number;
-    readonly order?: ArchiveFindOrder;
-    readonly sourceContext?: number;
-    readonly triplePattern?: ArchiveTriplePattern;
-    readonly types?: readonly ArchiveCollectionType[];
+interface ChapterTreeMoveChange {
+    readonly newUri: string;
+    readonly newIndex: number;
+    readonly newPath: readonly string[];
+    readonly newParentUri: string | null;
+    readonly oldUri: string;
+    readonly oldIndex: number;
+    readonly oldPath: readonly string[];
+    readonly oldParentUri: string | null;
 }
-interface ArchiveTriplePattern {
-    readonly objectQid?: string;
-    readonly predicate?: string;
-    readonly subjectQid?: string;
+interface ChapterTreeTitleChange {
+    readonly uri: string;
+    readonly newTitle: string | null;
+    readonly oldTitle: string | null;
 }
-interface ArchiveCollectionResult {
-    readonly chapters: readonly number[] | null;
-    readonly ids: readonly string[] | null;
-    readonly items: readonly ArchiveFindHit[];
-    readonly limit: number;
-    readonly nextCursor: string | null;
-    readonly order: ArchiveFindOrder;
-    readonly types: readonly ArchiveCollectionType[] | null;
+interface MoveChapterOptions {
+    readonly afterChapterId?: number;
+    readonly beforeChapterId?: number;
+    readonly first?: boolean;
+    readonly last?: boolean;
+    readonly parentChapterId?: number;
+    readonly root?: boolean;
 }
-interface ArchiveBacklinks {
-    readonly chunks: ArchiveBacklinkBucket;
-    readonly entities: ArchiveBacklinkBucket;
-    readonly triples: ArchiveBacklinkBucket;
+interface AdvanceChapterStagesOptions {
+    readonly chapterId?: number;
+    readonly extractionPrompt?: string;
+    readonly llm: LLM<WikiGraphScope>;
+    readonly logDirPath?: string;
+    readonly onProgress?: AdvanceChapterStagesProgressCallback;
+    readonly targetStage: ChapterStage;
+    readonly userLanguage?: Language;
 }
-interface ArchiveBacklinkBucket {
-    readonly items: readonly ArchiveFindHit[];
-    readonly limit: number;
-    readonly nextCursor: string | null;
+interface AdvanceChapterStagesProgressState {
+    readonly graphWords: number;
+    readonly summaryWords: number;
+    readonly totalGraphWords: number;
+    readonly totalSummaryWords: number;
 }
-type ArchiveListKind = "chapters" | "edges" | "fragments" | "meta" | "nodes" | "summaries";
-type ArchiveListItem = {
-    readonly evidence?: ArchiveFindEvidencePreview;
-    readonly id: string;
-    readonly label: string;
-    readonly score?: number;
-    readonly state?: ChapterState;
-    readonly summary: string;
-    readonly type: Exclude<ArchiveObjectType, "triple">;
-} | {
-    readonly evidence?: ArchiveFindEvidencePreview;
-    readonly id: string;
-    readonly label: string;
-    readonly evidenceLinks?: readonly MentionLinkRecord[];
-    readonly objectLabel: string;
-    readonly objectQid: string;
-    readonly predicate: string;
-    readonly score?: number;
-    readonly subjectLabel: string;
-    readonly subjectQid: string;
-    readonly summary: string;
-    readonly type: "triple";
-};
-type ArchivePage = {
-    readonly id: string;
-    readonly state: ChapterState;
-    readonly title: string;
-    readonly type: "chapter";
-} | {
-    readonly id: string;
-    readonly title: string;
-    readonly type: "chapter-title";
-} | {
-    readonly id: string;
-    readonly title: string;
-    readonly tree: ChapterTree;
-    readonly type: "chapter-tree";
-} | {
-    readonly generatedNodeSummary: string;
-    readonly id: string;
-    readonly incoming: readonly GraphNeighbor[];
-    readonly neighbors: readonly GraphNeighbor[];
-    readonly outgoing: readonly GraphNeighbor[];
-    readonly position: ArchiveFindPosition | undefined;
-    readonly sourceFragments: readonly ArchiveNodeSourceFragment[];
-    readonly title: string;
-    readonly type: "node";
-} | {
-    readonly backlinks?: ArchiveBacklinks;
-    readonly fragment: ArchiveSourceFragment;
-    readonly id: string;
-    readonly nextFragmentId: string | undefined;
-    readonly nodes: readonly ArchiveNodeLabel[];
-    readonly previousFragmentId: string | undefined;
-    readonly title: string;
-    readonly type: "fragment";
-} | {
-    readonly content: string;
-    readonly id: string;
-    readonly title: string;
-    readonly type: "summary";
-} | {
-    readonly evidence: ArchiveFindEvidencePreview;
-    readonly id: string;
-    readonly label: string;
-    readonly labels: readonly string[];
-    readonly mentionCount: number;
-    readonly qid: string;
-    readonly type: "entity";
-} | {
-    readonly en: ArchiveEntityWikipageLocale | null;
-    readonly id: string;
-    readonly type: "entity-wikipage";
-    readonly zh: ArchiveEntityWikipageLocale | null;
+type AdvanceChapterStagesProgressCallback = (event: AdvanceChapterStagesProgressEvent) => void | Promise<void>;
+type AdvanceChapterStagesProgressEvent = {
+    readonly type: "selected";
+    readonly state: AdvanceChapterStagesProgressState;
+    readonly targetStage: ChapterStage;
+    readonly totalChapters: number;
 } | {
-    readonly evidence: ArchiveFindEvidencePreview;
-    readonly id: string;
-    readonly label: string;
-    readonly objectQid: string;
-    readonly predicate: string;
-    readonly subjectQid: string;
-    readonly type: "triple";
+    readonly type: "skipped";
+    readonly chapter: ChapterEntry;
+    readonly reason: "planned";
+    readonly targetStage: ChapterStage;
 } | {
-    readonly authors?: readonly string[];
-    readonly description?: string;
-    readonly id: string;
-    readonly publisher?: string;
-    readonly title: string;
-    readonly type: "meta";
+    readonly type: "progress";
+    readonly state: AdvanceChapterStagesProgressState;
+    readonly targetStage: ChapterStage;
 } | {
-    readonly id: string;
-    readonly state: ChapterState;
-    readonly type: "state";
+    readonly type: "started";
+    readonly chapter: ChapterEntry;
+    readonly step: "graph" | "summary";
+    readonly targetStage: ChapterStage;
 } | {
-    readonly id: string;
-    readonly target: ChapterStateTarget;
-    readonly type: "state";
-    readonly value: ChapterStateValue;
+    readonly type: "completed";
+    readonly chapter: ChapterEntry;
+    readonly step: "graph" | "summary";
+    readonly targetStage: ChapterStage;
 };
-interface ArchiveEntityWikipageLocale {
-    readonly description?: string;
-    readonly title: string;
-    readonly url: string;
+interface AdvanceChapterStagesResult {
+    readonly advanced: readonly ChapterEntry[];
+    readonly pending: readonly ChapterEntry[];
+    readonly skipped: readonly ChapterEntry[];
 }
-interface ArchivePack {
-    readonly anchor: ArchivePage;
-    readonly budget: number;
-    readonly related: readonly ArchiveListItem[];
+interface AddChapterOptions {
+    readonly parentChapterId?: number;
+    readonly title?: string | null | undefined;
 }
-type ArchiveRelatedRole = "any" | "object" | "self" | "subject";
-interface ArchiveRelatedOptions {
-    readonly cursor?: string;
-    readonly evidenceLimit?: number;
-    readonly limit?: number;
-    readonly order?: ArchiveFindOrder;
-    readonly query?: string;
-    readonly role?: ArchiveRelatedRole;
-    readonly sourceContext?: number;
+
+declare function advanceChapterStages(document: Document, options: AdvanceChapterStagesOptions): Promise<AdvanceChapterStagesResult>;
+
+interface SerialProgressSink {
+    begin?(input?: {
+        readonly fragments: number;
+        readonly words: number;
+    }): Promise<void>;
+    advance(wordsCount: number): Promise<void>;
+    complete(finalWordsCount?: number): Promise<void>;
 }
-interface ArchiveRelatedResult {
-    readonly items: readonly ArchiveListItem[];
-    readonly limit: number;
-    readonly nextCursor: string | null;
+
+interface GenerateChapterGraphOptions {
+    readonly extractionPrompt?: string;
+    readonly llm: LLM<WikiGraphScope>;
+    readonly logDirPath?: string;
+    readonly progressTracker?: SerialProgressSink;
+    readonly userLanguage?: Language;
 }
-interface ArchiveEvidence {
-    readonly items: readonly ArchiveEvidenceItem[];
-    readonly limit: number;
-    readonly nextCursor: string | null;
+interface GenerateChapterSummaryOptions {
+    readonly llm: LLM<WikiGraphScope>;
+    readonly logDirPath?: string;
+    readonly userLanguage?: Language;
 }
-interface ArchiveEvidenceItem {
-    readonly chapterId: number;
-    readonly endSentenceIndex: number;
-    readonly fragmentId?: number;
-    readonly id: string;
-    readonly score?: number;
-    readonly source: string;
-    readonly startSentenceIndex: number;
-    readonly title: string;
-    readonly type: "source";
+
+declare function generateChapterGraph(document: Document, chapterId: number, options: GenerateChapterGraphOptions): Promise<ChapterDetails>;
+declare function generateChapterSummary(document: Document, chapterId: number, options: GenerateChapterSummaryOptions): Promise<ChapterDetails>;
+
+declare function addChapter(document: Document, options: AddChapterOptions): Promise<ChapterDetails>;
+declare function resolveChapterPath(document: Document, chapterPath: string): Promise<number>;
+declare function resolveChapterPathReadonly(document: ReadonlyDocument, chapterPath: string): Promise<number>;
+declare function applyChapterTree(document: Document, tree: ChapterTreeInput, options?: {
+    readonly dryRun?: boolean;
+}): Promise<ChapterTreeApplyResult>;
+declare function moveChapter(document: Document, chapterId: number, options: MoveChapterOptions): Promise<ChapterDetails>;
+declare function removeChapter(document: Document, chapterId: number, options?: {
+    readonly recursive?: boolean;
+}): Promise<void>;
+declare function resetChapter(document: Document, chapterId: number, stage: Exclude<ChapterStage, "summarized">): Promise<ChapterDetails>;
+declare function setChapterSource(document: Document, chapterId: number, stream: ReaderTextStream): Promise<ChapterDetails>;
+declare function setChapterSummary(document: Document, chapterId: number, summary: string): Promise<ChapterDetails>;
+declare function setChapterTitle(document: Document, chapterId: number, title: string | null | undefined): Promise<ChapterDetails>;
+
+declare function parseChapterTreeInput(input: unknown): ChapterTreeInput;
+
+interface WikiGraphSerialEntry {
+    readonly fragmentCount: number;
+    readonly serialId: number;
+    readonly title: string | null;
+    readonly tocPath: readonly string[];
 }
-interface ArchiveNodeLabel {
-    readonly id: string;
-    readonly title: string;
+
+declare class WikiGraphArchive {
+    #private;
+    constructor(document: ReadonlyDocument, documentDirectoryPath: string);
+    exportEpub(path: string): Promise<void>;
+    exportText(path: string): Promise<void>;
+    readCover(): Promise<SourceAsset | undefined>;
+    readMeta(): Promise<BookMeta | undefined>;
+    readToc(): Promise<TocFile | undefined>;
+    readArchiveFormatVersion(): Promise<number>;
+    readChapterStage(serialId: number): Promise<ChapterStage>;
+    listSerials(): Promise<readonly WikiGraphSerialEntry[]>;
+    readSerialSummary(serialId: number): Promise<string>;
+    saveAs(path: string): Promise<void>;
 }
-interface ArchiveSourceFragment {
-    readonly fragmentId?: number;
-    readonly id: string;
-    readonly preview: string;
-    readonly sentenceCount: number;
-    readonly text: string;
-    readonly wordsCount: number;
+
+interface DigestDocumentSessionOptions {
+    readonly documentDirPath?: string;
 }
-interface ArchiveNodeSourceFragment {
-    readonly id: string;
-    readonly text: string;
-    readonly truncated: boolean;
+
+interface WikiGraphLLMOptions {
+    readonly cacheDirPath?: string;
+    readonly concurrent?: number;
+    readonly logDirPath?: string;
+    readonly model: LanguageModel;
+    readonly retryIntervalSeconds?: number;
+    readonly retryTimes?: number;
+    readonly stream?: boolean;
+    readonly temperature?: number | readonly number[];
+    readonly timeout?: number;
+    readonly topP?: number | readonly number[];
+}
+interface WikiGraphOptions {
+    readonly debugLogDirPath?: string;
+    readonly llm?: LanguageModel | WikiGraphLLMOptions;
+    readonly verbose?: boolean;
+}
+type WikiGraphOpenSessionOptions = DigestDocumentSessionOptions;
+interface WikiGraphSourceSessionOptions extends DigestDocumentSessionOptions {
+    readonly extractionPrompt?: string;
+    readonly onProgress?: WikiGraphProgressCallback;
+    readonly path: string;
+    readonly targetStage?: ChapterStage;
+    readonly userLanguage?: Language;
 }
-interface ArchiveEvidenceOptions {
-    readonly cursor?: string;
-    readonly limit?: number;
-    readonly order?: ArchiveFindOrder;
-    readonly query?: string;
-    readonly sourceContext?: number;
+interface WikiGraphTextStreamSessionOptions extends DigestDocumentSessionOptions {
+    readonly bookLanguage?: string | null;
+    readonly extractionPrompt?: string;
+    readonly onProgress?: WikiGraphProgressCallback;
+    readonly sourceFormat?: "markdown" | "txt";
+    readonly stream: AsyncIterable<string> | Iterable<string>;
+    readonly targetStage?: ChapterStage;
+    readonly title?: string | null;
+    readonly userLanguage?: Language;
 }
-interface ArchivePageOptions {
-    readonly backlinks?: boolean;
-    readonly evidenceLimit?: number;
-    readonly order?: ArchiveFindOrder;
-    readonly sourceContext?: number;
-    readonly wikipageResolverOptions?: WikipageResolverOptions;
+declare class WikiGraph {
+    #private;
+    constructor(options: WikiGraphOptions);
+    digestEpubSession<T>(options: WikiGraphSourceSessionOptions, operation: (digest: WikiGraphArchive) => Promise<T> | T): Promise<T>;
+    digestMarkdownSession<T>(options: WikiGraphSourceSessionOptions, operation: (digest: WikiGraphArchive) => Promise<T> | T): Promise<T>;
+    digestTextStreamSession<T>(options: WikiGraphTextStreamSessionOptions, operation: (digest: WikiGraphArchive) => Promise<T> | T): Promise<T>;
+    digestTxtSession<T>(options: WikiGraphSourceSessionOptions, operation: (digest: WikiGraphArchive) => Promise<T> | T): Promise<T>;
+    openSession<T>(path: string, operation: (digest: WikiGraphArchive) => Promise<T> | T, options?: WikiGraphOpenSessionOptions): Promise<T>;
 }
-declare function getArchiveIndex(document: ReadonlyDocument): Promise<ArchiveIndex>;
-declare function listArchiveObjects(document: ReadonlyDocument, kind: ArchiveListKind): Promise<readonly ArchiveListItem[]>;
-declare function listArchiveCollection(document: ReadonlyDocument, options?: ArchiveCollectionOptions): Promise<ArchiveCollectionResult>;
-declare function findArchiveObjects(document: ReadonlyDocument, query: string, options?: ArchiveFindOptions): Promise<ArchiveFindResult>;
-declare function rebuildArchiveSearchIndex(document: Document, progress?: SearchIndexProgressReporter): Promise<void>;
-declare function isArchiveSearchIndexCurrent(document: ReadonlyDocument): Promise<boolean>;
-declare function readArchiveSearchIndexStatus(document: ReadonlyDocument): Promise<"current" | "dirty" | "missing">;
-declare function clearDirtyArchiveSearchIndex(document: Document): Promise<void>;
-declare function createArchiveSearchIndexFingerprint(document: ReadonlyDocument): Promise<string>;
-declare function grepArchiveObjects(document: ReadonlyDocument, query: string, options?: ArchiveFindOptions): Promise<ArchiveFindResult>;
-declare function readArchiveText(document: ReadonlyDocument, id: string): Promise<string>;
-declare function readArchivePage(document: ReadonlyDocument, id: string, options?: ArchivePageOptions): Promise<ArchivePage>;
-declare function listArchiveLinks(document: ReadonlyDocument, id: string, direction: "backlinks" | "links"): Promise<readonly GraphNeighbor[]>;
-declare function listAllArchiveLinks(document: ReadonlyDocument, id: string): Promise<readonly GraphNeighbor[]>;
-declare function listRelatedArchiveObjects(document: ReadonlyDocument, id: string, options?: ArchiveRelatedOptions): Promise<ArchiveRelatedResult>;
-declare function listArchiveEvidence(document: ReadonlyDocument, uri: string, options?: ArchiveEvidenceOptions): Promise<ArchiveEvidence>;
-declare function packArchiveContext(document: ReadonlyDocument, id: string, budget: number): Promise<ArchivePack>;
-declare function formatChapterId(chapterId: number): string;
-declare function formatEdgeId(edge: ReadingEdgeRecord): string;
-declare function formatNodeId(nodeId: number): string;
-declare function formatSummaryId(chapterId: number): string;
 
-type ContinuationCursor = {
+type QueryScope = {
+    readonly kind: "archive";
+    readonly archiveId: number;
+} | {
+    readonly kind: "library";
+    readonly libraryId: number;
+};
+type QueryIndexScope = {
+    readonly kind: "archive-index";
+    readonly archivePath: string;
+    readonly archiveKey: string;
+} | {
+    readonly kind: "library-index";
+    readonly libraryId: number;
+};
+type ContinuationCursorBase = {
     readonly archiveKey: string;
     readonly archivePath: string;
+    readonly indexScope: QueryIndexScope;
+};
+type ContinuationCursor = (ContinuationCursorBase & {
     readonly backlinks?: boolean;
     readonly chapters: readonly number[] | null;
     readonly cursor: string;
@@ -2215,10 +2237,9 @@ type ContinuationCursor = {
         readonly subjectQid?: string;
     };
     readonly types: readonly string[] | null;
-} | {
-    readonly archiveKey: string;
-    readonly archivePath: string;
+}) | (ContinuationCursorBase & {
     readonly backlinks?: boolean;
+    readonly chapters?: readonly number[] | null;
     readonly cursor: string;
     readonly evidenceLimit?: number;
     readonly format: "json" | "jsonl" | "text";
@@ -2231,9 +2252,7 @@ type ContinuationCursor = {
         readonly subjectQid?: string;
     };
     readonly types: readonly string[] | null;
-} | {
-    readonly archiveKey: string;
-    readonly archivePath: string;
+}) | (ContinuationCursorBase & {
     readonly cursor: string;
     readonly format: "json" | "jsonl" | "text";
     readonly kind: "evidence";
@@ -2241,9 +2260,7 @@ type ContinuationCursor = {
     readonly query?: string;
     readonly sourceContext?: number;
     readonly targetUri: string;
-} | {
-    readonly archiveKey: string;
-    readonly archivePath: string;
+}) | (ContinuationCursorBase & {
     readonly cursor: string;
     readonly evidenceLimit?: number;
     readonly format: "json" | "jsonl" | "text";
@@ -2253,115 +2270,113 @@ type ContinuationCursor = {
     readonly role?: "any" | "object" | "self" | "subject";
     readonly sourceContext?: number;
     readonly targetUri: string;
-};
+});
+
 declare function createContinuationCursor(input: ContinuationCursor): Promise<string>;
 declare function readContinuationCursor(cursorId: string): Promise<ContinuationCursor>;
 
-interface SearchSessionInput {
-    readonly archiveKey: string;
-    readonly chapters: readonly number[] | null;
-    readonly chunkHits?: readonly SearchChunkHitInput[];
-    readonly entityHits?: readonly SearchEntityHitInput[];
-    readonly evidenceEvents?: readonly SearchEvidenceHitEventInput[];
-    readonly items?: readonly ArchiveFindHit[];
-    readonly lens: string;
-    readonly match: string;
-    readonly order: string;
-    readonly query: string;
-    readonly revisionScope: string;
-    readonly terms: readonly string[];
-    readonly tripleHits?: readonly SearchTripleHitInput[];
-    readonly types: readonly string[] | null;
-}
-declare const SEARCH_EVIDENCE_KIND: {
-    readonly mention: 1;
-    readonly mentionLink: 2;
-    readonly chunk: 3;
-};
-type SearchEvidenceKind = (typeof SEARCH_EVIDENCE_KIND)[keyof typeof SEARCH_EVIDENCE_KIND];
-interface SearchEvidenceHitEventInput {
-    readonly chapterId: number;
-    readonly evidenceId: string;
-    readonly evidenceKind: SearchEvidenceKind;
-    readonly score: number;
-    readonly sentenceIndex: number;
-}
-interface SearchEntityHitInput {
-    readonly evidenceTopScores?: readonly number[];
-    readonly propertyTopScores?: readonly number[];
-    readonly qid: string;
-}
-interface SearchTripleHitInput {
-    readonly evidenceTopScores: readonly number[];
-    readonly objectQid: string;
-    readonly predicate: string;
-    readonly subjectQid: string;
-}
-interface SearchChunkHitInput {
-    readonly chunkId: number;
-    readonly evidenceTopScores?: readonly number[];
-    readonly propertyTopScores?: readonly number[];
-}
-interface SearchSessionPage {
-    readonly chapters: readonly number[] | null;
-    readonly items: readonly ArchiveFindHit[];
-    readonly lens: string;
-    readonly match: string;
-    readonly nextCursor: string | null;
-    readonly query: string;
-    readonly sessionId: string;
-    readonly terms: readonly string[];
-    readonly types: readonly string[] | null;
-}
-interface SearchSessionDescriptor {
-    readonly chapters: readonly number[] | null;
-    readonly createdAt: number;
-    readonly lens: string;
-    readonly match: string;
-    readonly objectCachesPopulated: boolean;
-    readonly query: string;
-    readonly sessionId: string;
-    readonly terms: readonly string[];
-    readonly types: readonly string[] | null;
-}
-type SearchSessionCacheInput = Omit<SearchSessionInput, "items">;
-declare function readCachedSearchSessionPage(input: SearchSessionCacheInput, offset: number, limit: number): Promise<SearchSessionPage | undefined>;
-declare function createSearchSession(input: SearchSessionInput): Promise<string>;
 declare function deleteArchiveSearchSessions(archiveKey: string): Promise<void>;
-declare function runSearchCacheGc(context: GcContext): Promise<GcJobResult>;
+
+declare function addBuildJob(options: AddBuildJobOptions): Promise<BuildJob>;
+declare function recordBuildJobInputRevision(input: {
+    readonly currentRevision: number;
+    readonly jobId: string;
+    readonly ownerId: string;
+}): Promise<BuildJob>;
+declare function assertBuildJobInputRevision(input: {
+    readonly currentRevision: number;
+    readonly jobId: string;
+    readonly ownerId: string;
+}): Promise<void>;
+declare function listBuildJobs(options?: BuildJobListOptions): Promise<BuildJob[]>;
+declare function getBuildJob(jobId: string): Promise<BuildJob>;
+declare function resolveBuildJobId(jobIdPrefix: string): Promise<string>;
+declare function pauseBuildJob(jobId: string): Promise<BuildJob>;
+declare function resumeBuildJob(jobId: string): Promise<BuildJob>;
+declare function cancelBuildJob(jobId: string): Promise<BuildJob>;
+declare function boostBuildJob(jobId: string): Promise<BuildJob>;
+declare function updateBuildJobTarget(jobId: string, target: BuildJobTarget): Promise<BuildJob>;
+
+declare function assertNoActiveBuildJobs(input: {
+    readonly archivePath: string;
+    readonly chapterIds: readonly number[];
+    readonly operation: string;
+    readonly requiresTarget?: BuildJobTarget;
+}): Promise<void>;
+declare function assertNoActiveBuildJobConflicts(input: {
+    readonly archivePath: string;
+    readonly operation: string;
+    readonly requiresTarget?: BuildJobTarget;
+    readonly scope: BuildJobConflictScope;
+}): Promise<void>;
+
+declare function readBuildJobEvents(job: Pick<BuildJob, "eventsPath">): Promise<BuildJobEvent[]>;
+
+declare function cleanBuildJobs(options?: {
+    readonly olderThanMs?: number;
+    readonly states?: readonly BuildJobState[];
+}): Promise<number>;
 
 interface ChapterGraphBuildArtifact {
     readonly documentPath: string;
     readonly chapterId: number;
+    readonly objectsPath: string;
     readonly parameter: GraphBuildParameterInput$1;
 }
 interface GraphBuildParameterInput$1 {
     readonly language?: string;
     readonly prompt: string;
 }
-interface ChapterSummaryInputSnapshot {
-    readonly filePath: string;
-}
-interface BuildChapterGraphArtifactOptions extends GenerateChapterGraphOptions {
+interface BuildChapterGraphArtifactOptions {
+    readonly extractionPrompt?: string;
+    readonly llm: LLM<WikiGraphScope>;
+    readonly logDirPath?: string;
+    readonly progressTracker?: SerialProgressSink;
     readonly sourceText: readonly string[];
+    readonly userLanguage?: Language;
     readonly workspacePath: string;
 }
-interface BuildChapterSummaryArtifactOptions extends GenerateChapterSummaryOptions {
-    readonly snapshotPath?: string;
-    readonly sourceDocumentPath?: string;
-    readonly workspacePath: string;
-}
+
+declare function buildChapterGraphArtifact(chapterId: number, options: BuildChapterGraphArtifactOptions): Promise<ChapterGraphBuildArtifact>;
+declare function commitChapterGraphArtifact(document: Document, artifact: ChapterGraphBuildArtifact): Promise<ChapterDetails>;
+
 declare function readChapterBuildInput(document: ReadonlyDocument, chapterId: number): Promise<{
     readonly details: ChapterDetails;
     readonly revision: number;
     readonly sourceText: readonly string[];
 }>;
-declare function buildChapterGraphArtifact(chapterId: number, options: BuildChapterGraphArtifactOptions): Promise<ChapterGraphBuildArtifact>;
-declare function commitChapterGraphArtifact(document: Document, artifact: ChapterGraphBuildArtifact): Promise<ChapterDetails>;
+
+interface ChapterSummaryInputSnapshot {
+    readonly filePath: string;
+    readonly objectsPath: string;
+}
+interface BuildChapterSummaryArtifactOptions {
+    readonly llm: LLM<WikiGraphScope>;
+    readonly logDirPath?: string;
+    readonly readingGraphObjectsPath?: string;
+    readonly snapshotPath?: string;
+    readonly sourceDocumentPath?: string;
+    readonly userLanguage?: Language;
+    readonly workspacePath: string;
+}
+interface SummaryInputSnapshotData {
+    readonly chunks: readonly ChunkRecord[];
+    readonly fragmentGroups: readonly SentenceGroupRecord[];
+    readonly fragments: readonly FragmentRecord[];
+    readonly readingEdges: readonly ReadingEdgeRecord[];
+    readonly serial: SerialRecord;
+    readonly snakeChunks: readonly SnakeChunkRecord[];
+    readonly snakeEdges: readonly SnakeEdgeRecord[];
+    readonly snakes: readonly SnakeRecord[];
+}
+
 declare function buildChapterSummaryArtifact(document: ReadonlyDocument, chapterId: number, options: BuildChapterSummaryArtifactOptions): Promise<string>;
 declare function buildChapterSummaryArtifactFromSnapshot(chapterId: number, options: BuildChapterSummaryArtifactOptions & {
     readonly snapshotPath: string;
 }): Promise<string>;
+declare function buildChapterSummaryArtifactFromReadingGraphObjects(chapterId: number, options: BuildChapterSummaryArtifactOptions & {
+    readonly readingGraphObjectsPath: string;
+}): Promise<string>;
 declare function commitChapterSummaryArtifact(document: Document, chapterId: number, summary: string): Promise<ChapterDetails>;
 declare function snapshotChapterSummaryInput(document: ReadonlyDocument, chapterId: number, workspacePath: string): Promise<ChapterSummaryInputSnapshot>;
 
@@ -2369,6 +2384,7 @@ interface ChapterKnowledgeGraphBuildArtifact {
     readonly chapterId: number;
     readonly mentionLinksPath: string;
     readonly mentionsPath: string;
+    readonly objectsPath: string;
     readonly parameter: GraphBuildParameterInput;
     readonly workspacePath: string;
 }
@@ -2387,33 +2403,58 @@ interface BuildChapterKnowledgeGraphArtifactOptions {
     readonly workspacePath: string;
 }
 interface GenerateChapterKnowledgeGraphArtifactOptions {
-    readonly policyPrompt: string;
+    readonly policyPrompt?: string;
     readonly progressTracker?: Pick<BuildJobProgressReporter, "throwIfStopped" | "updatePhase">;
     readonly request: GuaranteedRequestController;
     readonly resolverOptions?: Omit<WikipageResolverOptions, "progress">;
     readonly wikispine?: Pick<MatchWikispineSentenceCandidatesOptions, "command" | "dataDir" | "endpoint" | "provider">;
     readonly workspacePath: string;
 }
+type KnowledgeGraphProgressTracker = GenerateChapterKnowledgeGraphArtifactOptions["progressTracker"];
+
+declare function buildChapterKnowledgeGraphArtifact(chapterId: number, options: BuildChapterKnowledgeGraphArtifactOptions): Promise<ChapterKnowledgeGraphBuildArtifact>;
+
+declare function commitChapterKnowledgeGraphArtifact(document: Document, artifact: ChapterKnowledgeGraphBuildArtifact): Promise<void>;
+declare function clearChapterKnowledgeGraph(document: Document, chapterId: number): Promise<void>;
+
 declare function generateChapterKnowledgeGraphArtifact(document: ReadonlyDocument, chapterId: number, options: GenerateChapterKnowledgeGraphArtifactOptions): Promise<ChapterKnowledgeGraphBuildArtifact>;
-declare function snapshotChapterKnowledgeGraphInput(document: ReadonlyDocument, chapterId: number): Promise<ChapterKnowledgeGraphInputSnapshot>;
 declare function generateChapterKnowledgeGraphArtifactFromSnapshot(chapterId: number, snapshot: ChapterKnowledgeGraphInputSnapshot, options: GenerateChapterKnowledgeGraphArtifactOptions): Promise<ChapterKnowledgeGraphBuildArtifact>;
-declare function buildChapterKnowledgeGraphArtifact(chapterId: number, options: BuildChapterKnowledgeGraphArtifactOptions): Promise<ChapterKnowledgeGraphBuildArtifact>;
+
 declare function groundWikimatchCandidates(input: {
     readonly candidates: readonly WikimatchCandidate[];
     readonly policyPrompt: string;
-    readonly progressTracker?: Pick<BuildJobProgressReporter, "throwIfStopped" | "updatePhase">;
+    readonly progressTracker?: KnowledgeGraphProgressTracker;
     readonly request: GuaranteedRequestController;
     readonly text: string;
 }): Promise<readonly WikimatchAcceptedMention[]>;
+
 declare function createEnrichmentProgressReporter(progressTracker: Pick<BuildJobProgressReporter, "throwIfStopped" | "updatePhase">): (event: WikipageResolveProgress) => Promise<void>;
-declare function commitChapterKnowledgeGraphArtifact(document: Document, artifact: ChapterKnowledgeGraphBuildArtifact): Promise<void>;
-declare function clearChapterKnowledgeGraph(document: Document, chapterId: number): Promise<void>;
 
-declare function writeWikgArchive(documentDirectoryPath: string, outputPath: string): Promise<void>;
+declare function snapshotChapterKnowledgeGraphInput(document: ReadonlyDocument, chapterId: number): Promise<ChapterKnowledgeGraphInputSnapshot>;
+
+declare const DEFAULT_EXTRACTION_PROMPT = "Focus on the main storyline and key character developments. Preserve important dialogues and critical plot points. Background descriptions and minor details can be compressed significantly.";
+declare const DEFAULT_KNOWLEDGE_GRAPH_RECALL_PROMPT: string;
+declare function resolveExtractionPrompt(prompt: string | undefined): string;
+declare function resolveKnowledgeGraphRecallPrompt(prompt: string | undefined): string;
+
+declare function formatChapterUri(path: string): string;
+declare function parseChapterPath(value: string, label?: string): string;
+declare function parseChapterUriPath(uri: string): string | undefined;
+
 declare function readWikgArchiveFormatVersion(documentDirectoryPath: string): Promise<number>;
 
+declare function writeWikgArchive(documentDirectoryPath: string, outputPath: string): Promise<void>;
+
 declare const WIKI_GRAPH_URI_PREFIX = "wikg://";
 declare const WIKI_GRAPH_JOB_URI_PREFIX = "wikg://local/job";
+interface ParsedWikiGraphUri {
+    readonly protocol: string;
+    readonly path: readonly string[];
+    readonly fragment?: number | {
+        readonly begin: number;
+        readonly end: number;
+    };
+}
 interface LocatedWikiGraphUri {
     readonly archivePath?: string;
     readonly objectUri?: string;
@@ -2421,11 +2462,12 @@ interface LocatedWikiGraphUri {
 declare function isWikiGraphUri(value: string | undefined): value is string;
 declare function isWikiGraphJobUri(value: string | undefined): value is string;
 declare function parseLocatedWikiGraphUri(uri: string): LocatedWikiGraphUri;
+declare function parseWikiGraphUriSyntax(uri: string): ParsedWikiGraphUri;
 declare function formatLocatedWikiGraphUri(archivePath: string, objectUri?: string): string;
 declare function formatWikiGraphCommandUri(archivePath: string, objectUri?: string, cwd?: string): string;
-declare function formatLocatedChapterUri(archivePath: string, chapterId: number): string;
-declare function formatLocatedChapterResourceUri(archivePath: string, chapterId: number, resource: "source" | "summary" | "title"): string;
-declare function formatLocatedChapterSourceCollectionUri(archivePath: string, chapterId: number): string;
+declare function formatLocatedChapterUri(archivePath: string, chapterPath: string): string;
+declare function formatLocatedChapterResourceUri(archivePath: string, chapterPath: string, resource: "source" | "summary" | "title"): string;
+declare function formatLocatedChapterSourceCollectionUri(archivePath: string, chapterPath: string): string;
 declare function requireArchiveUri(uri: string): string;
 declare function requireLocatedObjectUri(uri: string): {
     readonly archivePath: string;
@@ -2451,6 +2493,64 @@ declare class WikiGraphArchiveFile {
     }): Promise<T>;
 }
 
+declare function ensureWikiGraphHomeSchemaCurrent(): Promise<void>;
+declare function readWikiGraphHomeSchemaVersion(coreDatabasePath?: string): Promise<number>;
+
+declare function ensureWikiGraphArchiveSchemaCurrent(archivePath: string): Promise<void>;
+declare function readWikiGraphArchiveSchemaVersion(archivePath: string): Promise<number>;
+declare function upgradeWikiGraphArchiveSchema(archivePath: string): Promise<void>;
+
+type WikiGraphMaintenanceUpgradeResult = {
+    readonly kind: "home";
+    readonly path: string;
+    readonly schemaVersionBefore: number;
+    readonly schemaVersionAfter: number;
+    readonly status: "already-current" | "upgraded";
+} | {
+    readonly kind: "archive";
+    readonly path: string;
+    readonly schemaVersionBefore: number;
+    readonly schemaVersionAfter: number;
+    readonly status: "already-current" | "upgraded";
+} | {
+    readonly kind: "sdpub";
+    readonly inputPath: string;
+    readonly outputPath: string;
+    readonly status: "migrated";
+} | WikiGraphLibraryUpgradeResult;
+interface WikiGraphLibraryUpgradeResult {
+    readonly kind: "lib";
+    readonly library: {
+        readonly id: number;
+        readonly publicId: string;
+        readonly uri: string;
+        readonly folderPath: string;
+        readonly stagingPath: string;
+    };
+    readonly upgraded: readonly WikiGraphLibraryArchiveUpgradeItem[];
+    readonly skipped: readonly WikiGraphLibraryArchiveUpgradeItem[];
+    readonly failed?: WikiGraphLibraryArchiveFailure | undefined;
+    readonly status: "already-current" | "partial" | "upgraded";
+}
+interface WikiGraphLibraryArchiveUpgradeItem {
+    readonly publicId: string;
+    readonly uri: string;
+    readonly path: string;
+    readonly schemaVersionBefore: number;
+    readonly schemaVersionAfter: number;
+}
+interface WikiGraphLibraryArchiveFailure {
+    readonly publicId: string;
+    readonly uri: string;
+    readonly path: string;
+    readonly message: string;
+}
+declare function upgradeWikiGraphMaintenanceTarget(target: string, options?: {
+    readonly outputPath?: string;
+}): Promise<WikiGraphMaintenanceUpgradeResult>;
+declare function assertWikiGraphLibrarySchemaCurrent(target: ParsedWikiGraphLibraryUri): Promise<void>;
+declare function upgradeWikiGraphLibrarySchema(target: ParsedWikiGraphLibraryUri): Promise<WikiGraphLibraryUpgradeResult>;
+
 interface LegacySdpubMigrationResult {
     readonly inputPath: string;
     readonly outputPath: string;
@@ -2459,4 +2559,140 @@ declare function migrateLegacySdpubToWikg(inputPath: string, outputPath?: string
 
 declare function formatError(error: unknown): string;
 
-export { type AddChapterOptions, type AdvanceChapterStagesOptions, type AdvanceChapterStagesProgressCallback, type AdvanceChapterStagesProgressEvent, type AdvanceChapterStagesResult, type ArchiveBacklinkBucket, type ArchiveBacklinks, type ArchiveCollectionOptions, type ArchiveCollectionResult, type ArchiveCollectionType, type ArchiveEvidence, type ArchiveEvidenceItem, type ArchiveFindEvidencePreview, type ArchiveFindField, type ArchiveFindFilterType, type ArchiveFindHit, type ArchiveFindObjectType, type ArchiveFindOptions, type ArchiveFindOrder, type ArchiveFindPosition, type ArchiveFindResult, type ArchiveIndex, type ArchiveIndexSettings, type ArchiveListItem, type ArchiveListKind, type ArchiveNodeLabel, type ArchiveNodeSourceFragment, type ArchiveObjectType, type ArchivePack, type ArchivePage, type ArchiveRelatedResult, type ArchiveTriplePattern, type BookMeta, type BuildChapterGraphArtifactOptions, type BuildChapterKnowledgeGraphArtifactOptions, type BuildChapterSummaryArtifactOptions, BuildJobProgressReporter, type BuildWikimatchSurfaceProtectionInputOptions, type BuildWikimatchWindowsOptions, CHAPTER_STAGES, CLI_FULL_COMMAND, CLI_PRIMARY_COMMAND, type CachedDisambiguationRecord, type CachedPageRecord, type CachedQidRecord, type ChapterDetails, type ChapterEntry, type ChapterGraphBuildArtifact, type ChapterKnowledgeGraphBuildArtifact, type ChapterKnowledgeGraphInputSnapshot, type ChapterStage, type ChapterTree, type ChapterTreeApplyResult, type ChapterTreeInput, type ChapterTreeInputNode, type ChapterTreeMoveChange, type ChapterTreeNode, type ChapterTreeTitleChange, ChunkImportance, type ChunkRecord, ChunkRetention, ChunkStore, type ContinuationCursor, type CreateSnakeRecord, DEFAULT_WIKISPINE_FETCH_ENDPOINT, Database, type DigestProgressEvent, DirectoryDocument, type DisambiguationExpansion, type DisambiguationLinkedQid, type DisambiguationMeaningPriority, type DisambiguationPageText, type DisambiguationProfile, type DisambiguationProfileMeaning, type DisambiguationProfileNormalizer, type DisambiguationProfileNormalizerInput, type Document, type DocumentContext, EVIDENCE_SELECTION_JSON_SHAPE, EVIDENCE_SELECTION_PROMPT_FRAGMENT, type EvidenceQuoteMatchStrategy, type EvidenceQuoteScore, type EvidenceSelection, type EvidenceSelectionCandidate, type EvidenceSelectionFailure, type EvidenceSelectionList, type EvidenceSelectionResolution, type EvidenceSelectionSentence, type EvidenceSentenceId, FragmentDraft, FragmentGroupStore, type FragmentRecord, Fragments, type GenerateChapterGraphOptions, type GenerateChapterSummaryOptions, type GraphBuildParameterRecord, GraphBuildParameterStore, type GraphEdge, type GraphEvidenceLine, type GraphNeighbor, type GraphNode, type GraphPathStep, type GraphSearchField, type GraphSearchHit, type GraphStatus, type GuaranteedRequest, type GuaranteedRequestController, type JudgeWikimatchPolicyOptions, type JudgeWikimatchSurfaceProtectionOptions, LLM, type LLMOptions, LLMPaymentRequiredError, type LLMRequestOptions, type LLMStreamProgressCallback, type LLMTokenUsage, type LLMTokenUsageCallback, type LLMessage, Language, LanguageCode, type LocatedWikiGraphUri, type MatchWikispineSentenceCandidatesOptions, type MentionLinkRecord, MentionLinkStore, type MentionRecord, MentionStore, type MoveChapterOptions, type NarrowWikimatchCandidateOptionsInput, type NarrowWikimatchCandidateOptionsOptions, ObjectMetadataKind, ObjectMetadataStore, type ObjectMetadataTarget, type QidResolution, RateLimiter, type ReadingEdgeRecord, ReadingEdgeStore, type ReadonlyChunkStore, type ReadonlyDocument, type ReadonlyFragmentGroupStore, type ReadonlyTextStreams as ReadonlyFragments, type ReadonlyGraphBuildParameterStore, type ReadonlyMentionLinkStore, type ReadonlyMentionStore, type ReadonlyObjectMetadataStore, type ReadonlyReadingEdgeStore, type ReadonlySerialTextStream as ReadonlySerialFragments, type ReadonlySerialStore, type ReadonlySerialTextStream, type ReadonlySnakeChunkStore, type ReadonlySnakeEdgeStore, type ReadonlySnakeStore, type ReadonlyTextStreams, SCHEMA_SQL, SEARCH_INDEX_FTS_HIT_LIMIT, SEARCH_OBJECT_PROPERTY_KIND, SEARCH_OBJECT_PROPERTY_OWNER_KIND, type SearchIndexInput, type SearchIndexObjectHit, type SearchIndexProgressEvent, type SearchIndexProgressPhase, type SearchIndexProgressReporter, type SearchIndexQueryResult, type SearchIndexStatus, type SearchIndexTextHit, type SearchObjectPropertyKind, type SearchObjectPropertyOwnerKind, type SearchSessionDescriptor, type SearchSessionInput, type SearchSessionPage, type SentenceGroupRecord, type SentenceId, type SentenceRecord, type SerialDiscoveryItem, SerialFragments, type SerialProgressEvent, type SerialRecord, SerialStore, SerialTextStream, type SerialsDiscoveredEvent, type SnakeChunkRecord, SnakeChunkStore, type SnakeEdgeRecord, SnakeEdgeStore, type SnakeRecord, SnakeStore, TEXT_SENTENCE_KIND, TOC_FILE_VERSION, type TestWikispineRuntimeOptions, type TextSentenceKind, TextStreams, WIKI_GRAPH_CONTEXT_VERSION, WIKI_GRAPH_EDITOR_SCOPES, WIKI_GRAPH_JOB_URI_PREFIX, WIKI_GRAPH_READER_SCOPES, WIKI_GRAPH_SCOPES, WIKI_GRAPH_URI_PREFIX, WikiGraph, WikiGraphArchive, WikiGraphArchiveFile, type WikiGraphLLMOptions, type WikiGraphOpenSessionOptions, type WikiGraphOperation, type WikiGraphOptions, type WikiGraphProgressCallback, type WikiGraphProgressEvent, type WikiGraphProgressEventType, WikiGraphScope, type WikiGraphSerialEntry, type WikiGraphSourceSessionOptions, WikiGraphTask, WikiGraphTaskContext, type WikiGraphTaskContextOptions, type WikiGraphTaskIdentity, type WikiGraphTaskType, type WikiGraphTextStreamSessionOptions, type WikimatchAcceptedMention, type WikimatchCandidate, type WikimatchCandidateOptionNarrowingFallback, type WikimatchCandidateOptionNarrowingItemOutput, type WikimatchCandidateOptionNarrowingResponse, type WikimatchCandidateOptionNarrowingResult, type WikimatchConflictGroup, type WikimatchPolicyContinuation, type WikimatchPolicyDecision, type WikimatchPolicyDecisionOutput, type WikimatchPolicyFallback, type WikimatchPolicyJudgeInput, type WikimatchPolicyJudgeResult, type WikimatchPolicyResponse, type WikimatchPolicyUpdate, type WikimatchProtectedSurface, type WikimatchQidOption, type WikimatchSentence, type WikimatchSurface, type WikimatchSurfaceProtectionBuildResult, type WikimatchSurfaceProtectionFallback, type WikimatchSurfaceProtectionInput, type WikimatchSurfaceProtectionResponse, type WikimatchSurfaceProtectionResult, type WikimatchTextRange, type WikimatchWindow, WikimediaClient, WikipageCache, WikipageResolver, type WikipageResolverOptions, type WikipageSitelink, type WikispineProvider, type WikispineRuntimeTestResult, addChapter, advanceChapterStages, applyChapterTree, applyQidResolutions, buildChapterGraphArtifact, buildChapterKnowledgeGraphArtifact, buildChapterSummaryArtifact, buildChapterSummaryArtifactFromSnapshot, buildWikimatchSurfaceProtectionInput, buildWikimatchWindows, clearChapterKnowledgeGraph, clearDirtyArchiveSearchIndex, commitChapterGraphArtifact, commitChapterKnowledgeGraphArtifact, commitChapterSummaryArtifact, countWikimatchCandidateOptions, countWikimatchQidOption, createArchiveSearchIndexFingerprint, createContinuationCursor, createDefaultWikiGraphSampling, createDisambiguationProfileNormalizer, createEnrichmentProgressReporter, createEnv, createSearchIndexFingerprint, createSearchSession, createWikiGraphTaskId, createWikiGraphTempDirectory, deleteArchiveSearchSessions, enrichWikimatchCandidates, ensureSearchIndex, ensureSharedStateDatabaseInitialized, expandRangeByWords, expectChunkImportance, expectChunkRetention, filterCandidateQidOptions, findArchiveObjects, findGraphPath, formatCandidateForPrompt, formatChapterId, formatEdgeId, formatError, formatEvidenceSelectionChoicePrompt, formatLanguageForPrompt, formatLocatedChapterResourceUri, formatLocatedChapterSourceCollectionUri, formatLocatedChapterUri, formatLocatedWikiGraphUri, formatNodeId, formatSummaryId, formatWikiGraphCommandUri, generateChapterGraph, generateChapterKnowledgeGraphArtifact, generateChapterKnowledgeGraphArtifactFromSnapshot, generateChapterSummary, getArchiveIndex, getChapterDetails, getChapterTree, getGraphEvidence, getGraphNode, getGraphStatus, getLanguageCode, getWikipageLanguageCode, grepArchiveObjects, groundWikimatchCandidates, isArchiveSearchIndexCurrent, isChunkImportance, isChunkRetention, isSearchIndexCurrent, isWikiGraphJobUri, isWikiGraphUri, judgeWikimatchPolicy, judgeWikimatchSurfaceProtection, listAllArchiveLinks, listArchiveCollection, listArchiveEvidence, listArchiveLinks, listArchiveObjects, listCandidateSelectableQids, listChapters, listGraphNeighbors, listGraphNodes, listRelatedArchiveObjects, listWordBoundaries, matchWikispineSentenceCandidates, migrateLegacySdpubToWikg, moveChapter, narrowWikimatchCandidateOptions, normalizeEvidenceDisplayText, normalizeEvidenceText, normalizeLanguageCode, openSharedStateDatabase, packArchiveContext, parseChapterTreeInput, parseLocatedWikiGraphUri, parseNarrowingResponse, parsePolicyResponse, parseRetryAfterMs, parseSurfaceProtectionResponse, querySearchIndex, rankEvidenceQuote, readArchiveIndexSettings, readArchivePage, readArchiveSearchIndexStatus, readArchiveText, readCachedSearchSessionPage, readChapterBuildInput, readContinuationCursor, readSearchIndexFingerprintFromDatabase, readSearchIndexStatus, readWikgArchiveFormatVersion, rebuildArchiveSearchIndex, removeChapter, requireArchiveUri, requireLocatedObjectOrArchiveUri, requireLocatedObjectUri, resetChapter, resolveDataDirPath, resolveEvidenceSelection, resolveEvidenceSelectionList, resolveWikiGraphCoreDatabasePath, resolveWikiGraphHomeDirectoryPath, resolveWikiGraphStateRootPath, runSearchCacheGc, scoreEvidenceQuote, searchGraphNodes, setChapterSource, setChapterSummary, setChapterTitle, setFtsIndexEmbedded, sliceCandidateByOptionBudget, snapshotChapterKnowledgeGraphInput, snapshotChapterSummaryInput, splitCandidateByOptionBudget, suppressContainedRanges, testWikispineRuntime, validateNarrowingResponse, validatePolicyResponse, validateSurfaceProtectionResponse, withLoggingContext, writeWikgArchive };
+declare const WIKG_OBJECT_SCHEMA_VERSION = 1;
+type WikgObject = WikgMetaObject | WikgParameterObject | WikgSourceFragmentObject | WikgReadingChunkObject | WikgReadingEdgeObject | WikgFragmentGroupObject | WikgSnakeObject | WikgSnakeChunkObject | WikgSnakeEdgeObject | WikgSummaryObject | WikgMentionObject | WikgMentionLinkObject | WikgEndObject;
+interface WikgMetaObject {
+    readonly type: "meta";
+    readonly schemaVersion: typeof WIKG_OBJECT_SCHEMA_VERSION;
+    readonly chapterId: number;
+    readonly stream: "knowledge-graph" | "reading-graph" | "summary";
+}
+interface WikgParameterObject {
+    readonly type: "parameter";
+    readonly scope: "knowledge-graph" | "reading-graph" | "summary";
+    readonly language?: string;
+    readonly prompt: string;
+}
+interface WikgSourceFragmentObject {
+    readonly type: "source-fragment";
+    readonly fragmentId: number;
+    readonly summary: string;
+    readonly sentences: readonly SentenceRecord[];
+}
+interface WikgReadingChunkObject {
+    readonly type: "reading-chunk";
+    readonly id: string;
+    readonly generation: number;
+    readonly sentenceIndex: number;
+    readonly label: string;
+    readonly content: string;
+    readonly sentenceIndexes: readonly number[];
+    readonly retention?: ChunkRetention;
+    readonly importance?: ChunkImportance;
+    readonly wordsCount: number;
+    readonly weight: number;
+}
+interface WikgReadingEdgeObject {
+    readonly type: "reading-edge";
+    readonly fromChunkId: string;
+    readonly toChunkId: string;
+    readonly strength?: string;
+    readonly weight: number;
+}
+interface WikgFragmentGroupObject {
+    readonly type: "fragment-group";
+    readonly groupId: number;
+    readonly startSentenceIndex: number;
+    readonly endSentenceIndex: number;
+}
+interface WikgSnakeObject {
+    readonly type: "snake";
+    readonly id: string;
+    readonly groupId: number;
+    readonly localSnakeId: number;
+    readonly size: number;
+    readonly firstLabel: string;
+    readonly lastLabel: string;
+    readonly wordsCount: number;
+    readonly weight: number;
+}
+interface WikgSnakeChunkObject {
+    readonly type: "snake-chunk";
+    readonly snakeId: string;
+    readonly chunkId: string;
+    readonly position: number;
+}
+interface WikgSnakeEdgeObject {
+    readonly type: "snake-edge";
+    readonly fromSnakeId: string;
+    readonly toSnakeId: string;
+    readonly weight: number;
+}
+interface WikgSummaryObject {
+    readonly type: "summary";
+    readonly text: string;
+}
+interface WikgMentionObject {
+    readonly type: "mention";
+    readonly id: string;
+    readonly fragmentId?: number;
+    readonly sentenceIndex?: number;
+    readonly rangeStart: number;
+    readonly rangeEnd: number;
+    readonly surface: string;
+    readonly qid: string;
+    readonly confidence?: number;
+    readonly note?: string;
+}
+interface WikgMentionLinkObject {
+    readonly type: "mention-link";
+    readonly id: string;
+    readonly sourceMentionId: string;
+    readonly targetMentionId: string;
+    readonly predicate: string;
+    readonly evidenceSentenceIndexes: readonly number[];
+    readonly confidence?: number;
+    readonly note?: string;
+}
+interface WikgEndObject {
+    readonly type: "end";
+}
+interface ChapterKnowledgeGraphObjects {
+    readonly mentionLinks: readonly MentionLinkRecord[];
+    readonly mentions: readonly MentionRecord[];
+    readonly parameter?: WikgParameterObject;
+}
+declare function parseWikgObject(record: unknown): WikgObject;
+declare function writeWikgObjectsToJsonl(path: string, objects: AsyncIterable<WikgObject> | Iterable<WikgObject>): Promise<void>;
+declare function readWikgObjectsFromJsonl(path: string): AsyncGenerator<WikgObject>;
+declare function createChapterKnowledgeGraphObjectStream(input: {
+    readonly chapterId: number;
+    readonly mentionLinks: AsyncIterable<MentionLinkRecord> | Iterable<MentionLinkRecord>;
+    readonly mentions: AsyncIterable<MentionRecord> | Iterable<MentionRecord>;
+    readonly parameter?: {
+        readonly language?: string;
+        readonly prompt: string;
+    };
+}): AsyncGenerator<WikgObject>;
+declare function collectChapterKnowledgeGraphObjects(chapterId: number, objects: AsyncIterable<WikgObject> | Iterable<WikgObject>): Promise<ChapterKnowledgeGraphObjects>;
+declare function createChapterReadingGraphObjectStream(input: {
+    readonly chapterId: number;
+    readonly document: ReadonlyDocument;
+    readonly parameter?: {
+        readonly language?: string;
+        readonly prompt: string;
+    };
+}): AsyncGenerator<WikgObject>;
+declare function collectReadingGraphObjects(chapterId: number, objects: AsyncIterable<WikgObject> | Iterable<WikgObject>): Promise<{
+    readonly chunks: readonly WikgReadingChunkObject[];
+    readonly fragmentGroups: readonly WikgFragmentGroupObject[];
+    readonly fragments: readonly FragmentRecord[];
+    readonly parameter?: WikgParameterObject;
+    readonly readingEdges: readonly WikgReadingEdgeObject[];
+    readonly snakeChunks: readonly WikgSnakeChunkObject[];
+    readonly snakeEdges: readonly WikgSnakeEdgeObject[];
+    readonly snakes: readonly WikgSnakeObject[];
+}>;
+declare function createSummaryInputSnapshotFromReadingGraphObjects(chapterId: number, objects: AsyncIterable<WikgObject> | Iterable<WikgObject>): Promise<SummaryInputSnapshotData>;
+
+export { AddBuildJobOptions, type AddChapterOptions, type AdvanceChapterStagesOptions, type AdvanceChapterStagesProgressCallback, type AdvanceChapterStagesProgressEvent, type AdvanceChapterStagesResult, type ArchiveBacklinkBucket, type ArchiveBacklinks, type ArchiveCollectionOptions, type ArchiveCollectionResult, type ArchiveCollectionType, type ArchiveEvidence, type ArchiveEvidenceItem, type ArchiveFindEvidencePreview, type ArchiveFindField, type ArchiveFindFilterType, type ArchiveFindHit, type ArchiveFindObjectType, type ArchiveFindOptions, type ArchiveFindOrder, type ArchiveFindPosition, type ArchiveFindResult, type ArchiveIndex, type ArchiveLibrarySource, type ArchiveListItem, type ArchiveListKind, type ArchiveNodeLabel, type ArchiveNodeSourceFragment, type ArchiveObjectType, type ArchivePack, type ArchivePage, type ArchiveRelatedResult, type ArchiveTriplePattern, type BookMeta, type BuildChapterGraphArtifactOptions, type BuildChapterKnowledgeGraphArtifactOptions, type BuildChapterSummaryArtifactOptions, BuildJob, BuildJobConflictScope, BuildJobEvent, BuildJobListOptions, BuildJobProgressReporter, BuildJobState, BuildJobTarget, type BuildWikimatchWindowsOptions, CHAPTER_STAGES, CLI_FULL_COMMAND, CLI_PRIMARY_COMMAND, type CachedDisambiguationRecord, type CachedPageRecord, type CachedQidRecord, type ChapterDetails, type ChapterEntry, type ChapterGraphBuildArtifact, type ChapterKnowledgeGraphBuildArtifact, type ChapterKnowledgeGraphInputSnapshot, type ChapterStage, type ChapterTree, type ChapterTreeApplyResult, type ChapterTreeInput, type ChapterTreeInputNode, type ChapterTreeMoveChange, type ChapterTreeNode, type ChapterTreeTitleChange, type ContinuationCursor, DEFAULT_EXTRACTION_PROMPT, DEFAULT_KNOWLEDGE_GRAPH_RECALL_PROMPT, DEFAULT_WIKISPINE_FETCH_ENDPOINT, Database, type DigestProgressEvent, DirectoryDocument, type DisambiguationExpansion, type DisambiguationLinkedQid, type DisambiguationMeaningPriority, type DisambiguationPageText, type DisambiguationProfile, type DisambiguationProfileError, type DisambiguationProfileMeaning, type DisambiguationProfileNormalizer, type DisambiguationProfileNormalizerInput, type Document, EVIDENCE_SELECTION_JSON_SHAPE, EVIDENCE_SELECTION_PROMPT_FRAGMENT, type EnrichmentStore, type EvidenceQuoteMatchStrategy, type EvidenceQuoteScore, type EvidenceSelection, type EvidenceSelectionCandidate, type EvidenceSelectionFailure, type EvidenceSelectionList, type EvidenceSelectionResolution, type EvidenceSelectionSentence, type EvidenceSentenceId, type GenerateChapterGraphOptions, type GenerateChapterSummaryOptions, type GuaranteedRequest, type GuaranteedRequestController, type JudgeWikimatchPolicyOptions, LLM, type LLMOptions, LLMPaymentRequiredError, type LLMRequestOptions, type LLMStreamProgressCallback, type LLMTokenUsage, type LLMTokenUsageCallback, type LLMessage, Language, LanguageCode, type LocatedWikiGraphUri, type MoveChapterOptions, ObjectMetadataKind, type ObjectMetadataTarget, type ParsedWikiGraphLibraryUri, type ParsedWikiGraphUri, type QidResolution, type QueryIndexScope, type QueryScope, RateLimiter, type ReadonlyDocument, type SerialDiscoveryItem, type SerialProgressEvent, type SerialsDiscoveredEvent, TOC_FILE_VERSION, WIKG_OBJECT_SCHEMA_VERSION, WIKI_GRAPH_CONTEXT_VERSION, WIKI_GRAPH_EDITOR_SCOPES, WIKI_GRAPH_JOB_URI_PREFIX, WIKI_GRAPH_READER_SCOPES, WIKI_GRAPH_SCOPES, WIKI_GRAPH_URI_PREFIX, type WikgObject, type WikiClient, WikiGraph, WikiGraphArchive, WikiGraphArchiveFile, type WikiGraphLLMOptions, type WikiGraphLibraryArchiveRecord, type WikiGraphLibraryIndexObjectHit, type WikiGraphLibraryIndexQueryResult, type WikiGraphLibraryIndexSource, type WikiGraphLibraryIndexState, type WikiGraphLibraryIndexStatus, type WikiGraphLibraryIndexTextHit, type WikiGraphLibraryRecord, type WikiGraphLibraryScanResult, type WikiGraphLibraryUpgradeResult, type WikiGraphMaintenanceUpgradeResult, type WikiGraphOpenSessionOptions, type WikiGraphOperation, type WikiGraphOptions, type WikiGraphProgressCallback, type WikiGraphProgressEvent, type WikiGraphProgressEventType, WikiGraphScope, type WikiGraphSerialEntry, type WikiGraphSourceSessionOptions, WikiGraphTask, WikiGraphTaskContext, type WikiGraphTaskContextOptions, type WikiGraphTaskIdentity, type WikiGraphTaskType, type WikiGraphTextStreamSessionOptions, type WikimatchAcceptedMention, type WikimatchCandidate, type WikimatchConflictGroup, type WikimatchPolicyDecision, type WikimatchPolicyDecisionOutput, type WikimatchPolicyFallback, type WikimatchPolicyJudgeInput, type WikimatchPolicyJudgeResult, type WikimatchPolicyResponse, type WikimatchPolicyUpdate, type WikimatchQidOption, type WikimatchTextRange, type WikimatchWindow, WikimediaClient, WikipageCache, WikipageResolver, type WikipageResolverOptions, type WikipageSitelink, type WikispineProvider, addBuildJob, addChapter, addWikiGraphLibraryArchive, advanceChapterStages, applyChapterTree, assertBuildJobInputRevision, assertNoActiveBuildJobConflicts, assertNoActiveBuildJobs, assertWikiGraphLibrarySchemaCurrent, boostBuildJob, buildChapterGraphArtifact, buildChapterKnowledgeGraphArtifact, buildChapterSummaryArtifact, buildChapterSummaryArtifactFromReadingGraphObjects, buildChapterSummaryArtifactFromSnapshot, buildWikimatchWindows, cancelBuildJob, cleanBuildJobs, clearChapterKnowledgeGraph, clearWikiGraphLibraryMetadata, collectChapterKnowledgeGraphObjects, collectReadingGraphObjects, commitChapterGraphArtifact, commitChapterKnowledgeGraphArtifact, commitChapterSummaryArtifact, createChapterKnowledgeGraphObjectStream, createChapterReadingGraphObjectStream, createContinuationCursor, createDefaultWikiGraphSampling, createDisambiguationProfileNormalizer, createEnrichmentProgressReporter, createEnv, createSummaryInputSnapshotFromReadingGraphObjects, createWikiGraphLibrary, createWikiGraphTaskId, createWikiGraphTempDirectory, deleteArchiveSearchSessions, deleteWikiGraphLibraryMetadataKey, disableWikiGraphLibraryIndex, ensureDefaultWikiGraphLibrary, ensureLibraryManagedArchiveHasNoSearchIndex, ensureWikiGraphArchiveSchemaCurrent, ensureWikiGraphHomeSchemaCurrent, finalizeWikiGraphLibraryArchiveWrite, findArchiveObjects, findWikiGraphLibraryObjects, formatChapterId, formatChapterUri, formatEdgeId, formatError, formatEvidenceSelectionChoicePrompt, formatLanguageForPrompt, formatLocatedChapterResourceUri, formatLocatedChapterSourceCollectionUri, formatLocatedChapterUri, formatLocatedWikiGraphUri, formatNodeId, formatSummaryId, formatWikiGraphCommandUri, formatWikiGraphLibraryUri, generateChapterGraph, generateChapterKnowledgeGraphArtifact, generateChapterKnowledgeGraphArtifactFromSnapshot, generateChapterSummary, getArchiveIndex, getBuildJob, getChapterDetails, getChapterTree, getLanguageCode, getWikiGraphLibraryArchive, getWikiGraphLibraryArchiveById, getWikiGraphLibraryMetadata, getWikipageLanguageCode, grepArchiveObjects, groundWikimatchCandidates, isArchiveSearchIndexCurrent, isWikiGraphJobUri, isWikiGraphLibraryUri, isWikiGraphUri, judgeWikimatchPolicy, listAllArchiveLinks, listArchiveCollection, listArchiveEvidence, listArchiveLinks, listArchiveObjects, listBuildJobs, listChapters, listRelatedArchiveObjects, listRelatedWikiGraphLibraryObjects, listWikiGraphLibraries, listWikiGraphLibraryArchives, listWikiGraphLibraryEvidence, listWikiGraphLibraryIndexArchiveIdsForObject, listWikiGraphLibraryObjects, listWikiGraphLibraryScope, markWikiGraphLibraryIndexDirty, migrateLegacySdpubToWikg, moveChapter, moveWikiGraphLibraryArchive, normalizeEvidenceDisplayText, normalizeEvidenceText, normalizeLanguageCode, openSharedStateDatabase, packArchiveContext, packWikiGraphLibraryContext, parseChapterPath, parseChapterTreeInput, parseChapterUriPath, parseLocatedWikiGraphUri, parsePolicyResponse, parseRetryAfterMs, parseWikgObject, parseWikiGraphLibraryUri, parseWikiGraphUriSyntax, pauseBuildJob, putWikiGraphLibraryMetadata, queryWikiGraphLibrarySearchIndex, rankEvidenceQuote, readArchiveIndexSettings, readArchivePage, readArchiveText, readBuildJobEvents, readChapterBuildInput, readContinuationCursor, readWikgArchiveFormatVersion, readWikgObjectsFromJsonl, readWikiGraphArchiveSchemaVersion, readWikiGraphHomeSchemaVersion, readWikiGraphLibraryIndexState, readWikiGraphLibraryPage, rebindWikiGraphLibrary, rebuildArchiveSearchIndex, rebuildWikiGraphLibraryIndex, recordBuildJobInputRevision, removeChapter, removeWikiGraphLibrary, removeWikiGraphLibraryArchive, replaceWikiGraphLibraryMetadata, requireArchiveUri, requireLocatedObjectOrArchiveUri, requireLocatedObjectUri, resetChapter, resolveBuildJobId, resolveChapterPath, resolveChapterPathReadonly, resolveDataDirPath, resolveDefaultWikiGraphLibraryDirectoryPath, resolveEvidenceSelection, resolveEvidenceSelectionList, resolveExtractionPrompt, resolveKnowledgeGraphRecallPrompt, resolveWikiGraphCoreDatabasePath, resolveWikiGraphHomeDirectoryPath, resolveWikiGraphLibrary, resolveWikiGraphLibraryArchivePath, resolveWikiGraphLibraryById, resolveWikiGraphLibraryQueryTargetById, resolveWikiGraphLibraryStagingDirectoryPath, resolveWikiGraphStateRootPath, resumeBuildJob, scanWikiGraphLibrary, scoreEvidenceQuote, setChapterSource, setChapterSummary, setChapterTitle, setFtsIndexEmbedded, snapshotChapterKnowledgeGraphInput, snapshotChapterSummaryInput, testWikispineRuntime, updateBuildJobTarget, upgradeWikiGraphArchiveSchema, upgradeWikiGraphLibrarySchema, upgradeWikiGraphMaintenanceTarget, validatePolicyResponse, withLoggingContext, withWikiGraphRuntimeEnvironment, withWikiGraphRuntimeStateDirectoryPath, writeWikgArchive, writeWikgObjectsToJsonl };