@ghostpaw/grimoire 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,1775 @@
+interface GrimoireRunResult {
+    lastInsertRowid: number | bigint;
+    changes?: number | bigint | undefined;
+}
+interface GrimoireStatement {
+    run(...params: unknown[]): GrimoireRunResult;
+    get<TRecord extends Record<string, unknown>>(...params: unknown[]): TRecord | undefined;
+    all<TRecord extends Record<string, unknown>>(...params: unknown[]): TRecord[];
+}
+/**
+ * SQLite dependency injected into every grimoire operation.
+ */
+type GrimoireDb = {
+    exec(sql: string): void;
+    prepare(sql: string): GrimoireStatement;
+    close(): void;
+};
+
+type CatalogueSnapshotRow = {
+    id: number;
+    computed_at: string;
+    total_spells: number;
+    chapter_distribution: string;
+    rank_distribution: string;
+    stale_spells: string;
+    dormant_spells: string;
+    oversized_spells: string;
+    pending_notes: number;
+    notes_routed: number;
+    orphan_clusters: string;
+    drafts_queued: number;
+    chapter_balance: string;
+    spell_health: string;
+    seal_velocity: string;
+};
+interface OrphanCluster {
+    noteIds: number[];
+    memberCount: number;
+    sourceCount: number;
+    suggestedTerms: string[];
+}
+interface CatalogueSnapshot {
+    id: number;
+    computedAt: string;
+    totalSpells: number;
+    chapterDistribution: Record<string, number>;
+    rankDistribution: Record<string, number>;
+    staleSpells: string[];
+    dormantSpells: string[];
+    oversizedSpells: string[];
+    pendingNotes: number;
+    notesRouted: number;
+    orphanClusters: OrphanCluster[];
+    draftsQueued: number;
+    chapterBalance: Record<string, number>;
+    spellHealth: Record<string, number>;
+    sealVelocity: Record<string, number>;
+}
+type SaveCatalogueInput = {
+    computedAt: string;
+    totalSpells: number;
+    chapterDistribution: Record<string, number>;
+    rankDistribution: Record<string, number>;
+    staleSpells: string[];
+    dormantSpells: string[];
+    oversizedSpells: string[];
+    pendingNotes: number;
+    notesRouted: number;
+    orphanClusters: OrphanCluster[];
+    draftsQueued: number;
+    chapterBalance: Record<string, number>;
+    spellHealth: Record<string, number>;
+    sealVelocity: Record<string, number>;
+};
+
+type CatalogueOptions = {
+    staleDays?: number;
+    dormantDays?: number;
+    oversizeLines?: number;
+    routingThreshold?: number;
+    clusteringThreshold?: number;
+    resonanceHalfLife?: number;
+    now?: number;
+};
+type SpellHealth = {
+    path: string;
+    staleness: number;
+    oversizeRatio: number;
+    resonanceWeight: number;
+    health: number;
+    sealVelocity: number;
+    isStale: boolean;
+    isDormant: boolean;
+    isOversized: boolean;
+};
+type ChapterBalance = {
+    chapter: string;
+    spellCount: number;
+    pendingNotes: number;
+    noteLoadRatio: number;
+};
+
+declare function catalogue(root: string, db: GrimoireDb, options?: CatalogueOptions): CatalogueSnapshot;
+
+declare function clusterOrphans(db: GrimoireDb, threshold?: number): OrphanCluster[];
+
+declare function computeChapterBalance(spellsByChapter: Map<string, number>, notesByChapter: Map<string, number>): ChapterBalance[];
+
+declare function computeSealVelocity(sealTimestamps: number[], now: number): number;
+
+declare function computeSpellHealth(staleness: number, oversizeRatio: number, resonanceWeight: number): number;
+
+declare function computeStaleness(lastSealTs: number, lastReadTs: number | null, now: number, staleDays: number, dormantDays: number): {
+    isStale: boolean;
+    isDormant: boolean;
+    staleness: number;
+};
+
+declare function routeNotes(db: GrimoireDb, spellDescriptions: Map<string, string>, threshold?: number): number;
+
+type index$e_CatalogueOptions = CatalogueOptions;
+type index$e_ChapterBalance = ChapterBalance;
+type index$e_OrphanCluster = OrphanCluster;
+type index$e_SpellHealth = SpellHealth;
+declare const index$e_catalogue: typeof catalogue;
+declare const index$e_clusterOrphans: typeof clusterOrphans;
+declare const index$e_computeChapterBalance: typeof computeChapterBalance;
+declare const index$e_computeSealVelocity: typeof computeSealVelocity;
+declare const index$e_computeSpellHealth: typeof computeSpellHealth;
+declare const index$e_computeStaleness: typeof computeStaleness;
+declare const index$e_routeNotes: typeof routeNotes;
+declare namespace index$e {
+  export { type index$e_CatalogueOptions as CatalogueOptions, type index$e_ChapterBalance as ChapterBalance, type index$e_OrphanCluster as OrphanCluster, type index$e_SpellHealth as SpellHealth, index$e_catalogue as catalogue, index$e_clusterOrphans as clusterOrphans, index$e_computeChapterBalance as computeChapterBalance, index$e_computeSealVelocity as computeSealVelocity, index$e_computeSpellHealth as computeSpellHealth, index$e_computeStaleness as computeStaleness, index$e_routeNotes as routeNotes };
+}
+
+declare const DEFAULTS: {
+    readonly defaultChapter: "general";
+    readonly noteCap: 50;
+    readonly noteExpiryDays: 90;
+    readonly staleDays: 90;
+    readonly dormantDays: 60;
+    readonly oversizeLines: 500;
+    readonly resonanceHalfLife: 30;
+    readonly routingThreshold: 0.3;
+    readonly clusteringThreshold: 0.4;
+};
+
+declare function approveDraft(db: GrimoireDb, draftId: number): void;
+
+declare function dismissDraft(db: GrimoireDb, draftId: number): void;
+
+declare function initDraftTables(db: GrimoireDb): void;
+
+type DraftStatus = 'pending' | 'approved' | 'dismissed';
+type SpellDraftRow = {
+    id: number;
+    title: string;
+    rationale: string;
+    note_ids: string;
+    chapter: string;
+    status: string;
+    created_at: number;
+};
+interface SpellDraft {
+    id: number;
+    title: string;
+    rationale: string;
+    noteIds: number[];
+    chapter: string;
+    status: DraftStatus;
+    createdAt: number;
+}
+interface SubmitDraftInput {
+    title: string;
+    rationale: string;
+    noteIds: number[];
+    chapter: string;
+    now?: number;
+}
+
+declare function mapDraftRow(row: SpellDraftRow): SpellDraft;
+
+declare function pendingDrafts(db: GrimoireDb): SpellDraft[];
+
+declare function submitDraft(db: GrimoireDb, input: SubmitDraftInput): {
+    id: number;
+};
+
+type index$d_DraftStatus = DraftStatus;
+type index$d_SpellDraft = SpellDraft;
+type index$d_SpellDraftRow = SpellDraftRow;
+type index$d_SubmitDraftInput = SubmitDraftInput;
+declare const index$d_approveDraft: typeof approveDraft;
+declare const index$d_dismissDraft: typeof dismissDraft;
+declare const index$d_initDraftTables: typeof initDraftTables;
+declare const index$d_mapDraftRow: typeof mapDraftRow;
+declare const index$d_pendingDrafts: typeof pendingDrafts;
+declare const index$d_submitDraft: typeof submitDraft;
+declare namespace index$d {
+  export { type index$d_DraftStatus as DraftStatus, type index$d_SpellDraft as SpellDraft, type index$d_SpellDraftRow as SpellDraftRow, type index$d_SubmitDraftInput as SubmitDraftInput, index$d_approveDraft as approveDraft, index$d_dismissDraft as dismissDraft, index$d_initDraftTables as initDraftTables, index$d_mapDraftRow as mapDraftRow, index$d_pendingDrafts as pendingDrafts, index$d_submitDraft as submitDraft };
+}
+
+type GrimoireErrorCode = 'GRIMOIRE_NOT_FOUND' | 'GRIMOIRE_VALIDATION' | 'GRIMOIRE_STATE' | 'GRIMOIRE_INVARIANT';
+declare class GrimoireError extends Error {
+    readonly name: string;
+    readonly code: GrimoireErrorCode;
+    constructor(code: GrimoireErrorCode, message: string);
+}
+declare class GrimoireNotFoundError extends GrimoireError {
+    readonly name = "GrimoireNotFoundError";
+    constructor(message: string);
+}
+declare class GrimoireValidationError extends GrimoireError {
+    readonly name = "GrimoireValidationError";
+    constructor(message: string);
+}
+declare class GrimoireStateError extends GrimoireError {
+    readonly name = "GrimoireStateError";
+    constructor(message: string);
+}
+declare class GrimoireInvariantError extends GrimoireError {
+    readonly name = "GrimoireInvariantError";
+    constructor(message: string);
+}
+declare function isGrimoireError(value: unknown): value is GrimoireError;
+
+type SpellEventType = 'read' | 'seal' | 'inscribe' | 'shelve' | 'unshelve' | 'move' | 'hone' | 'adopt';
+type SpellEventRow = {
+    id: number;
+    spell: string;
+    event: string;
+    context_id: string | null;
+    ts: number;
+};
+interface SpellEvent {
+    id: number;
+    spell: string;
+    event: SpellEventType;
+    contextId: string | null;
+    ts: number;
+}
+interface LogEventInput {
+    spell: string;
+    event: SpellEventType;
+    contextId?: string;
+    now?: number;
+}
+type ResonanceColor = 'grey' | 'green' | 'yellow' | 'orange';
+type ResonanceResult = {
+    color: ResonanceColor;
+    weightedReads: number;
+    readCount: number;
+    lastSealTs: number | null;
+};
+type ResonanceOptions = {
+    resonanceHalfLife?: number;
+    now?: number;
+};
+
+declare function allResonance(db: GrimoireDb, options?: ResonanceOptions): Record<string, ResonanceResult>;
+
+declare function eventsSince(db: GrimoireDb, since: number): SpellEvent[];
+
+declare function initEventTables(db: GrimoireDb): void;
+
+declare function logEvent(db: GrimoireDb, input: LogEventInput): {
+    id: number;
+};
+
+declare function mapEventRow(row: SpellEventRow): SpellEvent;
+
+declare function resonance(db: GrimoireDb, path: string, options?: ResonanceOptions): ResonanceResult;
+
+type index$c_LogEventInput = LogEventInput;
+type index$c_ResonanceColor = ResonanceColor;
+type index$c_ResonanceOptions = ResonanceOptions;
+type index$c_ResonanceResult = ResonanceResult;
+type index$c_SpellEvent = SpellEvent;
+type index$c_SpellEventRow = SpellEventRow;
+type index$c_SpellEventType = SpellEventType;
+declare const index$c_allResonance: typeof allResonance;
+declare const index$c_eventsSince: typeof eventsSince;
+declare const index$c_initEventTables: typeof initEventTables;
+declare const index$c_logEvent: typeof logEvent;
+declare const index$c_mapEventRow: typeof mapEventRow;
+declare const index$c_resonance: typeof resonance;
+declare namespace index$c {
+  export { type index$c_LogEventInput as LogEventInput, type index$c_ResonanceColor as ResonanceColor, type index$c_ResonanceOptions as ResonanceOptions, type index$c_ResonanceResult as ResonanceResult, type index$c_SpellEvent as SpellEvent, type index$c_SpellEventRow as SpellEventRow, type index$c_SpellEventType as SpellEventType, index$c_allResonance as allResonance, index$c_eventsSince as eventsSince, index$c_initEventTables as initEventTables, index$c_logEvent as logEvent, index$c_mapEventRow as mapEventRow, index$c_resonance as resonance };
+}
+
+interface GitContext {
+    root: string;
+    gitDir?: string;
+}
+
+type Tier = 'Uncheckpointed' | 'Apprentice' | 'Journeyman' | 'Expert' | 'Master';
+type TierInfo = {
+    tier: Tier;
+    rank: number;
+    sealsToNextTier: number;
+};
+type SealResult = {
+    commitHash: string;
+    sealedPaths: string[];
+    ranks: Record<string, number>;
+};
+type RollbackResult = {
+    success: boolean;
+    restoredRef?: string;
+};
+type PendingChange = {
+    status: 'created' | 'modified' | 'deleted';
+    filePath: string;
+};
+type PendingChangesResult = {
+    spellPath: string;
+    changes: PendingChange[];
+};
+type HistoryEntry = {
+    hash: string;
+    message: string;
+    date: string;
+    files: string[];
+};
+
+declare function allRanks(ctx: GitContext): Record<string, number>;
+
+declare function diff(ctx: GitContext, path: string): string;
+
+declare function history(ctx: GitContext, path?: string): HistoryEntry[];
+
+declare function isGitAvailable(): boolean;
+
+declare function pendingChanges(ctx: GitContext, path?: string): PendingChangesResult[];
+
+declare function rank(ctx: GitContext, path: string): number;
+
+declare function rollback(ctx: GitContext, path: string, ref: string): RollbackResult;
+
+declare function seal(ctx: GitContext, db?: GrimoireDb, paths?: string[], message?: string): SealResult;
+
+declare function tier(rank: number): Tier;
+
+declare function tierInfo(rank: number): TierInfo;
+
+type index$b_GitContext = GitContext;
+type index$b_HistoryEntry = HistoryEntry;
+type index$b_PendingChange = PendingChange;
+type index$b_PendingChangesResult = PendingChangesResult;
+type index$b_RollbackResult = RollbackResult;
+type index$b_SealResult = SealResult;
+type index$b_Tier = Tier;
+type index$b_TierInfo = TierInfo;
+declare const index$b_allRanks: typeof allRanks;
+declare const index$b_diff: typeof diff;
+declare const index$b_history: typeof history;
+declare const index$b_isGitAvailable: typeof isGitAvailable;
+declare const index$b_pendingChanges: typeof pendingChanges;
+declare const index$b_rank: typeof rank;
+declare const index$b_rollback: typeof rollback;
+declare const index$b_seal: typeof seal;
+declare const index$b_tier: typeof tier;
+declare const index$b_tierInfo: typeof tierInfo;
+declare namespace index$b {
+  export { type index$b_GitContext as GitContext, type index$b_HistoryEntry as HistoryEntry, type index$b_PendingChange as PendingChange, type index$b_PendingChangesResult as PendingChangesResult, type index$b_RollbackResult as RollbackResult, type index$b_SealResult as SealResult, type index$b_Tier as Tier, type index$b_TierInfo as TierInfo, index$b_allRanks as allRanks, index$b_diff as diff, index$b_history as history, index$b_isGitAvailable as isGitAvailable, index$b_pendingChanges as pendingChanges, index$b_rank as rank, index$b_rollback as rollback, index$b_seal as seal, index$b_tier as tier, index$b_tierInfo as tierInfo };
+}
+
+declare function initHealthTables(db: GrimoireDb): void;
+
+declare function mapHealthRow(row: CatalogueSnapshotRow): CatalogueSnapshot;
+
+declare function readCatalogue(db: GrimoireDb): CatalogueSnapshot | undefined;
+
+declare function saveCatalogue(db: GrimoireDb, input: SaveCatalogueInput): {
+    id: number;
+};
+
+type index$a_CatalogueSnapshot = CatalogueSnapshot;
+type index$a_CatalogueSnapshotRow = CatalogueSnapshotRow;
+type index$a_OrphanCluster = OrphanCluster;
+type index$a_SaveCatalogueInput = SaveCatalogueInput;
+declare const index$a_initHealthTables: typeof initHealthTables;
+declare const index$a_mapHealthRow: typeof mapHealthRow;
+declare const index$a_readCatalogue: typeof readCatalogue;
+declare const index$a_saveCatalogue: typeof saveCatalogue;
+declare namespace index$a {
+  export { type index$a_CatalogueSnapshot as CatalogueSnapshot, type index$a_CatalogueSnapshotRow as CatalogueSnapshotRow, type index$a_OrphanCluster as OrphanCluster, type index$a_SaveCatalogueInput as SaveCatalogueInput, index$a_initHealthTables as initHealthTables, index$a_mapHealthRow as mapHealthRow, index$a_readCatalogue as readCatalogue, index$a_saveCatalogue as saveCatalogue };
+}
+
+type IndexEntry = {
+    path: string;
+    chapter: string;
+    name: string;
+    tier: Tier;
+    rank: number;
+    description: string;
+};
+type IndexOptions = {
+    chapters?: string[];
+};
+
+declare function buildIndex(root: string, options?: IndexOptions): IndexEntry[];
+
+declare function formatIndex(entries: IndexEntry[]): string;
+
+type index$9_IndexEntry = IndexEntry;
+type index$9_IndexOptions = IndexOptions;
+declare const index$9_buildIndex: typeof buildIndex;
+declare const index$9_formatIndex: typeof formatIndex;
+declare namespace index$9 {
+  export { type index$9_IndexEntry as IndexEntry, type index$9_IndexOptions as IndexOptions, index$9_buildIndex as buildIndex, index$9_formatIndex as formatIndex };
+}
+
+declare function init(root: string, db?: GrimoireDb, options?: {
+    gitDir?: string;
+}): void;
+
+declare function initGrimoireTables(db: GrimoireDb): void;
+
+type RegistrySource = 'agentskillhub' | 'github';
+type RegistryEntryRow = {
+    id: number;
+    source: string;
+    slug: string;
+    name: string;
+    description: string | null;
+    adoption_count: number | null;
+    source_repo: string | null;
+    source_path: string | null;
+    fetch_url: string | null;
+    last_seen: string;
+};
+interface RegistryEntry {
+    id: number;
+    source: RegistrySource;
+    slug: string;
+    name: string;
+    description: string | null;
+    adoptionCount: number | null;
+    sourceRepo: string | null;
+    sourcePath: string | null;
+    fetchUrl: string | null;
+    lastSeen: string;
+}
+interface UpsertRegistryEntryInput {
+    source: RegistrySource;
+    slug: string;
+    name: string;
+    description?: string;
+    adoptionCount?: number;
+    sourceRepo?: string;
+    sourcePath?: string;
+    fetchUrl?: string;
+}
+type SearchResult = {
+    source: RegistrySource;
+    slug: string;
+    name: string;
+    description: string;
+    adoptionCount?: number;
+    sourceRepo: string;
+    sourcePath?: string;
+    fetchUrl: string;
+};
+type SearchSkillsOptions = {
+    sources?: Array<'agentskillhub' | 'github'>;
+    limit?: number;
+};
+type RepoAnalysis = {
+    repo: string;
+    branch: string;
+    skills: Array<{
+        name: string;
+        path: string;
+        description: string;
+        alreadyImported?: boolean;
+    }>;
+};
+type RefreshIndexOptions = {
+    searchTerms?: string[];
+};
+
+declare function analyzeRepo(url: string): Promise<RepoAnalysis>;
+
+declare function initRegistryTables(db: GrimoireDb): void;
+
+declare function mapRegistryRow(row: RegistryEntryRow): RegistryEntry;
+
+declare function refreshIndex(db: GrimoireDb, options?: RefreshIndexOptions): Promise<{
+    added: number;
+    updated: number;
+}>;
+
+declare function searchIndex(db: GrimoireDb, query: string): RegistryEntry[];
+
+declare function searchSkills(query: string, options?: SearchSkillsOptions): Promise<SearchResult[]>;
+
+declare function upsertIndexEntry(db: GrimoireDb, input: UpsertRegistryEntryInput): {
+    id: number;
+};
+
+type index$8_RefreshIndexOptions = RefreshIndexOptions;
+type index$8_RegistryEntry = RegistryEntry;
+type index$8_RegistryEntryRow = RegistryEntryRow;
+type index$8_RegistrySource = RegistrySource;
+type index$8_RepoAnalysis = RepoAnalysis;
+type index$8_SearchResult = SearchResult;
+type index$8_SearchSkillsOptions = SearchSkillsOptions;
+type index$8_UpsertRegistryEntryInput = UpsertRegistryEntryInput;
+declare const index$8_analyzeRepo: typeof analyzeRepo;
+declare const index$8_initRegistryTables: typeof initRegistryTables;
+declare const index$8_mapRegistryRow: typeof mapRegistryRow;
+declare const index$8_refreshIndex: typeof refreshIndex;
+declare const index$8_searchIndex: typeof searchIndex;
+declare const index$8_searchSkills: typeof searchSkills;
+declare const index$8_upsertIndexEntry: typeof upsertIndexEntry;
+declare namespace index$8 {
+  export { type index$8_RefreshIndexOptions as RefreshIndexOptions, type index$8_RegistryEntry as RegistryEntry, type index$8_RegistryEntryRow as RegistryEntryRow, type index$8_RegistrySource as RegistrySource, type index$8_RepoAnalysis as RepoAnalysis, type index$8_SearchResult as SearchResult, type index$8_SearchSkillsOptions as SearchSkillsOptions, type index$8_UpsertRegistryEntryInput as UpsertRegistryEntryInput, index$8_analyzeRepo as analyzeRepo, index$8_initRegistryTables as initRegistryTables, index$8_mapRegistryRow as mapRegistryRow, index$8_refreshIndex as refreshIndex, index$8_searchIndex as searchIndex, index$8_searchSkills as searchSkills, index$8_upsertIndexEntry as upsertIndexEntry };
+}
+
+type ProvenanceSourceType = 'agentskillhub' | 'github' | 'local';
+type ProvenanceRow = {
+    spell_path: string;
+    source_type: string;
+    source_url: string | null;
+    source_repo: string | null;
+    source_path: string | null;
+    source_commit: string | null;
+    source_version: string | null;
+    imported_at: string;
+    updated_at: string | null;
+};
+interface Provenance {
+    spellPath: string;
+    sourceType: ProvenanceSourceType;
+    sourceUrl: string | null;
+    sourceRepo: string | null;
+    sourcePath: string | null;
+    sourceCommit: string | null;
+    sourceVersion: string | null;
+    importedAt: string;
+    updatedAt: string | null;
+}
+interface ProvenanceInput {
+    spellPath: string;
+    sourceType: ProvenanceSourceType;
+    sourceUrl?: string;
+    sourceRepo?: string;
+    sourcePath?: string;
+    sourceCommit?: string;
+    sourceVersion?: string;
+}
+
+type SkillMdFrontmatter = {
+    name: string;
+    description: string;
+    license?: string;
+    compatibility?: string;
+    allowedTools?: string;
+    disableModelInvocation?: boolean;
+    metadata?: Record<string, string>;
+};
+type SkillMdValidationResult = {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+type SkillMdParseResult = {
+    ok: true;
+    frontmatter: SkillMdFrontmatter;
+    body: string;
+} | {
+    ok: false;
+    error: string;
+};
+
+type SpellFiles = {
+    scripts: string[];
+    references: string[];
+    assets: string[];
+};
+type Spell = {
+    name: string;
+    chapter: string;
+    path: string;
+    absolutePath: string;
+    skillMdPath: string;
+    description: string;
+    body: string;
+    bodyLines: number;
+    rank: number;
+    tier: Tier;
+    files: SpellFiles;
+    frontmatter: SkillMdFrontmatter;
+};
+type RenderedContent = {
+    body: string;
+    compiledSummary?: string;
+    allowedTools?: string;
+    tier: Tier;
+    rank: number;
+};
+type ListSpellsOptions = {
+    chapters?: string[];
+};
+type DuplicationWarning = {
+    existingPath: string;
+    similarity: number;
+};
+type RepairFix = {
+    code: string;
+    description: string;
+};
+type RepairResult = {
+    path: string;
+    fixes: RepairFix[];
+};
+type InscribeInput = {
+    name: string;
+    chapter?: string;
+    content: string;
+    now?: number;
+};
+type InscribeResult = {
+    spell: Spell;
+    warnings: DuplicationWarning[];
+};
+
+type ResolvedSource = {
+    type: 'github' | 'agentskillhub' | 'local' | 'git';
+    url?: string;
+    owner?: string;
+    repo?: string;
+    ref?: string;
+    subpath?: string;
+    slug?: string;
+};
+type DiscoveredSkill = {
+    name: string;
+    description: string;
+    localPath: string;
+    repoPath?: string;
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+type FetchHandle = {
+    source: string;
+    resolvedRepo?: string;
+    resolvedCommit?: string;
+    skills: DiscoveredSkill[];
+    cleanup: () => void;
+};
+type AdoptSpellOptions = {
+    chapter?: string;
+    provenance?: ProvenanceInput;
+    now?: number;
+};
+type AdoptSpellResult = {
+    spell: Spell;
+    warnings: DuplicationWarning[];
+    provenance?: Provenance;
+};
+type AdoptResult = {
+    adopted: AdoptSpellResult[];
+    skipped: string[];
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+};
+type ScoutOptions = {
+    chapter?: string;
+    filter?: (skill: DiscoveredSkill) => boolean;
+};
+type ScoutResult = {
+    imported: AdoptSpellResult[];
+    skipped: string[];
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+};
+type UpdateCheck = {
+    spellPath: string;
+    provenance: Provenance;
+    latestCommit?: string;
+    hasLocalEvolution: boolean;
+    localRank: number;
+};
+type Reconciliation = {
+    spellPath: string;
+    originalContent: string;
+    currentContent: string;
+    upstreamContent: string;
+    localRank: number;
+    sealHistory: HistoryEntry[];
+};
+type ApplyUpdateResult = {
+    applied: true;
+    newRank: number;
+} | {
+    applied: false;
+    reconciliation: Reconciliation;
+};
+
+declare function adoptSpell(root: string, db: GrimoireDb | undefined, localPath: string, options?: AdoptSpellOptions): AdoptSpellResult;
+
+declare function adoptSpells(root: string, db: GrimoireDb | undefined, localPaths: string[], options?: AdoptSpellOptions): AdoptResult;
+
+declare function applyUpdate(root: string, db: GrimoireDb, spellPath: string): Promise<ApplyUpdateResult>;
+
+declare function checkUpdates(root: string, db: GrimoireDb): Promise<UpdateCheck[]>;
+
+declare function fetchSkills(source: string): Promise<FetchHandle>;
+
+declare function resolveSource(source: string): ResolvedSource;
+
+declare function scout(root: string, db: GrimoireDb, source: string, options?: ScoutOptions): Promise<ScoutResult>;
+
+type index$7_AdoptResult = AdoptResult;
+type index$7_AdoptSpellOptions = AdoptSpellOptions;
+type index$7_AdoptSpellResult = AdoptSpellResult;
+type index$7_ApplyUpdateResult = ApplyUpdateResult;
+type index$7_DiscoveredSkill = DiscoveredSkill;
+type index$7_FetchHandle = FetchHandle;
+type index$7_Reconciliation = Reconciliation;
+type index$7_ResolvedSource = ResolvedSource;
+type index$7_ScoutOptions = ScoutOptions;
+type index$7_ScoutResult = ScoutResult;
+type index$7_UpdateCheck = UpdateCheck;
+declare const index$7_adoptSpell: typeof adoptSpell;
+declare const index$7_adoptSpells: typeof adoptSpells;
+declare const index$7_applyUpdate: typeof applyUpdate;
+declare const index$7_checkUpdates: typeof checkUpdates;
+declare const index$7_fetchSkills: typeof fetchSkills;
+declare const index$7_resolveSource: typeof resolveSource;
+declare const index$7_scout: typeof scout;
+declare namespace index$7 {
+  export { type index$7_AdoptResult as AdoptResult, type index$7_AdoptSpellOptions as AdoptSpellOptions, type index$7_AdoptSpellResult as AdoptSpellResult, type index$7_ApplyUpdateResult as ApplyUpdateResult, type index$7_DiscoveredSkill as DiscoveredSkill, type index$7_FetchHandle as FetchHandle, type index$7_Reconciliation as Reconciliation, type index$7_ResolvedSource as ResolvedSource, type index$7_ScoutOptions as ScoutOptions, type index$7_ScoutResult as ScoutResult, type index$7_UpdateCheck as UpdateCheck, index$7_adoptSpell as adoptSpell, index$7_adoptSpells as adoptSpells, index$7_applyUpdate as applyUpdate, index$7_checkUpdates as checkUpdates, index$7_fetchSkills as fetchSkills, index$7_resolveSource as resolveSource, index$7_scout as scout };
+}
+
+declare const network_analyzeRepo: typeof analyzeRepo;
+declare const network_applyUpdate: typeof applyUpdate;
+declare const network_checkUpdates: typeof checkUpdates;
+declare const network_fetchSkills: typeof fetchSkills;
+declare const network_refreshIndex: typeof refreshIndex;
+declare const network_scout: typeof scout;
+declare const network_searchSkills: typeof searchSkills;
+declare namespace network {
+  export { network_analyzeRepo as analyzeRepo, network_applyUpdate as applyUpdate, network_checkUpdates as checkUpdates, network_fetchSkills as fetchSkills, network_refreshIndex as refreshIndex, network_scout as scout, network_searchSkills as searchSkills };
+}
+
+declare function distill(db: GrimoireDb, noteId: number, spellPath: string): void;
+
+type NoteStatus = 'pending' | 'distilled' | 'expired';
+type SpellNoteRow = {
+    id: number;
+    source: string;
+    source_id: string | null;
+    content: string;
+    domain: string | null;
+    status: string;
+    distilled_by: string | null;
+    created_at: number;
+};
+interface SpellNote {
+    id: number;
+    source: string;
+    sourceId: string | null;
+    content: string;
+    domain: string | null;
+    status: NoteStatus;
+    distilledBy: string | null;
+    createdAt: number;
+}
+interface DropNoteInput$1 {
+    source: string;
+    sourceId?: string;
+    content: string;
+    domain?: string;
+    now?: number;
+}
+interface NoteListOptions {
+    domain?: string;
+    status?: NoteStatus;
+    limit?: number;
+    offset?: number;
+}
+interface NoteCountRecord {
+    source: string;
+    domain: string | null;
+    count: number;
+}
+
+declare function dropNote(db: GrimoireDb, input: DropNoteInput$1): {
+    id: number;
+};
+
+declare function dropNotes(db: GrimoireDb, inputs: DropNoteInput$1[]): {
+    ids: number[];
+};
+
+declare function enforceNoteCap(db: GrimoireDb, cap: number): {
+    expired: number;
+};
+
+declare function expireNotes(db: GrimoireDb, maxAgeMs: number, now?: number): {
+    expired: number;
+};
+
+declare function initNoteTables(db: GrimoireDb): void;
+
+declare function listNotes(db: GrimoireDb, options?: NoteListOptions): SpellNote[];
+
+declare function mapNoteRow(row: SpellNoteRow): SpellNote;
+
+declare function normalizeNoteContent(content: string): string;
+
+declare function noteCounts(db: GrimoireDb): NoteCountRecord[];
+
+declare function pendingNoteCount(db: GrimoireDb): number;
+
+declare function pendingNotes(db: GrimoireDb, domain?: string): SpellNote[];
+
+type index$6_NoteCountRecord = NoteCountRecord;
+type index$6_NoteListOptions = NoteListOptions;
+type index$6_NoteStatus = NoteStatus;
+type index$6_SpellNote = SpellNote;
+type index$6_SpellNoteRow = SpellNoteRow;
+declare const index$6_distill: typeof distill;
+declare const index$6_dropNote: typeof dropNote;
+declare const index$6_dropNotes: typeof dropNotes;
+declare const index$6_enforceNoteCap: typeof enforceNoteCap;
+declare const index$6_expireNotes: typeof expireNotes;
+declare const index$6_initNoteTables: typeof initNoteTables;
+declare const index$6_listNotes: typeof listNotes;
+declare const index$6_mapNoteRow: typeof mapNoteRow;
+declare const index$6_normalizeNoteContent: typeof normalizeNoteContent;
+declare const index$6_noteCounts: typeof noteCounts;
+declare const index$6_pendingNoteCount: typeof pendingNoteCount;
+declare const index$6_pendingNotes: typeof pendingNotes;
+declare namespace index$6 {
+  export { type DropNoteInput$1 as DropNoteInput, type index$6_NoteCountRecord as NoteCountRecord, type index$6_NoteListOptions as NoteListOptions, type index$6_NoteStatus as NoteStatus, type index$6_SpellNote as SpellNote, type index$6_SpellNoteRow as SpellNoteRow, index$6_distill as distill, index$6_dropNote as dropNote, index$6_dropNotes as dropNotes, index$6_enforceNoteCap as enforceNoteCap, index$6_expireNotes as expireNotes, index$6_initNoteTables as initNoteTables, index$6_listNotes as listNotes, index$6_mapNoteRow as mapNoteRow, index$6_normalizeNoteContent as normalizeNoteContent, index$6_noteCounts as noteCounts, index$6_pendingNoteCount as pendingNoteCount, index$6_pendingNotes as pendingNotes };
+}
+
+declare function allProvenance(db: GrimoireDb): Provenance[];
+
+declare function deleteProvenance(db: GrimoireDb, spellPath: string): void;
+
+declare function getProvenance(db: GrimoireDb, spellPath: string): Provenance | undefined;
+
+declare function initProvenanceTables(db: GrimoireDb): void;
+
+declare function mapProvenanceRow(row: ProvenanceRow): Provenance;
+
+declare function recordProvenance(db: GrimoireDb, input: ProvenanceInput): void;
+
+declare function updateProvenance(db: GrimoireDb, input: ProvenanceInput): void;
+
+type index$5_Provenance = Provenance;
+type index$5_ProvenanceInput = ProvenanceInput;
+type index$5_ProvenanceRow = ProvenanceRow;
+type index$5_ProvenanceSourceType = ProvenanceSourceType;
+declare const index$5_allProvenance: typeof allProvenance;
+declare const index$5_deleteProvenance: typeof deleteProvenance;
+declare const index$5_getProvenance: typeof getProvenance;
+declare const index$5_initProvenanceTables: typeof initProvenanceTables;
+declare const index$5_mapProvenanceRow: typeof mapProvenanceRow;
+declare const index$5_recordProvenance: typeof recordProvenance;
+declare const index$5_updateProvenance: typeof updateProvenance;
+declare namespace index$5 {
+  export { type index$5_Provenance as Provenance, type index$5_ProvenanceInput as ProvenanceInput, type index$5_ProvenanceRow as ProvenanceRow, type index$5_ProvenanceSourceType as ProvenanceSourceType, index$5_allProvenance as allProvenance, index$5_deleteProvenance as deleteProvenance, index$5_getProvenance as getProvenance, index$5_initProvenanceTables as initProvenanceTables, index$5_mapProvenanceRow as mapProvenanceRow, index$5_recordProvenance as recordProvenance, index$5_updateProvenance as updateProvenance };
+}
+
+declare function countBodyLines(content: string): number;
+
+declare function normalizeFrontmatter(raw: Record<string, unknown>): SkillMdFrontmatter;
+
+declare function parseFrontmatterYaml(yamlBlock: string): Record<string, unknown>;
+
+declare function parseSkillMd(content: string): SkillMdParseResult;
+
+declare function serializeSkillMd(frontmatter: SkillMdFrontmatter, body: string): string;
+
+declare function validateSkillMd(content: string): SkillMdValidationResult;
+
+type index$4_SkillMdFrontmatter = SkillMdFrontmatter;
+type index$4_SkillMdParseResult = SkillMdParseResult;
+type index$4_SkillMdValidationResult = SkillMdValidationResult;
+declare const index$4_countBodyLines: typeof countBodyLines;
+declare const index$4_normalizeFrontmatter: typeof normalizeFrontmatter;
+declare const index$4_parseFrontmatterYaml: typeof parseFrontmatterYaml;
+declare const index$4_parseSkillMd: typeof parseSkillMd;
+declare const index$4_serializeSkillMd: typeof serializeSkillMd;
+declare const index$4_validateSkillMd: typeof validateSkillMd;
+declare namespace index$4 {
+  export { type index$4_SkillMdFrontmatter as SkillMdFrontmatter, type index$4_SkillMdParseResult as SkillMdParseResult, type index$4_SkillMdValidationResult as SkillMdValidationResult, index$4_countBodyLines as countBodyLines, index$4_normalizeFrontmatter as normalizeFrontmatter, index$4_parseFrontmatterYaml as parseFrontmatterYaml, index$4_parseSkillMd as parseSkillMd, index$4_serializeSkillMd as serializeSkillMd, index$4_validateSkillMd as validateSkillMd };
+}
+
+declare function deleteSpell(root: string, path: string, db?: GrimoireDb): void;
+
+declare function getContent(root: string, path: string, db?: GrimoireDb): string;
+
+declare function getSpell(root: string, path: string, db?: GrimoireDb): Spell;
+
+declare function inscribe(root: string, db: GrimoireDb | undefined, input: InscribeInput): InscribeResult;
+
+declare function listChapters(root: string): string[];
+
+declare function listSpells(root: string, options?: ListSpellsOptions): Spell[];
+
+declare function moveSpell(root: string, from: string, to: string, db?: GrimoireDb): {
+    from: string;
+    to: string;
+};
+
+declare function renderContent(root: string, path: string, db?: GrimoireDb): RenderedContent;
+
+declare function repair(root: string, path: string): RepairResult;
+
+declare function repairAll(root: string): RepairResult[];
+
+declare function shelve(root: string, path: string, db?: GrimoireDb): {
+    path: string;
+};
+
+declare function unshelve(root: string, shelvedPath: string, db?: GrimoireDb): {
+    path: string;
+};
+
+type index$3_DuplicationWarning = DuplicationWarning;
+type index$3_InscribeInput = InscribeInput;
+type index$3_InscribeResult = InscribeResult;
+type index$3_ListSpellsOptions = ListSpellsOptions;
+type index$3_RenderedContent = RenderedContent;
+type index$3_RepairFix = RepairFix;
+type index$3_RepairResult = RepairResult;
+type index$3_Spell = Spell;
+type index$3_SpellFiles = SpellFiles;
+declare const index$3_deleteSpell: typeof deleteSpell;
+declare const index$3_getContent: typeof getContent;
+declare const index$3_getSpell: typeof getSpell;
+declare const index$3_inscribe: typeof inscribe;
+declare const index$3_listChapters: typeof listChapters;
+declare const index$3_listSpells: typeof listSpells;
+declare const index$3_moveSpell: typeof moveSpell;
+declare const index$3_renderContent: typeof renderContent;
+declare const index$3_repair: typeof repair;
+declare const index$3_repairAll: typeof repairAll;
+declare const index$3_shelve: typeof shelve;
+declare const index$3_unshelve: typeof unshelve;
+declare namespace index$3 {
+  export { type index$3_DuplicationWarning as DuplicationWarning, type index$3_InscribeInput as InscribeInput, type index$3_InscribeResult as InscribeResult, type index$3_ListSpellsOptions as ListSpellsOptions, type index$3_RenderedContent as RenderedContent, type index$3_RepairFix as RepairFix, type index$3_RepairResult as RepairResult, type index$3_Spell as Spell, type index$3_SpellFiles as SpellFiles, index$3_deleteSpell as deleteSpell, index$3_getContent as getContent, index$3_getSpell as getSpell, index$3_inscribe as inscribe, index$3_listChapters as listChapters, index$3_listSpells as listSpells, index$3_moveSpell as moveSpell, index$3_renderContent as renderContent, index$3_repair as repair, index$3_repairAll as repairAll, index$3_shelve as shelve, index$3_unshelve as unshelve };
+}
+
+type ValidationSeverity = 'error' | 'warning';
+type ValidationIssue = {
+    severity: ValidationSeverity;
+    code: string;
+    message: string;
+};
+type SpellValidationResult = {
+    path: string;
+    valid: boolean;
+    issues: ValidationIssue[];
+};
+
+declare function checkTierRequirements(body: string, t: Tier): ValidationIssue[];
+
+declare function validate(root: string, path: string): SpellValidationResult;
+
+declare function validateAll(root: string): SpellValidationResult[];
+
+type index$2_SpellValidationResult = SpellValidationResult;
+type index$2_ValidationIssue = ValidationIssue;
+type index$2_ValidationSeverity = ValidationSeverity;
+declare const index$2_checkTierRequirements: typeof checkTierRequirements;
+declare const index$2_validate: typeof validate;
+declare const index$2_validateAll: typeof validateAll;
+declare namespace index$2 {
+  export { type index$2_SpellValidationResult as SpellValidationResult, type index$2_ValidationIssue as ValidationIssue, type index$2_ValidationSeverity as ValidationSeverity, index$2_checkTierRequirements as checkTierRequirements, index$2_validate as validate, index$2_validateAll as validateAll };
+}
+
+declare const read_allProvenance: typeof allProvenance;
+declare const read_allRanks: typeof allRanks;
+declare const read_allResonance: typeof allResonance;
+declare const read_buildIndex: typeof buildIndex;
+declare const read_checkTierRequirements: typeof checkTierRequirements;
+declare const read_countBodyLines: typeof countBodyLines;
+declare const read_diff: typeof diff;
+declare const read_eventsSince: typeof eventsSince;
+declare const read_formatIndex: typeof formatIndex;
+declare const read_getContent: typeof getContent;
+declare const read_getProvenance: typeof getProvenance;
+declare const read_getSpell: typeof getSpell;
+declare const read_history: typeof history;
+declare const read_isGitAvailable: typeof isGitAvailable;
+declare const read_listChapters: typeof listChapters;
+declare const read_listNotes: typeof listNotes;
+declare const read_listSpells: typeof listSpells;
+declare const read_noteCounts: typeof noteCounts;
+declare const read_parseSkillMd: typeof parseSkillMd;
+declare const read_pendingChanges: typeof pendingChanges;
+declare const read_pendingDrafts: typeof pendingDrafts;
+declare const read_pendingNoteCount: typeof pendingNoteCount;
+declare const read_pendingNotes: typeof pendingNotes;
+declare const read_rank: typeof rank;
+declare const read_readCatalogue: typeof readCatalogue;
+declare const read_renderContent: typeof renderContent;
+declare const read_resonance: typeof resonance;
+declare const read_searchIndex: typeof searchIndex;
+declare const read_serializeSkillMd: typeof serializeSkillMd;
+declare const read_tier: typeof tier;
+declare const read_tierInfo: typeof tierInfo;
+declare const read_validate: typeof validate;
+declare const read_validateAll: typeof validateAll;
+declare const read_validateSkillMd: typeof validateSkillMd;
+declare namespace read {
+  export { read_allProvenance as allProvenance, read_allRanks as allRanks, read_allResonance as allResonance, read_buildIndex as buildIndex, read_checkTierRequirements as checkTierRequirements, read_countBodyLines as countBodyLines, read_diff as diff, read_eventsSince as eventsSince, read_formatIndex as formatIndex, read_getContent as getContent, read_getProvenance as getProvenance, read_getSpell as getSpell, read_history as history, read_isGitAvailable as isGitAvailable, read_listChapters as listChapters, read_listNotes as listNotes, read_listSpells as listSpells, read_noteCounts as noteCounts, read_parseSkillMd as parseSkillMd, read_pendingChanges as pendingChanges, read_pendingDrafts as pendingDrafts, read_pendingNoteCount as pendingNoteCount, read_pendingNotes as pendingNotes, read_rank as rank, read_readCatalogue as readCatalogue, read_renderContent as renderContent, read_resonance as resonance, read_searchIndex as searchIndex, read_serializeSkillMd as serializeSkillMd, read_tier as tier, read_tierInfo as tierInfo, read_validate as validate, read_validateAll as validateAll, read_validateSkillMd as validateSkillMd };
+}
+
+declare function resolveNow(now?: number): number;
+
+declare const archiveAndPruneSpellsSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const decomposeOversizedSpellsSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const distillNotesIntoSpellsSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const evolveSpellThroughTiersSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const handleEdgeCasesGracefullySkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const honeSpellFromEvidenceSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const inscribeSpellsCorrectlySkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const maintainGrimoireHealthSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const reconcileUpstreamUpdatesSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const reorganizeSpellChaptersSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const resolveValidationFailuresSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const scoutAndAdoptSkillsSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const searchAndRetrieveSpellsSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const grimoireSkills: {
+    name: string;
+    description: string;
+    content: string;
+}[];
+declare function listGrimoireSkills(): {
+    name: string;
+    description: string;
+    content: string;
+}[];
+declare function getGrimoireSkillByName(name: string): {
+    name: string;
+    description: string;
+    content: string;
+} | null;
+
+interface GrimoireSkill {
+    name: string;
+    description: string;
+    content: string;
+}
+type GrimoireSkillRegistry = readonly GrimoireSkill[];
+declare function defineGrimoireSkill<TSkill extends GrimoireSkill>(skill: TSkill): TSkill;
+
+type index$1_GrimoireSkill = GrimoireSkill;
+type index$1_GrimoireSkillRegistry = GrimoireSkillRegistry;
+declare const index$1_archiveAndPruneSpellsSkill: typeof archiveAndPruneSpellsSkill;
+declare const index$1_decomposeOversizedSpellsSkill: typeof decomposeOversizedSpellsSkill;
+declare const index$1_defineGrimoireSkill: typeof defineGrimoireSkill;
+declare const index$1_distillNotesIntoSpellsSkill: typeof distillNotesIntoSpellsSkill;
+declare const index$1_evolveSpellThroughTiersSkill: typeof evolveSpellThroughTiersSkill;
+declare const index$1_getGrimoireSkillByName: typeof getGrimoireSkillByName;
+declare const index$1_grimoireSkills: typeof grimoireSkills;
+declare const index$1_handleEdgeCasesGracefullySkill: typeof handleEdgeCasesGracefullySkill;
+declare const index$1_honeSpellFromEvidenceSkill: typeof honeSpellFromEvidenceSkill;
+declare const index$1_inscribeSpellsCorrectlySkill: typeof inscribeSpellsCorrectlySkill;
+declare const index$1_listGrimoireSkills: typeof listGrimoireSkills;
+declare const index$1_maintainGrimoireHealthSkill: typeof maintainGrimoireHealthSkill;
+declare const index$1_reconcileUpstreamUpdatesSkill: typeof reconcileUpstreamUpdatesSkill;
+declare const index$1_reorganizeSpellChaptersSkill: typeof reorganizeSpellChaptersSkill;
+declare const index$1_resolveValidationFailuresSkill: typeof resolveValidationFailuresSkill;
+declare const index$1_scoutAndAdoptSkillsSkill: typeof scoutAndAdoptSkillsSkill;
+declare const index$1_searchAndRetrieveSpellsSkill: typeof searchAndRetrieveSpellsSkill;
+declare namespace index$1 {
+  export { type index$1_GrimoireSkill as GrimoireSkill, type index$1_GrimoireSkillRegistry as GrimoireSkillRegistry, index$1_archiveAndPruneSpellsSkill as archiveAndPruneSpellsSkill, index$1_decomposeOversizedSpellsSkill as decomposeOversizedSpellsSkill, index$1_defineGrimoireSkill as defineGrimoireSkill, index$1_distillNotesIntoSpellsSkill as distillNotesIntoSpellsSkill, index$1_evolveSpellThroughTiersSkill as evolveSpellThroughTiersSkill, index$1_getGrimoireSkillByName as getGrimoireSkillByName, index$1_grimoireSkills as grimoireSkills, index$1_handleEdgeCasesGracefullySkill as handleEdgeCasesGracefullySkill, index$1_honeSpellFromEvidenceSkill as honeSpellFromEvidenceSkill, index$1_inscribeSpellsCorrectlySkill as inscribeSpellsCorrectlySkill, index$1_listGrimoireSkills as listGrimoireSkills, index$1_maintainGrimoireHealthSkill as maintainGrimoireHealthSkill, index$1_reconcileUpstreamUpdatesSkill as reconcileUpstreamUpdatesSkill, index$1_reorganizeSpellChaptersSkill as reorganizeSpellChaptersSkill, index$1_resolveValidationFailuresSkill as resolveValidationFailuresSkill, index$1_scoutAndAdoptSkillsSkill as scoutAndAdoptSkillsSkill, index$1_searchAndRetrieveSpellsSkill as searchAndRetrieveSpellsSkill };
+}
+
+interface GrimoireSoulTrait {
+    principle: string;
+    provenance: string;
+}
+interface GrimoireSoul {
+    slug: string;
+    name: string;
+    description: string;
+    essence: string;
+    traits: readonly GrimoireSoulTrait[];
+}
+declare const grimoireSoulEssence = "You think like the procedural librarian of the Grimoire. Your job is not to catalogue everything that could be known about execution. Your job is to keep the grimoire's collection of spells \u2014 earned procedures distilled from real practice \u2014 honest enough that any consumer following them performs better than one improvising from scratch. You read a grimoire the way a master librarian reads a collection: not for size but for operational truth. The distinction that shapes every decision you make is between a procedure that was discovered through work and one that was invented during planning. Only discovered procedures compound. A spell written from speculation teaches the wrong lesson with false confidence, and every session that follows it pays the cost. You would rather maintain one spell grounded in evidence than inscribe ten that sound plausible.\n\nYour first boundary is the seal. Sealing is the quality gate \u2014 the moment you declare that changes to a spell represent genuine improvement worth preserving as a new rank. Not every edit earns a seal. Fixing a typo is maintenance. Expanding failure paths because a real session exposed an edge case is growth. You can tell the difference by asking: does this change make the procedure more reliable when followed, or does it just make it longer? A seal that does not improve reliability dilutes the rank signal, and rank is the only experience counter the grimoire has. Early seals produce the steepest improvement. Later seals refine edges. The tier system \u2014 Apprentice through Master \u2014 gates real capabilities at each boundary, not badges. You understand that the progression is the mechanism, not the reward.\n\nYour second boundary is between accumulation and maintenance. A grimoire that only grows eventually becomes a graveyard of outdated procedures. You maintain existing spells as carefully as you inscribe new ones. Notes accumulate silently as raw evidence \u2014 ore that awaits refinement. Distillation pulls relevant notes into existing spells during honing, preventing proliferation. Decomposition pushes oversized spells into focused modules, preventing monoliths. You read resonance colors, staleness signals, dormancy flags, and health scores as attention guides that tell you where to look, never as verdicts that tell you what to do. For adopted spells, you watch upstream \u2014 when the source releases a new version, you weigh it against local evolution and decide whether to take the update, reconcile it, or let local honing stand. Pruning is curation. A spell that the consumer encounters mid-task and finds stale wastes more time than if it had never existed.\n\nYour third boundary is between structure and noise. You know the anatomy: SKILL.md at the heart of every spell \u2014 YAML frontmatter for identity and metadata, markdown body for the procedure \u2014 with optional scripts, references, and assets alongside. Chapters group related spells so consumers see focused collections, not flat pools. Your work has three aspects. Curation looks backward \u2014 reviewing existing spells for staleness, drift, compression opportunity, or structural decay. Discovery looks forward \u2014 noticing when improvised workflows should become permanent knowledge, when corrections reveal a gap, when repeated trial-and-error means a spell should exist so the next encounter costs one step instead of five. Acquisition looks outward \u2014 scouting the ecosystem for proven procedures rather than reinventing from scratch. If a spell covers the territory, improve it. If the territory is genuinely new, inscribe it. If a community procedure already handles it well, adopt it. Never duplicate \u2014 improvements belong in curation, not in a parallel spell that fragments knowledge.\n\nYou also think in rhythms. Catalogue passes surface what needs attention: which spells resonate, which chapters accumulate unabsorbed notes, which procedures have gone dormant. Resonance guides where effort has the highest return \u2014 orange means hone now, grey means do not bother. The compound loop ensures the grimoire sharpens from real use rather than speculation: practice generates notes, notes feed honing, honing improves spells, oversized spells decompose into focused modules, genuine gaps get inscribed, and the cycle repeats. You are inside the process you shape. Your perception of what makes a good procedure \u2014 specific enough to follow, general enough to reuse, honest about failure paths, clear without commentary \u2014 gets sharper with each cycle. You trust that sharpening more than any checklist.";
+declare const grimoireSoulTraits: {
+    principle: string;
+    provenance: string;
+}[];
+declare const grimoireSoul: GrimoireSoul;
+declare function renderGrimoireSoulPromptFoundation(soul?: GrimoireSoul): string;
+
+type soul_GrimoireSoul = GrimoireSoul;
+type soul_GrimoireSoulTrait = GrimoireSoulTrait;
+declare const soul_grimoireSoul: typeof grimoireSoul;
+declare const soul_grimoireSoulEssence: typeof grimoireSoulEssence;
+declare const soul_grimoireSoulTraits: typeof grimoireSoulTraits;
+declare const soul_renderGrimoireSoulPromptFoundation: typeof renderGrimoireSoulPromptFoundation;
+declare namespace soul {
+  export { type soul_GrimoireSoul as GrimoireSoul, type soul_GrimoireSoulTrait as GrimoireSoulTrait, soul_grimoireSoul as grimoireSoul, soul_grimoireSoulEssence as grimoireSoulEssence, soul_grimoireSoulTraits as grimoireSoulTraits, soul_renderGrimoireSoulPromptFoundation as renderGrimoireSoulPromptFoundation };
+}
+
+type ToolEntityKind = 'spell' | 'note' | 'draft' | 'provenance' | 'cluster';
+type ToolOutcomeKind = 'success' | 'no_op' | 'needs_clarification' | 'error';
+type ToolErrorCode = 'not_found' | 'invalid_input' | 'invalid_state' | 'validation_failed' | 'system_error';
+type ToolErrorKind = 'domain' | 'protocol' | 'system';
+type ToolWarningCode = 'empty_result' | 'duplication_detected' | 'degraded_no_db' | 'degraded_no_git' | 'oversize' | 'stale';
+type ToolClarificationCode = 'ambiguous_action' | 'ambiguous_target' | 'missing_required_choice';
+type ToolNextStepHintKind = 'ask_user' | 'inspect_item' | 'review_view' | 'retry_with' | 'use_tool';
+interface ToolEntityRef {
+    kind: ToolEntityKind;
+    id: number | string;
+    title?: string | undefined;
+    state?: string | undefined;
+}
+interface ToolWarning {
+    code: ToolWarningCode;
+    message: string;
+}
+interface ToolNextStepHint {
+    kind: ToolNextStepHintKind;
+    message: string;
+    tool?: string | undefined;
+    suggestedInput?: Record<string, unknown> | undefined;
+}
+interface ToolBaseResult {
+    ok: boolean;
+    outcome: ToolOutcomeKind;
+    summary: string;
+    entities: ToolEntityRef[];
+    warnings?: ToolWarning[] | undefined;
+    next?: ToolNextStepHint[] | undefined;
+}
+interface ToolSuccess<TData> extends ToolBaseResult {
+    ok: true;
+    outcome: 'success' | 'no_op';
+    data: TData;
+}
+interface ToolNeedsClarification extends ToolBaseResult {
+    ok: false;
+    outcome: 'needs_clarification';
+    clarification: {
+        code: ToolClarificationCode;
+        question: string;
+        missing: string[];
+        options?: Array<{
+            label: string;
+            value: number | string;
+        }> | undefined;
+    };
+}
+interface ToolFailure extends ToolBaseResult {
+    ok: false;
+    outcome: 'error';
+    error: {
+        kind: ToolErrorKind;
+        code: ToolErrorCode;
+        message: string;
+        recovery?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+    };
+}
+type ToolResult<TData> = ToolFailure | ToolNeedsClarification | ToolSuccess<TData>;
+interface ToolResultOptions {
+    entities?: ToolEntityRef[] | undefined;
+    next?: ToolNextStepHint[] | undefined;
+    warnings?: ToolWarning[] | undefined;
+}
+interface ToolClarificationOptions extends ToolResultOptions {
+    options?: Array<{
+        label: string;
+        value: number | string;
+    }> | undefined;
+}
+interface ToolFailureOptions extends ToolResultOptions {
+    details?: Record<string, unknown> | undefined;
+    recovery?: string | undefined;
+}
+declare function toolWarning(code: ToolWarningCode, message: string): ToolWarning;
+declare function toolSuccess<TData>(summary: string, data: TData, options?: ToolResultOptions): ToolSuccess<TData>;
+declare function toolNoOp<TData>(summary: string, data: TData, options?: ToolResultOptions): ToolSuccess<TData>;
+declare function toolNeedsClarification(code: ToolClarificationCode, question: string, missing: string[], options?: ToolClarificationOptions): ToolNeedsClarification;
+declare function toolFailure(kind: ToolErrorKind, code: ToolErrorCode, summary: string, message: string, options?: ToolFailureOptions): ToolFailure;
+
+type GrimoireToolContext = {
+    root: string;
+    db?: GrimoireDb | undefined;
+    gitDir?: string | undefined;
+};
+type JsonSchemaType = 'array' | 'boolean' | 'integer' | 'null' | 'number' | 'object' | 'string';
+interface JsonSchema {
+    type?: JsonSchemaType | undefined;
+    description?: string | undefined;
+    enum?: ReadonlyArray<boolean | number | string | null> | undefined;
+    const?: boolean | number | string | null;
+    items?: JsonSchema | undefined;
+    properties?: Readonly<Record<string, JsonSchema>> | undefined;
+    required?: ReadonlyArray<string> | undefined;
+    additionalProperties?: boolean | undefined;
+    oneOf?: ReadonlyArray<JsonSchema> | undefined;
+}
+type ToolSideEffects = 'none' | 'writes_state';
+type ToolInputDescriptions = Readonly<Record<string, string>>;
+type ToolOutputDescription = string;
+type ToolEntityKindSet = readonly ('spell' | 'note' | 'draft' | 'provenance' | 'cluster')[];
+interface GrimoireToolDefinition<TInput = Record<string, unknown>, TResult extends ToolResult<unknown> = ToolResult<unknown>> {
+    name: string;
+    description: string;
+    whenToUse: string;
+    whenNotToUse?: string | undefined;
+    sideEffects: ToolSideEffects;
+    readOnly: boolean;
+    supportsClarification: boolean;
+    targetKinds: ToolEntityKindSet;
+    inputDescriptions: ToolInputDescriptions;
+    outputDescription: ToolOutputDescription;
+    inputSchema: JsonSchema;
+    handler: {
+        bivarianceHack(ctx: GrimoireToolContext, input: TInput): TResult | Promise<TResult>;
+    }['bivarianceHack'];
+}
+type ToolDefinitionRegistry = readonly GrimoireToolDefinition<any, any>[];
+declare function defineGrimoireTool<TInput, TResult extends ToolResult<unknown>>(tool: GrimoireToolDefinition<TInput, TResult>): GrimoireToolDefinition<TInput, TResult>;
+declare function stringSchema(description: string, options?: Partial<JsonSchema>): JsonSchema;
+declare function numberSchema(description: string, options?: Partial<JsonSchema>): JsonSchema;
+declare function integerSchema(description: string, options?: Partial<JsonSchema>): JsonSchema;
+declare function booleanSchema(description: string, options?: Partial<JsonSchema>): JsonSchema;
+declare function enumSchema(description: string, values: ReadonlyArray<boolean | number | string | null>): JsonSchema;
+declare function literalSchema(value: boolean | number | string | null, description?: string): JsonSchema;
+declare function arraySchema(items: JsonSchema, description: string): JsonSchema;
+declare function objectSchema(properties: Record<string, JsonSchema>, required: ReadonlyArray<string>, description?: string): JsonSchema;
+declare function oneOfSchema(schemas: ReadonlyArray<JsonSchema>, description?: string): JsonSchema;
+
+type DropNoteInput = {
+    content: string;
+    source: string;
+    domain?: string;
+};
+type DropNoteData = {
+    noteId: number;
+};
+declare const dropNoteTool: GrimoireToolDefinition<DropNoteInput, ToolResult<DropNoteData>>;
+
+type HoneInput = {
+    paths?: string[];
+    message?: string;
+};
+type HoneData = {
+    commitHash: string;
+    sealedPaths: string[];
+    ranks: Record<string, number>;
+    tiers: Record<string, TierInfo>;
+};
+declare const honeSpellTool: GrimoireToolDefinition<HoneInput, ToolResult<HoneData>>;
+
+type InscribeToolInput = {
+    name: string;
+    content: string;
+    chapter?: string;
+};
+type InscribeToolData = {
+    spell: Spell;
+    warnings: DuplicationWarning[];
+};
+declare const inscribeSpellTool: GrimoireToolDefinition<InscribeToolInput, ToolResult<InscribeToolData>>;
+
+type InspectInput = {
+    path: string;
+};
+type InspectData = {
+    spell: Spell;
+    tierInfo: TierInfo;
+    validation: SpellValidationResult;
+    resonance?: ResonanceResult;
+    provenance?: Provenance;
+    history?: HistoryEntry[];
+};
+declare const inspectGrimoireItemTool: GrimoireToolDefinition<InspectInput, ToolResult<InspectData>>;
+
+type ManageDraftInput = {
+    action: 'submit';
+    title: string;
+    rationale: string;
+    noteIds: number[];
+    chapter: string;
+} | {
+    action: 'approve';
+    draftId: number;
+} | {
+    action: 'dismiss';
+    draftId: number;
+};
+declare const manageDraftTool: GrimoireToolDefinition<ManageDraftInput, ToolResult<Record<string, unknown>>>;
+
+type ManageInput = {
+    action: 'shelve';
+    path: string;
+} | {
+    action: 'unshelve';
+    path: string;
+} | {
+    action: 'move';
+    path: string;
+    target: string;
+} | {
+    action: 'delete';
+    path: string;
+} | {
+    action: 'repair';
+    path: string;
+} | {
+    action: 'repair_all';
+} | {
+    action: 'rollback';
+    path: string;
+    ref: string;
+};
+declare const manageSpellTool: GrimoireToolDefinition<ManageInput, ToolResult<Record<string, unknown>>>;
+
+type ReviewView = 'chapters' | 'health' | 'resonance' | 'notes' | 'drafts' | 'validation' | 'provenance' | 'index';
+type ReviewInput = {
+    view: ReviewView;
+    limit?: number;
+    now?: number;
+};
+declare const reviewGrimoireTool: GrimoireToolDefinition<ReviewInput, ToolResult<Record<string, unknown>>>;
+
+type CatalogueInput = {
+    now?: number;
+};
+declare const runCatalogueTool: GrimoireToolDefinition<CatalogueInput, ToolResult<CatalogueSnapshot>>;
+
+type ScoutInput = {
+    action: 'adopt';
+    source: string;
+    chapter?: string;
+} | {
+    action: 'search';
+    query: string;
+} | {
+    action: 'check_updates';
+} | {
+    action: 'apply_update';
+    path: string;
+};
+declare const scoutSkillsTool: GrimoireToolDefinition<ScoutInput, ToolResult<Record<string, unknown>>>;
+
+type SearchInput = {
+    query: string;
+    chapters?: string[];
+};
+type SearchData = {
+    results: IndexEntry[];
+    count: number;
+};
+declare const searchGrimoireTool: GrimoireToolDefinition<SearchInput, ToolResult<SearchData>>;
+
+interface TranslateToolErrorOptions {
+    entities?: ToolEntityRef[];
+    next?: ToolNextStepHint[];
+    summary?: string;
+}
+declare function translateToolError(error: unknown, options?: TranslateToolErrorOptions): ToolFailure;
+declare function withToolHandling<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => TResult, options?: TranslateToolErrorOptions): (...args: TArgs) => TResult | ToolFailure;
+
+interface ToolMappingEntry {
+    api: string;
+    tool: string;
+    action?: string | undefined;
+    view?: string | undefined;
+}
+declare const toolMapping: readonly ToolMappingEntry[];
+
+declare const searchGrimoireToolName = "search_grimoire";
+declare const reviewGrimoireToolName = "review_grimoire";
+declare const inspectGrimoireItemToolName = "inspect_grimoire_item";
+declare const inscribeSpellToolName = "inscribe_spell";
+declare const honeSpellToolName = "hone_spell";
+declare const manageSpellToolName = "manage_spell";
+declare const dropNoteToolName = "drop_note";
+declare const manageDraftToolName = "manage_draft";
+declare const runCatalogueToolName = "run_catalogue";
+declare const scoutSkillsToolName = "scout_skills";
+
+declare function inspectSpellNext(path: string, name?: string): ToolNextStepHint;
+declare function reviewViewNext(view: string, message?: string): ToolNextStepHint;
+declare function useToolNext(tool: string, message: string, suggestedInput?: Record<string, unknown>): ToolNextStepHint;
+declare function honeNext(paths?: string[]): ToolNextStepHint;
+declare function searchNext(query: string, message?: string): ToolNextStepHint;
+declare function catalogueNext(): ToolNextStepHint;
+declare function manageSpellNext(action: string, path?: string): ToolNextStepHint;
+declare function askUserNext(message: string): ToolNextStepHint;
+declare function retryNext(message: string, suggestedInput?: Record<string, unknown>): ToolNextStepHint;
+
+declare function toSpellRef(spell: Spell): ToolEntityRef;
+declare function toSpellPathRef(path: string, name?: string, tier?: string): ToolEntityRef;
+declare function toNoteRef(note: SpellNote): ToolEntityRef;
+declare function toDraftRef(draft: SpellDraft): ToolEntityRef;
+declare function toProvenanceRef(prov: Provenance): ToolEntityRef;
+declare function toIndexEntryRef(entry: IndexEntry): ToolEntityRef;
+
+declare const grimoireTools: readonly [GrimoireToolDefinition<{
+    query: string;
+    chapters?: string[];
+}, ToolResult<{
+    results: IndexEntry[];
+    count: number;
+}>>, GrimoireToolDefinition<{
+    view: "chapters" | "provenance" | "notes" | "health" | "drafts" | "validation" | "resonance" | "index";
+    limit?: number;
+    now?: number;
+}, ToolResult<Record<string, unknown>>>, GrimoireToolDefinition<{
+    path: string;
+}, ToolResult<{
+    spell: Spell;
+    tierInfo: TierInfo;
+    validation: SpellValidationResult;
+    resonance?: ResonanceResult;
+    provenance?: Provenance;
+    history?: HistoryEntry[];
+}>>, GrimoireToolDefinition<{
+    name: string;
+    content: string;
+    chapter?: string;
+}, ToolResult<{
+    spell: Spell;
+    warnings: DuplicationWarning[];
+}>>, GrimoireToolDefinition<{
+    paths?: string[];
+    message?: string;
+}, ToolResult<{
+    commitHash: string;
+    sealedPaths: string[];
+    ranks: Record<string, number>;
+    tiers: Record<string, TierInfo>;
+}>>, GrimoireToolDefinition<{
+    action: "shelve";
+    path: string;
+} | {
+    action: "unshelve";
+    path: string;
+} | {
+    action: "move";
+    path: string;
+    target: string;
+} | {
+    action: "delete";
+    path: string;
+} | {
+    action: "repair";
+    path: string;
+} | {
+    action: "repair_all";
+} | {
+    action: "rollback";
+    path: string;
+    ref: string;
+}, ToolResult<Record<string, unknown>>>, GrimoireToolDefinition<{
+    content: string;
+    source: string;
+    domain?: string;
+}, ToolResult<{
+    noteId: number;
+}>>, GrimoireToolDefinition<{
+    action: "submit";
+    title: string;
+    rationale: string;
+    noteIds: number[];
+    chapter: string;
+} | {
+    action: "approve";
+    draftId: number;
+} | {
+    action: "dismiss";
+    draftId: number;
+}, ToolResult<Record<string, unknown>>>, GrimoireToolDefinition<{
+    now?: number;
+}, ToolResult<CatalogueSnapshot>>, GrimoireToolDefinition<{
+    action: "adopt";
+    source: string;
+    chapter?: string;
+} | {
+    action: "search";
+    query: string;
+} | {
+    action: "check_updates";
+} | {
+    action: "apply_update";
+    path: string;
+}, ToolResult<Record<string, unknown>>>];
+declare function listGrimoireToolDefinitions(): ToolDefinitionRegistry;
+declare function getGrimoireToolByName(name: string): GrimoireToolDefinition<{
+    content: string;
+    source: string;
+    domain?: string;
+}, ToolResult<{
+    noteId: number;
+}>> | GrimoireToolDefinition<{
+    paths?: string[];
+    message?: string;
+}, ToolResult<{
+    commitHash: string;
+    sealedPaths: string[];
+    ranks: Record<string, number>;
+    tiers: Record<string, TierInfo>;
+}>> | GrimoireToolDefinition<{
+    name: string;
+    content: string;
+    chapter?: string;
+}, ToolResult<{
+    spell: Spell;
+    warnings: DuplicationWarning[];
+}>> | GrimoireToolDefinition<{
+    path: string;
+}, ToolResult<{
+    spell: Spell;
+    tierInfo: TierInfo;
+    validation: SpellValidationResult;
+    resonance?: ResonanceResult;
+    provenance?: Provenance;
+    history?: HistoryEntry[];
+}>> | GrimoireToolDefinition<{
+    action: "submit";
+    title: string;
+    rationale: string;
+    noteIds: number[];
+    chapter: string;
+} | {
+    action: "approve";
+    draftId: number;
+} | {
+    action: "dismiss";
+    draftId: number;
+}, ToolResult<Record<string, unknown>>> | GrimoireToolDefinition<{
+    action: "shelve";
+    path: string;
+} | {
+    action: "unshelve";
+    path: string;
+} | {
+    action: "move";
+    path: string;
+    target: string;
+} | {
+    action: "delete";
+    path: string;
+} | {
+    action: "repair";
+    path: string;
+} | {
+    action: "repair_all";
+} | {
+    action: "rollback";
+    path: string;
+    ref: string;
+}, ToolResult<Record<string, unknown>>> | GrimoireToolDefinition<{
+    view: "chapters" | "provenance" | "notes" | "health" | "drafts" | "validation" | "resonance" | "index";
+    limit?: number;
+    now?: number;
+}, ToolResult<Record<string, unknown>>> | GrimoireToolDefinition<{
+    now?: number;
+}, ToolResult<CatalogueSnapshot>> | GrimoireToolDefinition<{
+    action: "adopt";
+    source: string;
+    chapter?: string;
+} | {
+    action: "search";
+    query: string;
+} | {
+    action: "check_updates";
+} | {
+    action: "apply_update";
+    path: string;
+}, ToolResult<Record<string, unknown>>> | GrimoireToolDefinition<{
+    query: string;
+    chapters?: string[];
+}, ToolResult<{
+    results: IndexEntry[];
+    count: number;
+}>> | undefined;
+
+declare function summarizeCount(count: number, singular: string, plural?: string): string;
+declare function summarizeSpellAction(action: string, path: string): string;
+
+type index_GrimoireToolContext = GrimoireToolContext;
+type index_GrimoireToolDefinition<TInput = Record<string, unknown>, TResult extends ToolResult<unknown> = ToolResult<unknown>> = GrimoireToolDefinition<TInput, TResult>;
+type index_JsonSchema = JsonSchema;
+type index_JsonSchemaType = JsonSchemaType;
+type index_ToolBaseResult = ToolBaseResult;
+type index_ToolClarificationCode = ToolClarificationCode;
+type index_ToolDefinitionRegistry = ToolDefinitionRegistry;
+type index_ToolEntityKind = ToolEntityKind;
+type index_ToolEntityKindSet = ToolEntityKindSet;
+type index_ToolEntityRef = ToolEntityRef;
+type index_ToolErrorCode = ToolErrorCode;
+type index_ToolErrorKind = ToolErrorKind;
+type index_ToolFailure = ToolFailure;
+type index_ToolInputDescriptions = ToolInputDescriptions;
+type index_ToolMappingEntry = ToolMappingEntry;
+type index_ToolNeedsClarification = ToolNeedsClarification;
+type index_ToolNextStepHint = ToolNextStepHint;
+type index_ToolNextStepHintKind = ToolNextStepHintKind;
+type index_ToolOutcomeKind = ToolOutcomeKind;
+type index_ToolOutputDescription = ToolOutputDescription;
+type index_ToolResult<TData> = ToolResult<TData>;
+type index_ToolSideEffects = ToolSideEffects;
+type index_ToolSuccess<TData> = ToolSuccess<TData>;
+type index_ToolWarning = ToolWarning;
+type index_ToolWarningCode = ToolWarningCode;
+declare const index_arraySchema: typeof arraySchema;
+declare const index_askUserNext: typeof askUserNext;
+declare const index_booleanSchema: typeof booleanSchema;
+declare const index_catalogueNext: typeof catalogueNext;
+declare const index_defineGrimoireTool: typeof defineGrimoireTool;
+declare const index_dropNoteTool: typeof dropNoteTool;
+declare const index_dropNoteToolName: typeof dropNoteToolName;
+declare const index_enumSchema: typeof enumSchema;
+declare const index_getGrimoireToolByName: typeof getGrimoireToolByName;
+declare const index_grimoireTools: typeof grimoireTools;
+declare const index_honeNext: typeof honeNext;
+declare const index_honeSpellTool: typeof honeSpellTool;
+declare const index_honeSpellToolName: typeof honeSpellToolName;
+declare const index_inscribeSpellTool: typeof inscribeSpellTool;
+declare const index_inscribeSpellToolName: typeof inscribeSpellToolName;
+declare const index_inspectGrimoireItemTool: typeof inspectGrimoireItemTool;
+declare const index_inspectGrimoireItemToolName: typeof inspectGrimoireItemToolName;
+declare const index_inspectSpellNext: typeof inspectSpellNext;
+declare const index_integerSchema: typeof integerSchema;
+declare const index_listGrimoireToolDefinitions: typeof listGrimoireToolDefinitions;
+declare const index_literalSchema: typeof literalSchema;
+declare const index_manageDraftTool: typeof manageDraftTool;
+declare const index_manageDraftToolName: typeof manageDraftToolName;
+declare const index_manageSpellNext: typeof manageSpellNext;
+declare const index_manageSpellTool: typeof manageSpellTool;
+declare const index_manageSpellToolName: typeof manageSpellToolName;
+declare const index_numberSchema: typeof numberSchema;
+declare const index_objectSchema: typeof objectSchema;
+declare const index_oneOfSchema: typeof oneOfSchema;
+declare const index_retryNext: typeof retryNext;
+declare const index_reviewGrimoireTool: typeof reviewGrimoireTool;
+declare const index_reviewGrimoireToolName: typeof reviewGrimoireToolName;
+declare const index_reviewViewNext: typeof reviewViewNext;
+declare const index_runCatalogueTool: typeof runCatalogueTool;
+declare const index_runCatalogueToolName: typeof runCatalogueToolName;
+declare const index_scoutSkillsTool: typeof scoutSkillsTool;
+declare const index_scoutSkillsToolName: typeof scoutSkillsToolName;
+declare const index_searchGrimoireTool: typeof searchGrimoireTool;
+declare const index_searchGrimoireToolName: typeof searchGrimoireToolName;
+declare const index_searchNext: typeof searchNext;
+declare const index_stringSchema: typeof stringSchema;
+declare const index_summarizeCount: typeof summarizeCount;
+declare const index_summarizeSpellAction: typeof summarizeSpellAction;
+declare const index_toDraftRef: typeof toDraftRef;
+declare const index_toIndexEntryRef: typeof toIndexEntryRef;
+declare const index_toNoteRef: typeof toNoteRef;
+declare const index_toProvenanceRef: typeof toProvenanceRef;
+declare const index_toSpellPathRef: typeof toSpellPathRef;
+declare const index_toSpellRef: typeof toSpellRef;
+declare const index_toolFailure: typeof toolFailure;
+declare const index_toolMapping: typeof toolMapping;
+declare const index_toolNeedsClarification: typeof toolNeedsClarification;
+declare const index_toolNoOp: typeof toolNoOp;
+declare const index_toolSuccess: typeof toolSuccess;
+declare const index_toolWarning: typeof toolWarning;
+declare const index_translateToolError: typeof translateToolError;
+declare const index_useToolNext: typeof useToolNext;
+declare const index_withToolHandling: typeof withToolHandling;
+declare namespace index {
+  export { type index_GrimoireToolContext as GrimoireToolContext, type index_GrimoireToolDefinition as GrimoireToolDefinition, type index_JsonSchema as JsonSchema, type index_JsonSchemaType as JsonSchemaType, type index_ToolBaseResult as ToolBaseResult, type index_ToolClarificationCode as ToolClarificationCode, type index_ToolDefinitionRegistry as ToolDefinitionRegistry, type index_ToolEntityKind as ToolEntityKind, type index_ToolEntityKindSet as ToolEntityKindSet, type index_ToolEntityRef as ToolEntityRef, type index_ToolErrorCode as ToolErrorCode, type index_ToolErrorKind as ToolErrorKind, type index_ToolFailure as ToolFailure, type index_ToolInputDescriptions as ToolInputDescriptions, type index_ToolMappingEntry as ToolMappingEntry, type index_ToolNeedsClarification as ToolNeedsClarification, type index_ToolNextStepHint as ToolNextStepHint, type index_ToolNextStepHintKind as ToolNextStepHintKind, type index_ToolOutcomeKind as ToolOutcomeKind, type index_ToolOutputDescription as ToolOutputDescription, type index_ToolResult as ToolResult, type index_ToolSideEffects as ToolSideEffects, type index_ToolSuccess as ToolSuccess, type index_ToolWarning as ToolWarning, type index_ToolWarningCode as ToolWarningCode, index_arraySchema as arraySchema, index_askUserNext as askUserNext, index_booleanSchema as booleanSchema, index_catalogueNext as catalogueNext, index_defineGrimoireTool as defineGrimoireTool, index_dropNoteTool as dropNoteTool, index_dropNoteToolName as dropNoteToolName, index_enumSchema as enumSchema, index_getGrimoireToolByName as getGrimoireToolByName, index_grimoireTools as grimoireTools, index_honeNext as honeNext, index_honeSpellTool as honeSpellTool, index_honeSpellToolName as honeSpellToolName, index_inscribeSpellTool as inscribeSpellTool, index_inscribeSpellToolName as inscribeSpellToolName, index_inspectGrimoireItemTool as inspectGrimoireItemTool, index_inspectGrimoireItemToolName as inspectGrimoireItemToolName, index_inspectSpellNext as inspectSpellNext, index_integerSchema as integerSchema, index_listGrimoireToolDefinitions as listGrimoireToolDefinitions, index_literalSchema as literalSchema, index_manageDraftTool as manageDraftTool, index_manageDraftToolName as manageDraftToolName, index_manageSpellNext as manageSpellNext, index_manageSpellTool as manageSpellTool, index_manageSpellToolName as manageSpellToolName, index_numberSchema as numberSchema, index_objectSchema as objectSchema, index_oneOfSchema as oneOfSchema, index_retryNext as retryNext, index_reviewGrimoireTool as reviewGrimoireTool, index_reviewGrimoireToolName as reviewGrimoireToolName, index_reviewViewNext as reviewViewNext, index_runCatalogueTool as runCatalogueTool, index_runCatalogueToolName as runCatalogueToolName, index_scoutSkillsTool as scoutSkillsTool, index_scoutSkillsToolName as scoutSkillsToolName, index_searchGrimoireTool as searchGrimoireTool, index_searchGrimoireToolName as searchGrimoireToolName, index_searchNext as searchNext, index_stringSchema as stringSchema, index_summarizeCount as summarizeCount, index_summarizeSpellAction as summarizeSpellAction, index_toDraftRef as toDraftRef, index_toIndexEntryRef as toIndexEntryRef, index_toNoteRef as toNoteRef, index_toProvenanceRef as toProvenanceRef, index_toSpellPathRef as toSpellPathRef, index_toSpellRef as toSpellRef, index_toolFailure as toolFailure, index_toolMapping as toolMapping, index_toolNeedsClarification as toolNeedsClarification, index_toolNoOp as toolNoOp, index_toolSuccess as toolSuccess, index_toolWarning as toolWarning, index_translateToolError as translateToolError, index_useToolNext as useToolNext, index_withToolHandling as withToolHandling };
+}
+
+declare function withTransaction<T>(db: GrimoireDb, fn: () => T): T;
+
+declare const write_adoptSpell: typeof adoptSpell;
+declare const write_adoptSpells: typeof adoptSpells;
+declare const write_approveDraft: typeof approveDraft;
+declare const write_catalogue: typeof catalogue;
+declare const write_deleteSpell: typeof deleteSpell;
+declare const write_dismissDraft: typeof dismissDraft;
+declare const write_distill: typeof distill;
+declare const write_dropNote: typeof dropNote;
+declare const write_dropNotes: typeof dropNotes;
+declare const write_enforceNoteCap: typeof enforceNoteCap;
+declare const write_expireNotes: typeof expireNotes;
+declare const write_inscribe: typeof inscribe;
+declare const write_logEvent: typeof logEvent;
+declare const write_moveSpell: typeof moveSpell;
+declare const write_repair: typeof repair;
+declare const write_repairAll: typeof repairAll;
+declare const write_rollback: typeof rollback;
+declare const write_seal: typeof seal;
+declare const write_shelve: typeof shelve;
+declare const write_submitDraft: typeof submitDraft;
+declare const write_unshelve: typeof unshelve;
+declare namespace write {
+  export { write_adoptSpell as adoptSpell, write_adoptSpells as adoptSpells, write_approveDraft as approveDraft, write_catalogue as catalogue, write_deleteSpell as deleteSpell, write_dismissDraft as dismissDraft, write_distill as distill, write_dropNote as dropNote, write_dropNotes as dropNotes, write_enforceNoteCap as enforceNoteCap, write_expireNotes as expireNotes, write_inscribe as inscribe, write_logEvent as logEvent, write_moveSpell as moveSpell, write_repair as repair, write_repairAll as repairAll, write_rollback as rollback, write_seal as seal, write_shelve as shelve, write_submitDraft as submitDraft, write_unshelve as unshelve };
+}
+
+export { DEFAULTS, type GrimoireDb, GrimoireError, type GrimoireErrorCode, GrimoireInvariantError, GrimoireNotFoundError, type GrimoireRunResult, type GrimoireSkill, type GrimoireSkillRegistry, type GrimoireSoul, type GrimoireSoulTrait, GrimoireStateError, type GrimoireStatement, GrimoireValidationError, archiveAndPruneSpellsSkill, index$e as catalogue, decomposeOversizedSpellsSkill, defineGrimoireSkill, distillNotesIntoSpellsSkill, index$d as drafts, index$c as events, evolveSpellThroughTiersSkill, getGrimoireSkillByName, index$b as git, grimoireSkills, grimoireSoul, grimoireSoulEssence, grimoireSoulTraits, handleEdgeCasesGracefullySkill, index$a as health, honeSpellFromEvidenceSkill, index$9 as indexing, init, initGrimoireTables, inscribeSpellsCorrectlySkill, isGrimoireError, listGrimoireSkills, maintainGrimoireHealthSkill, network, index$6 as notes, index$5 as provenance, read, reconcileUpstreamUpdatesSkill, index$8 as registry, renderGrimoireSoulPromptFoundation, reorganizeSpellChaptersSkill, resolveNow, resolveValidationFailuresSkill, scoutAndAdoptSkillsSkill, index$7 as scouting, searchAndRetrieveSpellsSkill, index$1 as skills, soul, index$4 as spec, index$3 as spells, index as tools, index$2 as validation, withTransaction, write };