@kaelio/ktx 0.4.0 → 0.5.0

package/node_modules/@ktx/context/dist/wiki/keys.js

@@ -1,26 +0,0 @@
-const FLAT_WIKI_KEY_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
-export function suggestFlatWikiKey(key) {
-    const suggested = key
-        .trim()
-        .replace(/[\\/]+/g, '-')
-        .replace(/[^a-zA-Z0-9_-]+/g, '-')
-        .replace(/-+/g, '-')
-        .replace(/^[-_]+|[-_]+$/g, '');
-    return suggested.length > 0 ? suggested : 'page-key';
-}
-export function invalidFlatWikiKeyMessage(key) {
-    return `Invalid wiki key "${key}". Wiki keys must be flat; use "${suggestFlatWikiKey(key)}".`;
-}
-export function isFlatWikiKey(key) {
-    return FLAT_WIKI_KEY_PATTERN.test(key);
-}
-export function validateFlatWikiKey(key) {
-    return isFlatWikiKey(key) ? { ok: true, key } : { ok: false, error: invalidFlatWikiKeyMessage(key) };
-}
-export function assertFlatWikiKey(key) {
-    const result = validateFlatWikiKey(key);
-    if (!result.ok) {
-        throw new Error(result.error);
-    }
-    return result.key;
-}

package/node_modules/@ktx/context/dist/wiki/knowledge-wiki.service.d.ts

@@ -1,77 +0,0 @@
-import type { KtxEmbeddingPort, KtxFileStorePort, KtxLogger } from '../core/index.js';
-import type { ReindexWorkResult } from '../index-sync/types.js';
-import type { KnowledgeGitDiffPort, KnowledgeIndexPort } from './ports.js';
-import type { WikiFrontmatter, WikiPage, WikiPageWithScope } from './types.js';
-export type { WikiFrontmatter };
-export declare class KnowledgeWikiService {
-    private readonly configService;
-    private readonly embeddingService;
-    private readonly pagesRepository;
-    private readonly gitService;
-    private readonly logger;
-    private isWorktreeScoped;
-    constructor(configService: KtxFileStorePort, embeddingService: KtxEmbeddingPort | null, pagesRepository: KnowledgeIndexPort, gitService: KnowledgeGitDiffPort, logger?: KtxLogger);
-    /**
-     * Return a clone of this service whose disk writes go through a worktree-scoped
-     * ConfigService AND whose DB-index writes are no-ops. Used by memory-agent
-     * session worktrees so wiki tool calls during the LLM loop land on the session
-     * branch. The shared `knowledge` table is only touched once per run, atomically,
-     * via `syncFromCommit` after Stage 6 squashes the branch into main.
-     */
-    forWorktree(workdir: string): KnowledgeWikiService;
-    private markWorktreeScoped;
-    private scopeDir;
-    pagePath(scope: string, scopeId: string | null | undefined, pageKey: string): string;
-    parsePage(raw: string): {
-        frontmatter: WikiFrontmatter;
-        content: string;
-    };
-    serializePage(frontmatter: WikiFrontmatter, content: string): string;
-    writePage(scope: string, scopeId: string | null | undefined, pageKey: string, frontmatter: WikiFrontmatter, content: string, author: string, authorEmail: string, commitMessage?: string, options?: {
-        skipLock?: boolean;
-    }): Promise<import("../core/file-store.js").KtxFileWriteResult>;
-    readPage(scope: string, scopeId: string | null | undefined, pageKey: string): Promise<WikiPage | null>;
-    deletePage(scope: string, scopeId: string | null | undefined, pageKey: string, author: string, authorEmail: string): Promise<import("../core/file-store.js").KtxFileWriteResult | null>;
-    listPageKeys(scope: string, scopeId?: string | null): Promise<string[]>;
-    getPageHistory(scope: string, scopeId: string | null | undefined, pageKey: string): Promise<unknown>;
-    readPageForUser(userId: string, pageKey: string): Promise<WikiPageWithScope | null>;
-    /**
-     * Write a page verbatim from raw .md text (front-matter + body) after parse-validation.
-     * Preserves the user's exact formatting (raw mode source-of-truth).
-     */
-    writeRawPageAndSync(scope: string, scopeId: string | null | undefined, pageKey: string, rawContent: string, author: string, authorEmail: string, commitMessage?: string): Promise<{
-        frontmatter: WikiFrontmatter;
-        content: string;
-    }>;
-    /**
-     * Write a wiki page and then sync it to the DB search index.
-     * Chains the two operations so the index is only updated after the file write succeeds.
-     */
-    writePageAndSync(scope: string, scopeId: string | null | undefined, pageKey: string, frontmatter: WikiFrontmatter, content: string, author: string, authorEmail: string, commitMessage?: string): Promise<void>;
-    /**
-     * Sync a single page to the DB search index after a write.
-     * Computes search_text and embedding, then upserts to knowledge index.
-     */
-    syncSinglePage(scope: string, scopeId: string | null | undefined, pageKey: string, frontmatter: WikiFrontmatter, content: string, contentHash?: string | null): Promise<void>;
-    /**
-     * Full sync: load all pages from disk for a scope, reindex changed pages, clean stale entries.
-     * Mirrors SlSearchService.indexSources() pattern.
-     */
-    syncIndex(scope: string, scopeId?: string | null): Promise<ReindexWorkResult>;
-    /**
-     * Delete a page from the DB index (after file deletion).
-     */
-    deleteFromIndex(scope: string, scopeId: string | null | undefined, pageKey: string): Promise<void>;
-    /**
-     * Apply the diff between two commits on the config repo to the shared
-     * wiki index in a single transaction. Called by the ingest runner
-     * after Stage 6 squashes the session branch into main: the pre-squash main
-     * SHA and the post-squash SHA bracket exactly the set of wiki-file
-     * changes this run produced.
-     *
-     * Any added/modified file becomes an upsert (tagged with `source_run_id`),
-     * any deleted file becomes a delete. Parsing errors fail the whole
-     * transaction so the shared table stays consistent.
-     */
-    syncFromCommit(fromSha: string, toSha: string, runId: string): Promise<void>;
-}

package/node_modules/@ktx/context/dist/wiki/knowledge-wiki.service.js

@@ -1,357 +0,0 @@
-import { createHash } from 'node:crypto';
-import YAML from 'yaml';
-import { noopLogger } from '../core/index.js';
-import { assertFlatWikiKey, isFlatWikiKey } from './keys.js';
-import { buildKnowledgeSearchText } from './knowledge-search-text.js';
-const WIKI_PREFIX = 'wiki';
-export class KnowledgeWikiService {
-    configService;
-    embeddingService;
-    pagesRepository;
-    gitService;
-    logger;
-    isWorktreeScoped = false;
-    constructor(configService, embeddingService, pagesRepository, gitService, logger = noopLogger) {
-        this.configService = configService;
-        this.embeddingService = embeddingService;
-        this.pagesRepository = pagesRepository;
-        this.gitService = gitService;
-        this.logger = logger;
-    }
-    /**
-     * Return a clone of this service whose disk writes go through a worktree-scoped
-     * ConfigService AND whose DB-index writes are no-ops. Used by memory-agent
-     * session worktrees so wiki tool calls during the LLM loop land on the session
-     * branch. The shared `knowledge` table is only touched once per run, atomically,
-     * via `syncFromCommit` after Stage 6 squashes the branch into main.
-     */
-    forWorktree(workdir) {
-        return new KnowledgeWikiService(this.configService.forWorktree(workdir), this.embeddingService, this.pagesRepository, this.gitService, this.logger).markWorktreeScoped();
-    }
-    markWorktreeScoped() {
-        this.isWorktreeScoped = true;
-        return this;
-    }
-    // ── File paths ────────────────────────────────────────────────
-    scopeDir(scope, scopeId) {
-        if (scope === 'GLOBAL') {
-            return `${WIKI_PREFIX}/global`;
-        }
-        return `${WIKI_PREFIX}/user/${scopeId}`;
-    }
-    pagePath(scope, scopeId, pageKey) {
-        return `${this.scopeDir(scope, scopeId)}/${assertFlatWikiKey(pageKey)}.md`;
-    }
-    // ── Parsing / serialization ───────────────────────────────────
-    parsePage(raw) {
-        const match = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-        if (!match) {
-            throw new Error('Invalid wiki page: missing YAML frontmatter');
-        }
-        const frontmatter = YAML.parse(match[1]);
-        const content = match[2].trim();
-        return { frontmatter, content };
-    }
-    serializePage(frontmatter, content) {
-        const yaml = YAML.stringify(frontmatter, { indent: 2, lineWidth: 0 }).trimEnd();
-        return `---\n${yaml}\n---\n\n${content}\n`;
-    }
-    // ── File CRUD ─────────────────────────────────────────────────
-    async writePage(scope, scopeId, pageKey, frontmatter, content, author, authorEmail, commitMessage, options) {
-        const path = this.pagePath(scope, scopeId, pageKey);
-        const serialized = this.serializePage(frontmatter, content);
-        const message = commitMessage ?? `Update wiki page: ${pageKey}`;
-        return this.configService.writeFile(path, serialized, author, authorEmail, message, {
-            skipLock: options?.skipLock,
-        });
-    }
-    async readPage(scope, scopeId, pageKey) {
-        const path = this.pagePath(scope, scopeId, pageKey);
-        try {
-            const result = await this.configService.readFile(path);
-            const { frontmatter, content } = this.parsePage(result.content);
-            return { pageKey, frontmatter, content };
-        }
-        catch {
-            return null;
-        }
-    }
-    async deletePage(scope, scopeId, pageKey, author, authorEmail) {
-        const path = this.pagePath(scope, scopeId, pageKey);
-        try {
-            return await this.configService.deleteFile(path, author, authorEmail, `Remove wiki page: ${pageKey}`);
-        }
-        catch (error) {
-            // Check if the file actually exists — if not, deletion is a no-op
-            try {
-                await this.configService.readFile(path);
-            }
-            catch {
-                // File doesn't exist, nothing to delete
-                return null;
-            }
-            // File exists but delete failed — propagate so callers don't assume success
-            this.logger.error(`Failed to delete wiki page at ${path} despite file existing`);
-            throw error;
-        }
-    }
-    async listPageKeys(scope, scopeId) {
-        const dir = this.scopeDir(scope, scopeId);
-        try {
-            const result = await this.configService.listFiles(dir);
-            return result.files
-                .filter((f) => f.endsWith('.md'))
-                .map((f) => {
-                // Strip the directory prefix and .md extension
-                const name = f.replace(`${dir}/`, '').replace(/\.md$/, '');
-                return name;
-            })
-                .filter(isFlatWikiKey);
-        }
-        catch {
-            return [];
-        }
-    }
-    async getPageHistory(scope, scopeId, pageKey) {
-        const path = this.pagePath(scope, scopeId, pageKey);
-        return this.configService.getFileHistory(path);
-    }
-    // ── Read page for user (USER scope first, fallback to GLOBAL) ─
-    async readPageForUser(userId, pageKey) {
-        // Try USER scope first
-        const userPage = await this.readPage('USER', userId, pageKey);
-        if (userPage) {
-            return { ...userPage, scope: 'USER' };
-        }
-        // Fall back to GLOBAL
-        const globalPage = await this.readPage('GLOBAL', null, pageKey);
-        if (globalPage) {
-            return { ...globalPage, scope: 'GLOBAL' };
-        }
-        return null;
-    }
-    /**
-     * Write a page verbatim from raw .md text (front-matter + body) after parse-validation.
-     * Preserves the user's exact formatting (raw mode source-of-truth).
-     */
-    async writeRawPageAndSync(scope, scopeId, pageKey, rawContent, author, authorEmail, commitMessage) {
-        const parsed = this.parsePage(rawContent);
-        if (!parsed.frontmatter.summary || String(parsed.frontmatter.summary).trim().length === 0) {
-            throw new Error('Front-matter field "summary" is required');
-        }
-        const validModes = ['always', 'auto', 'never'];
-        if (!validModes.includes(parsed.frontmatter.usage_mode)) {
-            throw new Error(`Front-matter field "usage_mode" must be one of: ${validModes.join(', ')}`);
-        }
-        const path = this.pagePath(scope, scopeId, pageKey);
-        await this.configService.writeFile(path, rawContent, author, authorEmail, commitMessage ?? `Update wiki page (raw): ${pageKey}`);
-        await this.syncSinglePage(scope, scopeId, pageKey, parsed.frontmatter, parsed.content);
-        return parsed;
-    }
-    /**
-     * Write a wiki page and then sync it to the DB search index.
-     * Chains the two operations so the index is only updated after the file write succeeds.
-     */
-    async writePageAndSync(scope, scopeId, pageKey, frontmatter, content, author, authorEmail, commitMessage) {
-        await this.writePage(scope, scopeId, pageKey, frontmatter, content, author, authorEmail, commitMessage);
-        const serialized = this.serializePage(frontmatter, content);
-        const contentHash = createHash('sha256').update(serialized).digest('hex');
-        await this.syncSinglePage(scope, scopeId, pageKey, frontmatter, content, contentHash);
-    }
-    // ── Index sync (files → DB) ───────────────────────────────────
-    /**
-     * Sync a single page to the DB search index after a write.
-     * Computes search_text and embedding, then upserts to knowledge index.
-     */
-    async syncSinglePage(scope, scopeId, pageKey, frontmatter, content, contentHash) {
-        if (this.isWorktreeScoped) {
-            // Worktree-scoped writes stay on the session branch only. The shared
-            // knowledge index is updated atomically from the squashed commit diff
-            // after Stage 6 via syncFromCommit().
-            return;
-        }
-        const searchText = buildKnowledgeSearchText(pageKey, frontmatter.summary, content, frontmatter.tags);
-        let embedding = null;
-        if (this.embeddingService) {
-            try {
-                embedding = await this.embeddingService.computeEmbedding(searchText);
-            }
-            catch (err) {
-                this.logger.warn(`Embedding failed for page "${pageKey}": ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-        await this.pagesRepository.upsertPage({
-            scope,
-            scopeId: scopeId ?? null,
-            pageKey,
-            summary: frontmatter.summary,
-            usageMode: frontmatter.usage_mode,
-            sortOrder: frontmatter.sort_order ?? 0,
-            searchText,
-            embedding,
-            contentHash: contentHash ?? null,
-        });
-    }
-    /**
-     * Full sync: load all pages from disk for a scope, reindex changed pages, clean stale entries.
-     * Mirrors SlSearchService.indexSources() pattern.
-     */
-    async syncIndex(scope, scopeId) {
-        const pageKeys = await this.listPageKeys(scope, scopeId);
-        const existing = await this.pagesRepository.getExistingSearchTexts(scope, scopeId ?? null);
-        if (pageKeys.length === 0) {
-            const deleted = await this.pagesRepository.deleteByScope(scope, scopeId ?? null);
-            return {
-                scanned: 0,
-                updated: 0,
-                deleted,
-                embeddingsRecomputed: 0,
-                embeddingsFailed: 0,
-            };
-        }
-        const pages = [];
-        for (const key of pageKeys) {
-            const page = await this.readPage(scope, scopeId, key);
-            if (page) {
-                const searchText = buildKnowledgeSearchText(key, page.frontmatter.summary, page.content, page.frontmatter.tags);
-                pages.push({ pageKey: key, frontmatter: page.frontmatter, content: page.content, searchText });
-            }
-        }
-        const embeddingService = this.embeddingService;
-        const changedPages = pages.filter((page) => {
-            const previous = existing.get(page.pageKey);
-            return (!previous ||
-                previous.searchText !== page.searchText ||
-                (embeddingService !== null && !previous.hasEmbedding));
-        });
-        let embeddings = changedPages.map(() => null);
-        let embeddingsRecomputed = 0;
-        let embeddingsFailed = 0;
-        if (embeddingService && changedPages.length > 0) {
-            try {
-                const changedTexts = changedPages.map((page) => page.searchText);
-                const all = [];
-                for (let i = 0; i < changedTexts.length; i += embeddingService.maxBatchSize) {
-                    const batch = changedTexts.slice(i, i + embeddingService.maxBatchSize);
-                    all.push(...(await embeddingService.computeEmbeddingsBulk(batch)));
-                }
-                embeddings = all;
-                embeddingsRecomputed = all.length;
-            }
-            catch (err) {
-                this.logger.warn(`Embedding batch failed during sync: ${err instanceof Error ? err.message : String(err)}`);
-                embeddingsFailed = changedPages.length;
-            }
-        }
-        for (let i = 0; i < changedPages.length; i += 1) {
-            const page = changedPages[i];
-            await this.pagesRepository.upsertPage({
-                scope,
-                scopeId: scopeId ?? null,
-                pageKey: page.pageKey,
-                summary: page.frontmatter.summary,
-                usageMode: page.frontmatter.usage_mode,
-                sortOrder: page.frontmatter.sort_order ?? 0,
-                searchText: page.searchText,
-                embedding: embeddings[i] ?? null,
-            });
-        }
-        const deleted = await this.pagesRepository.deleteStale(scope, scopeId ?? null, pageKeys);
-        return {
-            scanned: pages.length,
-            updated: changedPages.length,
-            deleted,
-            embeddingsRecomputed,
-            embeddingsFailed,
-        };
-    }
-    /**
-     * Delete a page from the DB index (after file deletion).
-     */
-    async deleteFromIndex(scope, scopeId, pageKey) {
-        if (this.isWorktreeScoped) {
-            return;
-        }
-        await this.pagesRepository.deleteByKey(scope, scopeId ?? null, pageKey);
-    }
-    /**
-     * Apply the diff between two commits on the config repo to the shared
-     * wiki index in a single transaction. Called by the ingest runner
-     * after Stage 6 squashes the session branch into main: the pre-squash main
-     * SHA and the post-squash SHA bracket exactly the set of wiki-file
-     * changes this run produced.
-     *
-     * Any added/modified file becomes an upsert (tagged with `source_run_id`),
-     * any deleted file becomes a delete. Parsing errors fail the whole
-     * transaction so the shared table stays consistent.
-     */
-    async syncFromCommit(fromSha, toSha, runId) {
-        const diff = await this.gitService.diffNameStatus(fromSha, toSha, 'wiki/');
-        if (diff.length === 0) {
-            return;
-        }
-        const upserts = [];
-        const deletes = [];
-        for (const entry of diff) {
-            const parsedPath = parseKnowledgePath(entry.path);
-            if (!parsedPath) {
-                this.logger.warn(`[wiki.sync] skipping unparseable path: ${entry.path}`);
-                continue;
-            }
-            if (entry.status === 'D') {
-                deletes.push(parsedPath);
-                continue;
-            }
-            const content = await this.gitService.getFileAtCommit(entry.path, toSha);
-            const parsed = this.parsePage(content);
-            const searchText = buildKnowledgeSearchText(parsedPath.pageKey, parsed.frontmatter.summary, parsed.content, parsed.frontmatter.tags);
-            let embedding = null;
-            if (this.embeddingService) {
-                try {
-                    embedding = await this.embeddingService.computeEmbedding(searchText);
-                }
-                catch (err) {
-                    this.logger.warn(`[wiki.sync] embedding failed for ${parsedPath.pageKey}: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-            const contentHash = createHash('sha256').update(content).digest('hex');
-            upserts.push({
-                scope: parsedPath.scope,
-                scopeId: parsedPath.scopeId,
-                pageKey: parsedPath.pageKey,
-                summary: parsed.frontmatter.summary,
-                usageMode: parsed.frontmatter.usage_mode,
-                sortOrder: parsed.frontmatter.sort_order ?? 0,
-                searchText,
-                embedding,
-                contentHash,
-            });
-        }
-        await this.pagesRepository.applyDiffTransactional({ runId, upserts, deletes });
-        this.logger.log(`[wiki.sync] run=${runId} applied ${upserts.length} upsert(s), ${deletes.length} delete(s)`);
-    }
-}
-/**
- * Parse a `wiki/<scope>/...` file path into its scope and page key.
- *   `wiki/global/foo.md` → { scope: 'GLOBAL', scopeId: null, pageKey: 'foo' }
- *   `wiki/user/<id>/bar.md` → { scope: 'USER', scopeId: '<id>', pageKey: 'bar' }
- */
-function parseKnowledgePath(path) {
-    if (!path.endsWith('.md')) {
-        return null;
-    }
-    const segments = path.split('/');
-    if (segments[0] !== 'wiki') {
-        return null;
-    }
-    const rest = segments.slice(1);
-    if (rest.length === 2 && rest[0] === 'global') {
-        const pageKey = rest[1].replace(/\.md$/, '');
-        return isFlatWikiKey(pageKey) ? { scope: 'GLOBAL', scopeId: null, pageKey } : null;
-    }
-    if (rest.length === 3 && rest[0] === 'user') {
-        const pageKey = rest[2].replace(/\.md$/, '');
-        return isFlatWikiKey(pageKey) ? { scope: 'USER', scopeId: rest[1], pageKey } : null;
-    }
-    return null;
-}

package/node_modules/@ktx/context/dist/wiki/knowledge-wiki.service.test.js

@@ -1,190 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { KnowledgeWikiService } from './knowledge-wiki.service.js';
-function makeService() {
-    const pagesRepository = {
-        upsertPage: vi.fn().mockResolvedValue(undefined),
-        deleteByKey: vi.fn().mockResolvedValue(0),
-        deleteByScope: vi.fn().mockResolvedValue(0),
-        deleteStale: vi.fn().mockResolvedValue(0),
-        getExistingSearchTexts: vi.fn().mockResolvedValue(new Map()),
-        applyDiffTransactional: vi.fn().mockResolvedValue(undefined),
-    };
-    const embeddingService = {
-        computeEmbedding: vi.fn().mockResolvedValue([0.1, 0.2, 0.3]),
-        computeEmbeddingsBulk: vi.fn().mockResolvedValue([]),
-        maxBatchSize: 16,
-    };
-    const configService = {
-        forWorktree: vi.fn().mockReturnValue({
-            writeFile: vi.fn(),
-            readFile: vi.fn(),
-            deleteFile: vi.fn(),
-            listFiles: vi.fn(),
-            getFileHistory: vi.fn(),
-        }),
-        writeFile: vi.fn(),
-        readFile: vi.fn(),
-        deleteFile: vi.fn(),
-        listFiles: vi.fn(),
-        getFileHistory: vi.fn(),
-    };
-    const gitService = {
-        diffNameStatus: vi.fn().mockResolvedValue([]),
-        getFileAtCommit: vi.fn().mockResolvedValue(''),
-    };
-    const logger = {
-        log: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-    };
-    const service = new KnowledgeWikiService(configService, embeddingService, pagesRepository, gitService, logger);
-    return { service, pagesRepository, embeddingService, configService, gitService, logger };
-}
-const fm = { summary: 'sum', usage_mode: 'auto' };
-describe('KnowledgeWikiService.syncIndex result stats', () => {
-    it('reports scanned, updated, deleted, and embedding counts', async () => {
-        const { service, pagesRepository, embeddingService, configService } = makeService();
-        configService.listFiles.mockResolvedValue({ files: ['wiki/global/revenue.md'] });
-        configService.readFile.mockResolvedValue({
-            content: '---\nsummary: Revenue\nusage_mode: auto\ntags:\n  - finance\n---\n\nPaid orders.\n',
-        });
-        pagesRepository.getExistingSearchTexts.mockResolvedValue(new Map([
-            ['old-page', { searchText: 'old', hasEmbedding: true }],
-        ]));
-        embeddingService.computeEmbeddingsBulk.mockResolvedValue([[0.1, 0.2, 0.3]]);
-        pagesRepository.deleteStale.mockResolvedValue(1);
-        await expect(service.syncIndex('GLOBAL', null)).resolves.toEqual({
-            scanned: 1,
-            updated: 1,
-            deleted: 1,
-            embeddingsRecomputed: 1,
-            embeddingsFailed: 0,
-        });
-    });
-    it('indexes lexical rows when embeddings are not configured', async () => {
-        const { pagesRepository, configService, gitService, logger } = makeService();
-        const service = new KnowledgeWikiService(configService, null, pagesRepository, gitService, logger);
-        configService.listFiles.mockResolvedValue({ files: ['wiki/global/revenue.md'] });
-        configService.readFile.mockResolvedValue({
-            content: '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n',
-        });
-        pagesRepository.getExistingSearchTexts.mockResolvedValue(new Map());
-        pagesRepository.deleteStale.mockResolvedValue(0);
-        const result = await service.syncIndex('GLOBAL', null);
-        expect(result.embeddingsRecomputed).toBe(0);
-        expect(result.embeddingsFailed).toBe(0);
-        expect(pagesRepository.upsertPage).toHaveBeenCalledWith(expect.objectContaining({ pageKey: 'revenue', embedding: null }));
-    });
-    it('does not update unchanged lexical-only wiki rows on repeated sync', async () => {
-        const { pagesRepository, configService, gitService, logger } = makeService();
-        const service = new KnowledgeWikiService(configService, null, pagesRepository, gitService, logger);
-        configService.listFiles.mockResolvedValue({ files: ['wiki/global/revenue.md'] });
-        configService.readFile.mockResolvedValue({
-            content: '---\nsummary: Revenue\nusage_mode: auto\n---\n\nPaid orders.\n',
-        });
-        pagesRepository.getExistingSearchTexts.mockResolvedValue(new Map([
-            ['revenue', { searchText: 'revenue\nRevenue\nPaid orders.', hasEmbedding: false }],
-        ]));
-        pagesRepository.deleteStale.mockResolvedValue(0);
-        await expect(service.syncIndex('GLOBAL', null)).resolves.toEqual({
-            scanned: 1,
-            updated: 0,
-            deleted: 0,
-            embeddingsRecomputed: 0,
-            embeddingsFailed: 0,
-        });
-        expect(pagesRepository.upsertPage).not.toHaveBeenCalled();
-        expect(pagesRepository.deleteStale).toHaveBeenCalledWith('GLOBAL', null, ['revenue']);
-    });
-});
-describe('KnowledgeWikiService.forWorktree isolation', () => {
-    it('syncSinglePage in worktree scope does not call pagesRepository.upsertPage', async () => {
-        const { service, pagesRepository, embeddingService } = makeService();
-        const scoped = service.forWorktree('/tmp/fake-worktree');
-        await scoped.syncSinglePage('GLOBAL', null, 'key', fm, 'body');
-        expect(pagesRepository.upsertPage).not.toHaveBeenCalled();
-        expect(embeddingService.computeEmbedding).not.toHaveBeenCalled();
-    });
-    it('deleteFromIndex in worktree scope does not call pagesRepository.deleteByKey', async () => {
-        const { service, pagesRepository } = makeService();
-        const scoped = service.forWorktree('/tmp/fake-worktree');
-        await scoped.deleteFromIndex('GLOBAL', null, 'key');
-        expect(pagesRepository.deleteByKey).not.toHaveBeenCalled();
-    });
-    it('syncSinglePage in main scope still calls pagesRepository.upsertPage', async () => {
-        const { service, pagesRepository } = makeService();
-        await service.syncSinglePage('GLOBAL', null, 'key', fm, 'body');
-        expect(pagesRepository.upsertPage).toHaveBeenCalledTimes(1);
-    });
-});
-describe('KnowledgeWikiService.syncFromCommit', () => {
-    it('applies upserts for added/modified files and deletes for removed files in a single transactional batch', async () => {
-        const { service, pagesRepository, gitService } = makeService();
-        gitService.diffNameStatus.mockResolvedValue([
-            { status: 'A', path: 'wiki/global/new-page.md' },
-            { status: 'M', path: 'wiki/global/changed-page.md' },
-            { status: 'D', path: 'wiki/global/gone-page.md' },
-        ]);
-        gitService.getFileAtCommit.mockImplementation((path) => {
-            if (path.endsWith('new-page.md')) {
-                return Promise.resolve('---\nsummary: new\nusage_mode: auto\n---\n\nbody-new\n');
-            }
-            if (path.endsWith('changed-page.md')) {
-                return Promise.resolve('---\nsummary: changed\nusage_mode: auto\n---\n\nbody-changed\n');
-            }
-            return Promise.reject(new Error(`unexpected getFileAtCommit path: ${path}`));
-        });
-        await service.syncFromCommit('sha-before', 'sha-after', 'run-uuid');
-        expect(pagesRepository.applyDiffTransactional).toHaveBeenCalledTimes(1);
-        const call = pagesRepository.applyDiffTransactional.mock.calls[0][0];
-        expect(call.runId).toBe('run-uuid');
-        expect(call.upserts).toHaveLength(2);
-        expect(call.upserts).toEqual(expect.arrayContaining([
-            expect.objectContaining({ scope: 'GLOBAL', pageKey: 'new-page', summary: 'new' }),
-            expect.objectContaining({ scope: 'GLOBAL', pageKey: 'changed-page', summary: 'changed' }),
-        ]));
-        expect(call.deletes).toEqual([{ scope: 'GLOBAL', scopeId: null, pageKey: 'gone-page' }]);
-    });
-    it('indexes only flat wiki pages and skips nested paths from commit sync', async () => {
-        const { service, pagesRepository, gitService, logger } = makeService();
-        gitService.diffNameStatus.mockResolvedValue([
-            { status: 'A', path: 'wiki/global/revenue-policy.md' },
-            { status: 'A', path: 'wiki/global/historic-sql-order-lifecycle.md' },
-            { status: 'A', path: 'wiki/global/historic-sql/order-lifecycle.md' },
-            { status: 'A', path: 'wiki/global/orbit/company-overview.md' },
-        ]);
-        gitService.getFileAtCommit.mockImplementation((path) => {
-            if (path.endsWith('revenue-policy.md')) {
-                return Promise.resolve('---\nsummary: revenue\nusage_mode: auto\n---\n\nbody-revenue\n');
-            }
-            if (path.endsWith('order-lifecycle.md')) {
-                return Promise.resolve('---\nsummary: order lifecycle\nusage_mode: auto\n---\n\nbody-orders\n');
-            }
-            if (path.endsWith('retired-pattern.md')) {
-                return Promise.resolve('---\nsummary: retired\nusage_mode: never\n---\n\nbody-retired\n');
-            }
-            return Promise.reject(new Error(`unexpected getFileAtCommit path: ${path}`));
-        });
-        await service.syncFromCommit('sha-before', 'sha-after', 'run-uuid');
-        expect(gitService.getFileAtCommit).not.toHaveBeenCalledWith('wiki/global/orbit/company-overview.md', 'sha-after');
-        expect(gitService.getFileAtCommit).not.toHaveBeenCalledWith('wiki/global/historic-sql/order-lifecycle.md', 'sha-after');
-        expect(logger.warn).toHaveBeenCalledWith('[wiki.sync] skipping unparseable path: wiki/global/orbit/company-overview.md');
-        expect(logger.warn).toHaveBeenCalledWith('[wiki.sync] skipping unparseable path: wiki/global/historic-sql/order-lifecycle.md');
-        const call = pagesRepository.applyDiffTransactional.mock.calls[0][0];
-        expect(call.upserts).toEqual(expect.arrayContaining([
-            expect.objectContaining({ scope: 'GLOBAL', pageKey: 'revenue-policy', summary: 'revenue' }),
-            expect.objectContaining({
-                scope: 'GLOBAL',
-                pageKey: 'historic-sql-order-lifecycle',
-                summary: 'order lifecycle',
-            }),
-        ]));
-        expect(call.upserts).toHaveLength(2);
-    });
-    it('is a no-op when the diff between shas has no knowledge changes', async () => {
-        const { service, pagesRepository, gitService } = makeService();
-        gitService.diffNameStatus.mockResolvedValue([]);
-        await service.syncFromCommit('sha-before', 'sha-after', 'run-uuid');
-        expect(pagesRepository.applyDiffTransactional).not.toHaveBeenCalled();
-    });
-});