@kaelio/ktx 0.1.0 → 0.2.0

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

@@ -58,6 +58,7 @@ export class SqliteKnowledgeIndex {
         path TEXT PRIMARY KEY,
         key TEXT NOT NULL,
         scope TEXT NOT NULL,
+        scope_id TEXT,
         summary TEXT NOT NULL,
         content TEXT NOT NULL,
         tags TEXT NOT NULL,
@@ -81,6 +82,9 @@ export class SqliteKnowledgeIndex {
         if (!columnNames.has('embedding_json')) {
             this.db.exec('ALTER TABLE knowledge_pages ADD COLUMN embedding_json TEXT');
         }
+        if (!columnNames.has('scope_id')) {
+            this.db.exec('ALTER TABLE knowledge_pages ADD COLUMN scope_id TEXT');
+        }
     }
     sync(pages) {
         const keepPaths = pages.map((page) => page.path);
@@ -91,11 +95,12 @@ export class SqliteKnowledgeIndex {
             ? this.db.prepare('DELETE FROM knowledge_pages_fts')
             : this.db.prepare(`DELETE FROM knowledge_pages_fts WHERE path NOT IN (${keepPaths.map(() => '?').join(', ')})`);
         const upsertPage = this.db.prepare(`
-      INSERT INTO knowledge_pages (path, key, scope, summary, content, tags, search_text, embedding_json)
-      VALUES (@path, @key, @scope, @summary, @content, @tags, @searchText, @embeddingJson)
+      INSERT INTO knowledge_pages (path, key, scope, scope_id, summary, content, tags, search_text, embedding_json)
+      VALUES (@path, @key, @scope, @scopeId, @summary, @content, @tags, @searchText, @embeddingJson)
       ON CONFLICT(path) DO UPDATE SET
         key = excluded.key,
         scope = excluded.scope,
+        scope_id = excluded.scope_id,
         summary = excluded.summary,
         content = excluded.content,
         tags = excluded.tags,
@@ -116,6 +121,7 @@ export class SqliteKnowledgeIndex {
                     path: page.path,
                     key: page.key,
                     scope: page.scope,
+                    scopeId: page.scopeId ?? null,
                     summary: page.summary,
                     content: searchText,
                     tags: page.tags.join(' '),
@@ -205,4 +211,151 @@ export class SqliteKnowledgeIndex {
             score: scoreFromRank(row.rawScore),
         }));
     }
+    pathForPage(scope, scopeId, pageKey) {
+        return scope === 'GLOBAL' ? `wiki/global/${pageKey}.md` : `wiki/user/${scopeId ?? 'local'}/${pageKey}.md`;
+    }
+    async upsertPage(params) {
+        const path = this.pathForPage(params.scope, params.scopeId, params.pageKey);
+        const row = {
+            path,
+            key: params.pageKey,
+            scope: params.scope,
+            scopeId: params.scopeId,
+            summary: params.summary,
+            content: params.searchText,
+            tags: '',
+            searchText: params.searchText,
+            embeddingJson: params.embedding && params.embedding.length > 0 ? JSON.stringify(params.embedding) : null,
+        };
+        const write = this.db.transaction(() => {
+            this.db
+                .prepare(`
+          INSERT INTO knowledge_pages (path, key, scope, scope_id, summary, content, tags, search_text, embedding_json)
+          VALUES (@path, @key, @scope, @scopeId, @summary, @content, @tags, @searchText, @embeddingJson)
+          ON CONFLICT(path) DO UPDATE SET
+            key = excluded.key,
+            scope = excluded.scope,
+            scope_id = excluded.scope_id,
+            summary = excluded.summary,
+            content = excluded.content,
+            tags = excluded.tags,
+            search_text = excluded.search_text,
+            embedding_json = excluded.embedding_json
+        `)
+                .run(row);
+            this.db.prepare('DELETE FROM knowledge_pages_fts WHERE path = @path').run(row);
+            this.db
+                .prepare(`
+          INSERT INTO knowledge_pages_fts (path, key, summary, content, tags)
+          VALUES (@path, @key, @summary, @content, @tags)
+        `)
+                .run(row);
+        });
+        write();
+    }
+    async getExistingSearchTexts(scope, scopeId) {
+        const rows = this.db
+            .prepare(`
+        SELECT key, search_text, embedding_json
+        FROM knowledge_pages
+        WHERE scope = ?
+          AND scope_id IS ?
+        ORDER BY key ASC
+      `)
+            .all(scope, scopeId);
+        return new Map(rows.map((row) => [row.key, { searchText: row.search_text, hasEmbedding: row.embedding_json !== null }]));
+    }
+    async deleteStale(scope, scopeId, keepKeys) {
+        if (keepKeys.length === 0) {
+            return this.deleteByScope(scope, scopeId);
+        }
+        const placeholders = keepKeys.map(() => '?').join(', ');
+        const stale = this.db
+            .prepare(`
+        SELECT key
+        FROM knowledge_pages
+        WHERE scope = ?
+          AND scope_id IS ?
+          AND key NOT IN (${placeholders})
+      `)
+            .all(scope, scopeId, ...keepKeys);
+        for (const row of stale) {
+            await this.deleteByKey(scope, scopeId, row.key);
+        }
+        return stale.length;
+    }
+    async deleteByScope(scope, scopeId) {
+        return this.clear(scope, scopeId);
+    }
+    async deleteByKey(scope, scopeId, pageKey) {
+        const path = this.pathForPage(scope, scopeId, pageKey);
+        const remove = this.db.transaction(() => {
+            this.db.prepare('DELETE FROM knowledge_pages_fts WHERE path = ?').run(path);
+            const result = this.db.prepare('DELETE FROM knowledge_pages WHERE path = ?').run(path);
+            return Number(result.changes);
+        });
+        return remove();
+    }
+    clear(scope, scopeId) {
+        const rows = this.db
+            .prepare('SELECT path FROM knowledge_pages WHERE scope = ? AND scope_id IS ?')
+            .all(scope, scopeId);
+        const remove = this.db.transaction((paths) => {
+            for (const path of paths) {
+                this.db.prepare('DELETE FROM knowledge_pages_fts WHERE path = ?').run(path);
+                this.db.prepare('DELETE FROM knowledge_pages WHERE path = ?').run(path);
+            }
+        });
+        remove(rows.map((row) => row.path));
+        return rows.length;
+    }
+    async applyDiffTransactional(params) {
+        void params.runId;
+        for (const page of params.upserts) {
+            await this.upsertPage(page);
+        }
+        for (const page of params.deletes) {
+            await this.deleteByKey(page.scope, page.scopeId, page.pageKey);
+        }
+    }
+    async findPageByKey(scope, scopeId, pageKey) {
+        const path = this.pathForPage(scope, scopeId, pageKey);
+        const row = this.db.prepare('SELECT path, key FROM knowledge_pages WHERE path = ?').get(path);
+        return row ? { id: row.path, page_key: row.key } : null;
+    }
+    async listPagesForUser(userId) {
+        const rows = this.db
+            .prepare(`
+        SELECT path, key, scope, scope_id, summary, tags
+        FROM knowledge_pages
+        WHERE scope = 'GLOBAL'
+           OR (scope = 'USER' AND scope_id = ?)
+        ORDER BY scope ASC, key ASC
+      `)
+            .all(userId);
+        return rows.map((row) => ({
+            id: row.path,
+            page_key: row.key,
+            summary: row.summary,
+            scope: row.scope,
+            scope_id: row.scope_id,
+            tags: row.tags.split(/\s+/).filter(Boolean),
+        }));
+    }
+    async getUserPageCount(userId) {
+        const row = this.db
+            .prepare("SELECT COUNT(*) AS count FROM knowledge_pages WHERE scope = 'USER' AND scope_id = ?")
+            .get(userId);
+        return row.count;
+    }
+    async incrementUsageCount() { }
+    async searchRRF(userId, _embedding, queryText, limit) {
+        const allowedPages = new Map((await this.listPagesForUser(userId)).map((page) => [page.id, page]));
+        return this.search(queryText, limit)
+            .map((row) => {
+            const page = allowedPages.get(row.path);
+            return page ? { pageKey: page.page_key, summary: page.summary, rrfScore: row.score } : null;
+        })
+            .filter((row) => row !== null);
+    }
 }

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

@@ -54,6 +54,32 @@ describe('SqliteKnowledgeIndex', () => {
         index.rebuild([page()]);
         expect(index.search('churn', 10)).toEqual([]);
     });
+    it('clear removes one wiki scope and leaves other scopes intact', async () => {
+        const index = new SqliteKnowledgeIndex({ dbPath });
+        index.sync([
+            page({ path: 'wiki/global/revenue.md', key: 'revenue', scope: 'GLOBAL', scopeId: null }),
+            page({
+                path: 'wiki/user/local/revenue.md',
+                key: 'revenue',
+                scope: 'USER',
+                scopeId: 'local',
+                summary: 'Local revenue',
+                content: 'Local revenue notes.',
+            }),
+            page({
+                path: 'wiki/user/alex/revenue.md',
+                key: 'revenue',
+                scope: 'USER',
+                scopeId: 'alex',
+                summary: 'Alex revenue',
+                content: 'Alex revenue notes.',
+            }),
+        ]);
+        expect(index.clear('USER', 'local')).toBe(1);
+        expect(index.search('Local', 10)).toEqual([]);
+        expect(index.search('Alex', 10)).toEqual([expect.objectContaining({ path: 'wiki/user/alex/revenue.md' })]);
+        expect(index.search('definition', 10)).toEqual([expect.objectContaining({ path: 'wiki/global/revenue.md' })]);
+    });
     it('exposes existing search text and embedding state for incremental refresh', () => {
         const index = new SqliteKnowledgeIndex({ dbPath });
         index.sync([page({ path: 'wiki/global/revenue.md', key: 'revenue', embedding: [1, 0] })]);

package/node_modules/@ktx/context/package.json

@@ -46,6 +46,11 @@
       "import": "./dist/ingest/metabase-mapping.js",
       "default": "./dist/ingest/metabase-mapping.js"
     },
+    "./index-sync": {
+      "types": "./dist/index-sync/index.d.ts",
+      "import": "./dist/index-sync/index.js",
+      "default": "./dist/index-sync/index.js"
+    },
     "./scan": {
       "types": "./dist/scan/index.d.ts",
       "import": "./dist/scan/index.js",

package/node_modules/@ktx/llm/dist/embedding-provider.d.ts

@@ -1,7 +1,5 @@
 import type { KtxEmbeddingConfig, KtxEmbeddingProvider } from './types.js';
 type FetchFn = typeof fetch;
-type SentenceTransformersCommand = 'embedding-compute' | 'embedding-compute-bulk';
-type SentenceTransformersJsonRunner = (subcommand: SentenceTransformersCommand, payload: Record<string, unknown>) => Promise<Record<string, unknown>>;
 export interface KtxEmbeddingProviderDeps {
     createOpenAIClient?: (options: {
         apiKey?: string;
@@ -25,11 +23,6 @@ export interface KtxEmbeddingProviderDeps {
         };
     };
     fetch?: FetchFn;
-    runSentenceTransformersJson?: SentenceTransformersJsonRunner;
-    sentenceTransformersCommand?: string;
-    sentenceTransformersArgs?: string[];
-    sentenceTransformersCwd?: string;
-    sentenceTransformersEnv?: NodeJS.ProcessEnv;
 }
 export declare function createKtxEmbeddingProvider(config: KtxEmbeddingConfig, deps?: KtxEmbeddingProviderDeps): KtxEmbeddingProvider;
 export {};

package/node_modules/@ktx/llm/dist/embedding-provider.js

@@ -1,15 +1,6 @@
-import { createHash } from 'node:crypto';
-import { spawn } from 'node:child_process';
-import { join } from 'node:path';
 import OpenAI from 'openai';
 const DEFAULT_BATCH_SIZE = 100;
-function deterministicVector(text, dimensions) {
-    const digest = createHash('sha256').update(text).digest();
-    return Array.from({ length: dimensions }, (_, index) => {
-        const byte = digest[index % digest.length];
-        return Number(((byte / 255) * 2 - 1).toFixed(6));
-    });
-}
+const HTTP_ERROR_BODY_MAX_LENGTH = 2_000;
 function assertNonEmptyText(text) {
     if (!text.trim()) {
         throw new Error('Embedding text must be non-empty');
@@ -41,102 +32,12 @@ function joinUrl(baseURL, pathPrefix, path) {
     const suffix = path.replace(/^\/+/, '');
     return prefix ? `${base}/${prefix}/${suffix}` : `${base}/${suffix}`;
 }
-function errorText(error) {
-    if (error instanceof Error) {
-        return error.cause
-            ? `${error.name}: ${error.message}; cause: ${errorText(error.cause)}`
-            : `${error.name}: ${error.message}`;
-    }
-    return String(error);
-}
-function parseJsonObject(raw, subcommand) {
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error(`ktx-daemon ${subcommand} returned non-object JSON`);
-    }
-    return parsed;
-}
-function isCommandNotFound(error) {
-    return (error instanceof Error &&
-        ('code' in error || 'errno' in error) &&
-        (error.code === 'ENOENT' || error.errno === 'ENOENT'));
-}
-function defaultSentenceTransformersProcessCommands() {
-    const venvBin = process.platform === 'win32' ? join('.venv', 'Scripts', 'ktx-daemon.exe') : join('.venv', 'bin', 'ktx-daemon');
-    const repoVenvBin = process.platform === 'win32'
-        ? join('ktx', '.venv', 'Scripts', 'ktx-daemon.exe')
-        : join('ktx', '.venv', 'bin', 'ktx-daemon');
-    return [
-        { command: 'ktx-daemon', args: [] },
-        { command: venvBin, args: [] },
-        { command: repoVenvBin, args: [] },
-    ];
-}
-function runSentenceTransformersProcessCommand(options) {
-    return async (subcommand, payload) => new Promise((resolve, reject) => {
-        const child = spawn(options.command, [...options.args, subcommand], {
-            cwd: options.cwd,
-            env: { ...process.env, ...options.env },
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        const stdout = [];
-        const stderr = [];
-        child.stdout.on('data', (chunk) => stdout.push(chunk));
-        child.stderr.on('data', (chunk) => stderr.push(chunk));
-        child.on('error', reject);
-        child.on('close', (code) => {
-            const stdoutText = Buffer.concat(stdout).toString('utf8').trim();
-            const stderrText = Buffer.concat(stderr).toString('utf8').trim();
-            if (code !== 0) {
-                reject(new Error(`ktx-daemon ${subcommand} failed: ${stderrText || `exit code ${code}`}`));
-                return;
-            }
-            try {
-                resolve(parseJsonObject(stdoutText, subcommand));
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-        child.stdin.end(`${JSON.stringify(payload)}\n`);
-    });
-}
-function runSentenceTransformersProcessJson(options) {
-    return async (subcommand, payload) => {
-        const errors = [];
-        for (const command of options.commands) {
-            try {
-                return await runSentenceTransformersProcessCommand({
-                    ...command,
-                    cwd: options.cwd,
-                    env: options.env,
-                })(subcommand, payload);
-            }
-            catch (error) {
-                errors.push(`${command.command}: ${errorText(error)}`);
-                if (!isCommandNotFound(error)) {
-                    break;
-                }
-            }
-        }
-        throw new Error(`ktx-daemon ${subcommand} failed: ${errors.join('; ')}`);
-    };
-}
-class DeterministicEmbeddingProvider {
-    dimensions;
-    maxBatchSize;
-    constructor(dimensions, batchSize = DEFAULT_BATCH_SIZE) {
-        this.dimensions = dimensions;
-        this.maxBatchSize = batchSize;
-    }
-    async embed(text) {
-        assertNonEmptyText(text);
-        return deterministicVector(text, this.dimensions);
-    }
-    async embedMany(texts) {
-        assertBatchSize(texts, this.maxBatchSize);
-        return texts.map((text) => deterministicVector(text, this.dimensions));
+function boundedHttpBody(text) {
+    const normalized = text.trim();
+    if (normalized.length <= HTTP_ERROR_BODY_MAX_LENGTH) {
+        return normalized;
     }
+    return `${normalized.slice(0, HTTP_ERROR_BODY_MAX_LENGTH)}...`;
 }
 class OpenAIEmbeddingProvider {
     config;
@@ -186,9 +87,7 @@ class SentenceTransformersEmbeddingProvider {
     fetch;
     baseURL;
     pathPrefix;
-    runJson;
     startupProbe;
-    useProcessRunner = false;
     constructor(config, deps) {
         if (!config.sentenceTransformers?.baseURL) {
             throw new Error('sentenceTransformers.baseURL is required when KTX embedding backend is sentence-transformers');
@@ -198,15 +97,6 @@ class SentenceTransformersEmbeddingProvider {
         this.fetch = deps.fetch ?? fetch;
         this.baseURL = config.sentenceTransformers.baseURL;
         this.pathPrefix = config.sentenceTransformers.pathPrefix ?? '/api';
-        this.runJson =
-            deps.runSentenceTransformersJson ??
-                runSentenceTransformersProcessJson({
-                    commands: deps.sentenceTransformersCommand
-                        ? [{ command: deps.sentenceTransformersCommand, args: deps.sentenceTransformersArgs ?? [] }]
-                        : defaultSentenceTransformersProcessCommands(),
-                    cwd: deps.sentenceTransformersCwd,
-                    env: deps.sentenceTransformersEnv,
-                });
         this.startupProbe = this.requestSingle('__ktx_embedding_probe__').then((embedding) => {
             assertVectorDimensions(embedding, this.dimensions, 'sentence-transformers');
         });
@@ -219,7 +109,7 @@ class SentenceTransformersEmbeddingProvider {
     async embedMany(texts) {
         assertBatchSize(texts, this.maxBatchSize);
         await this.startupProbe;
-        const response = await this.requestJson('embedding-compute-bulk', '/embeddings/compute-bulk', { texts });
+        const response = await this.requestJson('/embeddings/compute-bulk', { texts });
         if (!response ||
             typeof response !== 'object' ||
             !('embeddings' in response) ||
@@ -233,29 +123,14 @@ class SentenceTransformersEmbeddingProvider {
         return response.embeddings.map((embedding) => assertVectorDimensions(embedding, this.dimensions, 'sentence-transformers'));
     }
     async requestSingle(text) {
-        const response = await this.requestJson('embedding-compute', '/embeddings/compute', { text });
+        const response = await this.requestJson('/embeddings/compute', { text });
         if (!response || typeof response !== 'object' || !('embedding' in response) || !Array.isArray(response.embedding)) {
             throw new Error('Embedding provider sentence-transformers returned malformed single response');
         }
         return response.embedding;
     }
-    async requestJson(command, path, body) {
-        if (this.useProcessRunner) {
-            return this.runJson(command, body);
-        }
-        try {
-            return await this.postJson(path, body);
-        }
-        catch (httpError) {
-            try {
-                const response = await this.runJson(command, body);
-                this.useProcessRunner = true;
-                return response;
-            }
-            catch (processError) {
-                throw new Error(`Embedding provider sentence-transformers local HTTP request failed (${errorText(httpError)}) and ktx-daemon fallback failed (${errorText(processError)})`);
-            }
-        }
+    async requestJson(path, body) {
+        return await this.postJson(path, body);
     }
     async postJson(path, body) {
         const response = await this.fetch(joinUrl(this.baseURL, this.pathPrefix, path), {
@@ -264,7 +139,8 @@ class SentenceTransformersEmbeddingProvider {
             body: JSON.stringify(body),
         });
         if (!response.ok) {
-            throw new Error(`Embedding provider sentence-transformers request failed with HTTP ${response.status}`);
+            const bodyText = boundedHttpBody(await response.text());
+            throw new Error(`Embedding provider sentence-transformers request failed with HTTP ${response.status}${bodyText ? `: ${bodyText}` : ''}`);
         }
         const parsed = (await response.json());
         if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
@@ -275,8 +151,6 @@ class SentenceTransformersEmbeddingProvider {
 }
 export function createKtxEmbeddingProvider(config, deps = {}) {
     switch (config.backend) {
-        case 'deterministic':
-            return new DeterministicEmbeddingProvider(config.dimensions, config.batchSize);
         case 'openai':
             return new OpenAIEmbeddingProvider(config, deps);
         case 'sentence-transformers':

package/node_modules/@ktx/llm/dist/embedding-provider.test.js

@@ -1,18 +1,13 @@
 import { describe, expect, it, vi } from 'vitest';
 import { createKtxEmbeddingProvider } from './embedding-provider.js';
 describe('createKtxEmbeddingProvider', () => {
-    it('creates deterministic embeddings with stable dimensions', async () => {
-        const provider = createKtxEmbeddingProvider({
+    it('rejects deterministic embeddings', () => {
+        const config = JSON.parse(JSON.stringify({
             backend: 'deterministic',
             model: 'sha256',
             dimensions: 6,
-            batchSize: 4,
-        });
-        await expect(provider.embed('Revenue policy')).resolves.toHaveLength(6);
-        await expect(provider.embed('Revenue policy')).resolves.toEqual(await provider.embed('Revenue policy'));
-        await expect(provider.embed('Revenue policy')).resolves.not.toEqual(await provider.embed('Approval policy'));
-        await expect(provider.embedMany(['a', 'b'])).resolves.toHaveLength(2);
-        expect(provider.maxBatchSize).toBe(4);
+        }));
+        expect(() => createKtxEmbeddingProvider(config)).toThrow('Unsupported KTX embedding backend: deterministic');
     });
     it('rejects gateway embeddings', () => {
         const config = JSON.parse(JSON.stringify({
@@ -72,28 +67,18 @@ describe('createKtxEmbeddingProvider', () => {
         expect(daemonFetch).toHaveBeenNthCalledWith(1, 'https://daemon.test/base/embeddings/compute', expect.objectContaining({ method: 'POST' }));
         expect(daemonFetch).toHaveBeenNthCalledWith(2, 'https://daemon.test/base/embeddings/compute-bulk', expect.objectContaining({ method: 'POST' }));
     });
-    it('falls back to one-shot ktx-daemon inference when the local HTTP daemon is unavailable', async () => {
-        const fetch = vi.fn().mockRejectedValue(new TypeError('fetch failed'));
-        const runSentenceTransformersJson = vi
+    it('reports local HTTP daemon failures without a ktx-daemon spawn fallback cascade', async () => {
+        const fetch = vi
             .fn()
-            .mockResolvedValueOnce({ embedding: [0.1, 0.2] })
-            .mockResolvedValueOnce({ embeddings: [[0.3, 0.4], [0.5, 0.6]] });
+            .mockResolvedValue(new Response('Embedding compute failed: httpx.InvalidURL: Invalid port', { status: 500 }));
         const provider = createKtxEmbeddingProvider({
             backend: 'sentence-transformers',
             model: 'all-MiniLM-L6-v2',
             dimensions: 2,
             sentenceTransformers: { baseURL: 'http://127.0.0.1:8765', pathPrefix: '' },
-        }, { fetch, runSentenceTransformersJson });
-        await expect(provider.embedMany(['hello', 'world'])).resolves.toEqual([
-            [0.3, 0.4],
-            [0.5, 0.6],
-        ]);
+        }, { fetch });
+        await expect(provider.embed('hello')).rejects.toThrow('Embedding provider sentence-transformers request failed with HTTP 500: Embedding compute failed: httpx.InvalidURL: Invalid port');
+        await expect(provider.embed('hello')).rejects.not.toThrow('ktx-daemon fallback failed');
         expect(fetch).toHaveBeenCalledTimes(1);
-        expect(runSentenceTransformersJson).toHaveBeenNthCalledWith(1, 'embedding-compute', {
-            text: '__ktx_embedding_probe__',
-        });
-        expect(runSentenceTransformersJson).toHaveBeenNthCalledWith(2, 'embedding-compute-bulk', {
-            texts: ['hello', 'world'],
-        });
     });
 });

package/node_modules/@ktx/llm/dist/types.d.ts

@@ -68,7 +68,7 @@ export interface KtxLlmProvider {
     promptCachingConfig(): KtxPromptCachingConfig;
     activeBackend(): KtxLlmBackend;
 }
-export type KtxEmbeddingBackend = 'openai' | 'deterministic' | 'sentence-transformers';
+export type KtxEmbeddingBackend = 'openai' | 'sentence-transformers';
 export interface KtxEmbeddingTokenUsageEvent {
     backend: KtxEmbeddingBackend;
     model: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaelio/ktx",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Standalone KTX context layer for database agents",
   "private": false,
   "type": "module",