@kaelio/ktx 0.4.1 → 0.6.0

package/node_modules/@ktx/context/dist/core/git.service.test.js

@@ -1,357 +0,0 @@
-import { mkdtemp, readFile, realpath, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { GitService } from './git.service.js';
-// These tests drive a real git repo inside a temp directory — simple-git shells out to the
-// system `git` binary. They are fast enough to run as unit tests and catch real issues that
-// would be invisible with mocked git.
-describe('GitService', () => {
-    let service;
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'git-service-spec-'));
-        const coreConfig = {
-            storage: { configDir: tempDir, homeDir: tempDir },
-            git: {
-                userName: 'Test User',
-                userEmail: 'test@example.com',
-                bootstrapMessage: 'Initialize test config repo',
-                bootstrapAuthor: 'test-system',
-                bootstrapAuthorEmail: 'system@example.com',
-            },
-        };
-        service = new GitService(coreConfig);
-        await service.onModuleInit();
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    const writeAndCommit = async (filePath, content, message = 'msg') => {
-        await writeFile(join(tempDir, filePath), content, 'utf-8');
-        return service.commitFile(filePath, message, 'Test', 'test@example.com');
-    };
-    describe('cold-start bootstrap commit', () => {
-        it('writes an empty commit on init so HEAD always resolves', async () => {
-            // beforeEach already ran onModuleInit() against an empty temp dir.
-            const head = await service.revParseHead();
-            expect(head).toMatch(/^[0-9a-f]{40}$/);
-        });
-        it('does not double-commit when re-initialized', async () => {
-            const before = await service.revParseHead();
-            await service.onModuleInit();
-            const after = await service.revParseHead();
-            expect(after).toBe(before);
-        });
-        it('keeps git auto-maintenance attached for deterministic cleanup', async () => {
-            const config = await readFile(join(tempDir, '.git', 'config'), 'utf-8');
-            expect(config).toMatch(/\[gc]\n\s+autoDetach = false/);
-            expect(config).toMatch(/\[maintenance]\n\s+autoDetach = false/);
-        });
-        it('initializes when release automation sets GIT_ASKPASS', async () => {
-            const releaseEnvDir = await mkdtemp(join(tmpdir(), 'git-service-release-env-'));
-            const previousAskPass = process.env.GIT_ASKPASS;
-            process.env.GIT_ASKPASS = 'echo';
-            try {
-                const releaseEnvService = new GitService({
-                    storage: { configDir: releaseEnvDir, homeDir: releaseEnvDir },
-                    git: {
-                        userName: 'Test User',
-                        userEmail: 'test@example.com',
-                        bootstrapMessage: 'Initialize test config repo',
-                        bootstrapAuthor: 'test-system',
-                        bootstrapAuthorEmail: 'system@example.com',
-                    },
-                });
-                await expect(releaseEnvService.onModuleInit()).resolves.toBeUndefined();
-            }
-            finally {
-                if (previousAskPass === undefined) {
-                    delete process.env.GIT_ASKPASS;
-                }
-                else {
-                    process.env.GIT_ASKPASS = previousAskPass;
-                }
-                await rm(releaseEnvDir, { recursive: true, force: true });
-            }
-        });
-    });
-    describe('commitFile `created` flag', () => {
-        it('is true for a real commit', async () => {
-            const info = await writeAndCommit('a.md', '# Hello');
-            expect(info.created).toBe(true);
-        });
-        it('is false on a no-op write (content unchanged)', async () => {
-            await writeAndCommit('a.md', '# Hello');
-            const second = await writeAndCommit('a.md', '# Hello', 'unused');
-            expect(second.created).toBe(false);
-        });
-    });
-    describe('addNote / getNote', () => {
-        it('attaches a note and reads it back', async () => {
-            const info = await writeAndCommit('a.md', '# Hello');
-            await service.addNote(info.commitHash, 'Rich message from LLM');
-            expect(await service.getNote(info.commitHash)).toBe('Rich message from LLM');
-        });
-        it('returns undefined when no note exists', async () => {
-            const info = await writeAndCommit('a.md', '# Hello');
-            expect(await service.getNote(info.commitHash)).toBeUndefined();
-        });
-        it('overwrites an existing note (idempotent retries)', async () => {
-            const info = await writeAndCommit('a.md', '# Hello');
-            await service.addNote(info.commitHash, 'First');
-            await service.addNote(info.commitHash, 'Second');
-            expect(await service.getNote(info.commitHash)).toBe('Second');
-        });
-        it('skips empty/whitespace messages silently', async () => {
-            const info = await writeAndCommit('a.md', '# Hello');
-            await service.addNote(info.commitHash, '   ');
-            expect(await service.getNote(info.commitHash)).toBeUndefined();
-        });
-    });
-    describe('getFileHistory', () => {
-        it('surfaces enhancedMessage when a note is present', async () => {
-            const info = await writeAndCommit('a.md', '# Hello');
-            await service.addNote(info.commitHash, 'Note body');
-            const history = await service.getFileHistory('a.md');
-            expect(history[0]?.enhancedMessage).toBe('Note body');
-        });
-        it('leaves enhancedMessage undefined when no note is attached', async () => {
-            await writeAndCommit('a.md', '# Hello');
-            const history = await service.getFileHistory('a.md');
-            expect(history[0]?.enhancedMessage).toBeUndefined();
-        });
-    });
-    describe('getCommitDiff', () => {
-        it('returns the patch scoped to the requested path', async () => {
-            const info = await writeAndCommit('a.md', '# Hello');
-            const diff = await service.getCommitDiff(info.commitHash, 'a.md');
-            expect(diff).toContain('diff --git');
-            expect(diff).toContain('Hello');
-        });
-        it('handles the repository initial commit without throwing', async () => {
-            const info = await writeAndCommit('first.md', 'first');
-            await expect(service.getCommitDiff(info.commitHash, 'first.md')).resolves.toBeDefined();
-        });
-    });
-    describe('squashTo', () => {
-        const writeAsSystem = async (filePath, content, message = 'msg') => {
-            await writeFile(join(tempDir, filePath), content, 'utf-8');
-            return service.commitFile(filePath, message, 'System User', 'system@example.com');
-        };
-        it('collapses 3 commits after preHead into a single commit', async () => {
-            const pre = await writeAsSystem('a.md', 'v1');
-            const preHead = pre.commitHash;
-            await writeAsSystem('b.md', 'b', 'add b');
-            await writeAsSystem('c.md', 'c', 'add c');
-            await writeAsSystem('a.md', 'v2', 'update a');
-            const result = await service.squashTo(preHead, {
-                message: 'Ingest: bundle 3 writes',
-                author: 'System User',
-                authorEmail: 'system@example.com',
-            });
-            expect(result.squashed).toBe(true);
-            expect(result.squashedCount).toBe(3);
-            expect(result.commitHash).toBeTruthy();
-            expect(result.commitHash).not.toBe(preHead);
-            const commitHash = result.commitHash;
-            if (!commitHash) {
-                throw new Error('Expected squash commit hash');
-            }
-            // The squashed commit should preserve the final tree state.
-            const fileAtSquash = await service.getFileAtCommit('a.md', commitHash);
-            expect(fileAtSquash).toBe('v2');
-            const bAtSquash = await service.getFileAtCommit('b.md', commitHash);
-            expect(bAtSquash).toBe('b');
-        });
-        it('is a no-op when preHead equals HEAD', async () => {
-            const pre = await writeAsSystem('a.md', 'v1');
-            const result = await service.squashTo(pre.commitHash, {
-                message: 'nothing to squash',
-                author: 'System User',
-                authorEmail: 'system@example.com',
-            });
-            expect(result.squashed).toBe(false);
-            expect(result.commitHash).toBe(pre.commitHash);
-        });
-        it('skips squash when a foreign-author commit sits between preHead and HEAD', async () => {
-            const pre = await writeAsSystem('a.md', 'v1');
-            const preHead = pre.commitHash;
-            await writeAsSystem('b.md', 'from us', 'ours');
-            // Foreign commit
-            await writeAndCommit('c.md', 'from someone else', 'foreign');
-            await writeAsSystem('d.md', 'ours again', 'ours 2');
-            const result = await service.squashTo(preHead, {
-                message: 'should be skipped',
-                author: 'System User',
-                authorEmail: 'system@example.com',
-            });
-            expect(result.squashed).toBe(false);
-            expect(result.reason).toContain('foreign');
-            expect(result.squashedCount).toBe(3);
-        });
-        it('returns cleanly when preHead is empty (no starting commit)', async () => {
-            const result = await service.squashTo('', {
-                message: 'would have squashed',
-                author: 'System User',
-                authorEmail: 'system@example.com',
-            });
-            expect(result.squashed).toBe(false);
-            expect(result.commitHash).toBeNull();
-        });
-    });
-    describe('worktree lifecycle', () => {
-        // macOS canonicalizes tmp paths (/var/folders → /private/var/folders) when git
-        // returns them from `worktree list`. Resolve through realpath() before comparing.
-        const canonicalSiblingPath = async (suffix) => {
-            const parent = await realpath(join(tempDir, '..'));
-            return join(parent, `wt-${Date.now()}-${suffix}`);
-        };
-        it('addWorktree creates a branch + directory at the given startSha', async () => {
-            const { commitHash } = await writeAndCommit('seed.md', 'seed');
-            const wtDir = await canonicalSiblingPath('add');
-            await service.addWorktree(wtDir, 'session/alpha', commitHash);
-            const list = await service.listWorktrees();
-            expect(list.find((e) => e.path === wtDir && e.branch === 'refs/heads/session/alpha')).toBeTruthy();
-            await service.removeWorktree(wtDir).catch(() => undefined);
-            await rm(wtDir, { recursive: true, force: true }).catch(() => undefined);
-        });
-        it('removeWorktree detaches the worktree entry', async () => {
-            const { commitHash } = await writeAndCommit('seed.md', 'seed');
-            const wtDir = await canonicalSiblingPath('rm');
-            await service.addWorktree(wtDir, 'session/beta', commitHash);
-            await service.removeWorktree(wtDir);
-            const list = await service.listWorktrees();
-            expect(list.find((e) => e.path === wtDir)).toBeFalsy();
-        });
-        it('deleteBranch removes a branch ref', async () => {
-            const { commitHash } = await writeAndCommit('seed.md', 'seed');
-            const wtDir = await canonicalSiblingPath('br');
-            await service.addWorktree(wtDir, 'session/gamma', commitHash);
-            await service.removeWorktree(wtDir);
-            await service.deleteBranch('session/gamma', true);
-            const branches = await service.git.branchLocal();
-            expect(branches.all).not.toContain('session/gamma');
-            await rm(wtDir, { recursive: true, force: true }).catch(() => undefined);
-        });
-    });
-    describe('forWorktree', () => {
-        it('returns a GitService whose operations run inside the given worktree', async () => {
-            const { commitHash } = await writeAndCommit('seed.md', 'seed');
-            const parent = await realpath(join(tempDir, '..'));
-            const wtDir = join(parent, `wt-${Date.now()}-fw`);
-            await service.addWorktree(wtDir, 'session/delta', commitHash);
-            const scoped = service.forWorktree(wtDir);
-            expect(await scoped.revParseHead()).toBe(commitHash);
-            await service.removeWorktree(wtDir).catch(() => undefined);
-            await rm(wtDir, { recursive: true, force: true }).catch(() => undefined);
-        });
-        it('serializes concurrent commits from scoped services targeting the same worktree', async () => {
-            const { commitHash } = await writeAndCommit('seed.md', 'seed');
-            const parent = await realpath(join(tempDir, '..'));
-            const wtDir = join(parent, `wt-${Date.now()}-fw-concurrent`);
-            await service.addWorktree(wtDir, 'session/concurrent', commitHash);
-            const first = service.forWorktree(wtDir);
-            const second = service.forWorktree(wtDir);
-            await writeFile(join(wtDir, 'a.md'), 'a\n', 'utf-8');
-            await writeFile(join(wtDir, 'b.md'), 'b\n', 'utf-8');
-            const [a, b] = await Promise.all([
-                first.commitFile('a.md', 'add a', 'System User', 'system@example.com'),
-                second.commitFile('b.md', 'add b', 'System User', 'system@example.com'),
-            ]);
-            expect(a.commitHash).toMatch(/^[0-9a-f]{40}$/);
-            expect(b.commitHash).toMatch(/^[0-9a-f]{40}$/);
-            await expect(first.getFileAtCommit('a.md', a.commitHash)).resolves.toBe('a\n');
-            await expect(second.getFileAtCommit('b.md', b.commitHash)).resolves.toBe('b\n');
-            await service.removeWorktree(wtDir).catch(() => undefined);
-            await rm(wtDir, { recursive: true, force: true }).catch(() => undefined);
-        });
-    });
-    describe('squashMergeIntoMain', () => {
-        it('merges a session branch as one commit on main, returning the new SHA + touched paths', async () => {
-            const { commitHash: baseSha } = await writeAndCommit('seed.md', 'seed');
-            const parent = await realpath(join(tempDir, '..'));
-            const wtDir = join(parent, `wt-${Date.now()}-sm`);
-            await service.addWorktree(wtDir, 'session/happy', baseSha);
-            const scoped = service.forWorktree(wtDir);
-            await writeFile(join(wtDir, 'a.yaml'), 'one: 1\n', 'utf-8');
-            await scoped.commitFile('a.yaml', 'wip a', 'System User', 'system@example.com');
-            await writeFile(join(wtDir, 'b.yaml'), 'two: 2\n', 'utf-8');
-            await scoped.commitFile('b.yaml', 'wip b', 'System User', 'system@example.com');
-            const result = await service.squashMergeIntoMain('session/happy', 'System User', 'system@example.com', 'Memory capture: 2 files [chat=abcd1234]');
-            expect(result.ok).toBe(true);
-            if (!result.ok) {
-                throw new Error('unreachable');
-            }
-            expect(result.squashSha).toMatch(/^[0-9a-f]{40}$/);
-            expect(result.touchedPaths.sort()).toEqual(['a.yaml', 'b.yaml']);
-            const mainHead = await service.revParseHead();
-            expect(mainHead).toBe(result.squashSha);
-            expect(mainHead).not.toBe(baseSha);
-            await service.removeWorktree(wtDir).catch(() => undefined);
-            await rm(wtDir, { recursive: true, force: true }).catch(() => undefined);
-        });
-        it('returns ok with empty touchedPaths when the session branch has no diff vs main', async () => {
-            const { commitHash: baseSha } = await writeAndCommit('seed.md', 'seed');
-            const parent = await realpath(join(tempDir, '..'));
-            const wtDir = join(parent, `wt-${Date.now()}-sm-empty`);
-            await service.addWorktree(wtDir, 'session/empty', baseSha);
-            const result = await service.squashMergeIntoMain('session/empty', 'System User', 'system@example.com', 'should be a no-op');
-            expect(result.ok).toBe(true);
-            if (!result.ok) {
-                throw new Error('unreachable');
-            }
-            expect(result.touchedPaths).toEqual([]);
-            expect(result.squashSha).toBe(baseSha);
-            await service.removeWorktree(wtDir).catch(() => undefined);
-            await rm(wtDir, { recursive: true, force: true }).catch(() => undefined);
-        });
-        it('returns conflict=true and leaves main clean when session+main touched same file differently', async () => {
-            await writeAndCommit('shared.yaml', 'base\n');
-            const base = await service.revParseHead();
-            if (!base) {
-                throw new Error('no base head');
-            }
-            const parent = await realpath(join(tempDir, '..'));
-            const wtDir = join(parent, `wt-${Date.now()}-conf`);
-            await service.addWorktree(wtDir, 'session/conf', base);
-            const scoped = service.forWorktree(wtDir);
-            await writeFile(join(wtDir, 'shared.yaml'), 'session-edit\n', 'utf-8');
-            await scoped.commitFile('shared.yaml', 'session edit', 'System User', 'system@example.com');
-            // Main edits the same file a different way, after the session branched.
-            await writeAndCommit('shared.yaml', 'main-edit\n');
-            const result = await service.squashMergeIntoMain('session/conf', 'System User', 'system@example.com', 'Memory capture: 1 file [chat=dead1234]');
-            expect(result.ok).toBe(false);
-            if (result.ok) {
-                throw new Error('unreachable');
-            }
-            expect(result.conflict).toBe(true);
-            expect(result.conflictPaths).toContain('shared.yaml');
-            const status = await service.git.status();
-            expect(status.isClean()).toBe(true);
-            await service.removeWorktree(wtDir).catch(() => undefined);
-            await rm(wtDir, { recursive: true, force: true }).catch(() => undefined);
-        });
-        it('reports untracked files that would be overwritten by the squash merge', async () => {
-            const { commitHash: baseSha } = await writeAndCommit('seed.md', 'seed');
-            const parent = await realpath(join(tempDir, '..'));
-            const wtDir = join(parent, `wt-${Date.now()}-untracked`);
-            await service.addWorktree(wtDir, 'session/untracked', baseSha);
-            const scoped = service.forWorktree(wtDir);
-            await writeFile(join(wtDir, 'knowledge.md'), 'session version\n', 'utf-8');
-            await scoped.commitFile('knowledge.md', 'session write', 'System User', 'system@example.com');
-            await writeFile(join(tempDir, 'knowledge.md'), 'untracked local version\n', 'utf-8');
-            const result = await service.squashMergeIntoMain('session/untracked', 'System User', 'system@example.com', 'Memory capture: 1 file [chat=untracked]');
-            expect(result.ok).toBe(false);
-            if (result.ok) {
-                throw new Error('unreachable');
-            }
-            expect(result.conflict).toBe(true);
-            expect(result.conflictPaths).toEqual(['knowledge.md']);
-            const status = await service.git.status();
-            expect(status.not_added).toContain('knowledge.md');
-            await service.removeWorktree(wtDir).catch(() => undefined);
-            await rm(wtDir, { recursive: true, force: true }).catch(() => undefined);
-        });
-    });
-});

package/node_modules/@ktx/context/dist/core/index.d.ts

@@ -1,10 +0,0 @@
-export type { KtxCoreConfig, KtxGitConfig, KtxLogger, KtxStorageConfig } from './config.js';
-export { noopLogger, resolveConfigDir, resolveWorktreesDir } from './config.js';
-export { resolveKtxConfigReference, resolveKtxHomePath } from './config-reference.js';
-export type { KtxEmbeddingPort } from './embedding.js';
-export { REDACTED_KTX_CREDENTIAL_VALUE, redactKtxSensitiveMetadata, redactKtxSensitiveText, redactKtxSensitiveValue, } from './redaction.js';
-export type { KtxFileHistoryEntry, KtxFileListResult, KtxFileReadResult, KtxFileStorePort, KtxFileWriteResult, } from './file-store.js';
-export type { GitCommitInfo, SquashMergeResult, WorktreeEntry } from './git.service.js';
-export { GitService } from './git.service.js';
-export type { SentinelPayload, SessionOutcome, SessionWorktree, SessionWorktreeServiceDeps, WorktreeConfigPort, } from './session-worktree.service.js';
-export { SessionWorktreeService } from './session-worktree.service.js';

package/node_modules/@ktx/context/dist/core/index.js

@@ -1,5 +0,0 @@
-export { noopLogger, resolveConfigDir, resolveWorktreesDir } from './config.js';
-export { resolveKtxConfigReference, resolveKtxHomePath } from './config-reference.js';
-export { REDACTED_KTX_CREDENTIAL_VALUE, redactKtxSensitiveMetadata, redactKtxSensitiveText, redactKtxSensitiveValue, } from './redaction.js';
-export { GitService } from './git.service.js';
-export { SessionWorktreeService } from './session-worktree.service.js';

package/node_modules/@ktx/context/dist/core/redaction.d.ts

@@ -1,4 +0,0 @@
-export declare const REDACTED_KTX_CREDENTIAL_VALUE = "<redacted>";
-export declare function redactKtxSensitiveValue(key: string, value: unknown): unknown;
-export declare function redactKtxSensitiveMetadata(metadata: Record<string, unknown>): Record<string, unknown>;
-export declare function redactKtxSensitiveText(value: string): string;

package/node_modules/@ktx/context/dist/core/redaction.js

@@ -1,39 +0,0 @@
-export const REDACTED_KTX_CREDENTIAL_VALUE = '<redacted>';
-const SENSITIVE_FIELD_NAME = /(password|secret|token|api[_-]?key|private[_-]?key|passphrase|credential|authorization|url)/i;
-const URL_CREDENTIAL_PATTERN = /([a-z][a-z0-9+.-]*:\/\/[^:\s/@]+:)([^@\s/]+)(@)/gi;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isSensitiveField(key) {
-    return SENSITIVE_FIELD_NAME.test(key);
-}
-export function redactKtxSensitiveValue(key, value) {
-    if (isSensitiveField(key)) {
-        return REDACTED_KTX_CREDENTIAL_VALUE;
-    }
-    if (Array.isArray(value)) {
-        return value.map((item) => redactKtxSensitiveValue(key, item));
-    }
-    if (isRecord(value)) {
-        return redactKtxSensitiveMetadata(value);
-    }
-    return value;
-}
-export function redactKtxSensitiveMetadata(metadata) {
-    const redacted = {};
-    for (const [key, value] of Object.entries(metadata)) {
-        if (Array.isArray(value)) {
-            redacted[key] = value.map((item) => isRecord(item) ? redactKtxSensitiveMetadata(item) : redactKtxSensitiveValue(key, item));
-            continue;
-        }
-        if (isRecord(value)) {
-            redacted[key] = redactKtxSensitiveValue(key, value);
-            continue;
-        }
-        redacted[key] = redactKtxSensitiveValue(key, value);
-    }
-    return redacted;
-}
-export function redactKtxSensitiveText(value) {
-    return value.replace(URL_CREDENTIAL_PATTERN, `$1${REDACTED_KTX_CREDENTIAL_VALUE}$3`);
-}

package/node_modules/@ktx/context/dist/core/session-worktree.service.d.ts

@@ -1,38 +0,0 @@
-import { type KtxCoreConfig, type KtxLogger } from './config.js';
-import { GitService } from './git.service.js';
-export type SessionOutcome = 'success' | 'empty' | 'conflict' | 'crash';
-export interface SentinelPayload {
-    outcome: SessionOutcome;
-    at: string;
-    chatId: string;
-    baseSha: string;
-    conflictPaths?: string[];
-}
-export interface WorktreeConfigPort<TConfig> {
-    forWorktree(workdir: string): TConfig;
-}
-export interface SessionWorktree<TConfig> {
-    chatId: string;
-    workdir: string;
-    branch: string;
-    baseSha: string;
-    createdAt: Date;
-    git: GitService;
-    config: TConfig;
-}
-export interface SessionWorktreeServiceDeps<TConfig extends WorktreeConfigPort<TConfig>> {
-    coreConfig: KtxCoreConfig;
-    gitService: GitService;
-    configService: TConfig;
-    logger?: KtxLogger;
-}
-export declare class SessionWorktreeService<TConfig extends WorktreeConfigPort<TConfig> = WorktreeConfigPort<never>> {
-    private readonly deps;
-    private readonly logger;
-    private readonly worktreesRoot;
-    constructor(deps: SessionWorktreeServiceDeps<TConfig>);
-    create(sessionKey: string, baseSha: string): Promise<SessionWorktree<TConfig>>;
-    cleanup(session: SessionWorktree<TConfig>, outcome: SessionOutcome, extra?: {
-        conflictPaths?: string[];
-    }): Promise<void>;
-}

package/node_modules/@ktx/context/dist/core/session-worktree.service.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@ktx/context/dist/core/session-worktree.service.test.js

@@ -1,97 +0,0 @@
-import { mkdtemp, realpath, rm, stat } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { GitService } from './git.service.js';
-import { SessionWorktreeService } from './session-worktree.service.js';
-// SessionWorktreeService glues a real GitService to a scoped config adapter.
-describe('SessionWorktreeService', () => {
-    let sessionService;
-    let gitService;
-    let homeDir;
-    beforeEach(async () => {
-        homeDir = await mkdtemp(join(tmpdir(), 'sws-spec-'));
-        homeDir = await realpath(homeDir);
-        const coreConfig = {
-            storage: { configDir: homeDir, homeDir },
-            git: {
-                userName: 'System User',
-                userEmail: 'system@example.com',
-                bootstrapMessage: 'Initialize test config repo',
-                bootstrapAuthor: 'test-system',
-                bootstrapAuthorEmail: 'system@example.com',
-            },
-        };
-        gitService = new GitService(coreConfig);
-        await gitService.onModuleInit();
-        const configService = {
-            forWorktree: vi.fn((workdir) => ({ workdir, forWorktree: configService.forWorktree })),
-        };
-        sessionService = new SessionWorktreeService({
-            coreConfig,
-            gitService,
-            configService,
-        });
-    });
-    afterEach(async () => {
-        await rm(homeDir, { recursive: true, force: true });
-    });
-    describe('create', () => {
-        it('creates a worktree + branch and returns scoped services', async () => {
-            const baseSha = await gitService.revParseHead();
-            if (!baseSha) {
-                throw new Error('no base sha');
-            }
-            const session = await sessionService.create('chat-abc', baseSha);
-            expect(session.workdir).toBe(join(homeDir, '.worktrees', 'session-chat-abc'));
-            expect(session.branch).toBe('session/chat-abc');
-            expect(session.baseSha).toBe(baseSha);
-            const stats = await stat(session.workdir);
-            expect(stats.isDirectory()).toBe(true);
-            // Scoped git instance reports the worktree's HEAD (= baseSha at creation time).
-            expect(await session.git.revParseHead()).toBe(baseSha);
-            const list = await gitService.listWorktrees();
-            expect(list.find((e) => e.path === session.workdir)).toBeTruthy();
-        });
-        it('appends a timestamp suffix when the primary dir already exists', async () => {
-            const baseSha = await gitService.revParseHead();
-            if (!baseSha) {
-                throw new Error('no base sha');
-            }
-            const first = await sessionService.create('chat-dup', baseSha);
-            const second = await sessionService.create('chat-dup', baseSha);
-            expect(first.workdir).not.toBe(second.workdir);
-            expect(second.branch).toMatch(/^session\/chat-dup-\d+$/);
-        });
-    });
-    describe('cleanup', () => {
-        it('success removes the worktree dir and deletes the branch', async () => {
-            const baseSha = await gitService.revParseHead();
-            if (!baseSha) {
-                throw new Error('no base sha');
-            }
-            const session = await sessionService.create('chat-cleanup-ok', baseSha);
-            await sessionService.cleanup(session, 'success');
-            const list = await gitService.listWorktrees();
-            expect(list.find((e) => e.path === session.workdir)).toBeFalsy();
-            await expect(stat(session.workdir)).rejects.toThrow();
-        });
-        it('conflict keeps the worktree and writes a sentinel file', async () => {
-            const baseSha = await gitService.revParseHead();
-            if (!baseSha) {
-                throw new Error('no base sha');
-            }
-            const session = await sessionService.create('chat-cleanup-conflict', baseSha);
-            await sessionService.cleanup(session, 'conflict', { conflictPaths: ['shared.yaml'] });
-            // Dir still exists.
-            await expect(stat(session.workdir)).resolves.toBeTruthy();
-            const { readFile } = await import('node:fs/promises');
-            const raw = await readFile(join(session.workdir, '.ktx-outcome'), 'utf-8');
-            const parsed = JSON.parse(raw);
-            expect(parsed.outcome).toBe('conflict');
-            expect(parsed.chatId).toBe('chat-cleanup-conflict');
-            expect(parsed.conflictPaths).toEqual(['shared.yaml']);
-            expect(typeof parsed.at).toBe('string');
-        });
-    });
-});

package/node_modules/@ktx/context/dist/daemon/index.d.ts

@@ -1 +0,0 @@
-export * from './semantic-layer-compute.js';

package/node_modules/@ktx/context/dist/daemon/index.js

@@ -1 +0,0 @@
-export * from './semantic-layer-compute.js';

package/node_modules/@ktx/context/dist/daemon/semantic-layer-compute.d.ts

@@ -1,80 +0,0 @@
-import type { ResolvedSemanticLayerSource, SemanticLayerQueryInput } from '../sl/types.js';
-export interface KtxSemanticLayerComputeQueryResult {
-    sql: string;
-    dialect: string;
-    columns: Array<Record<string, unknown>>;
-    plan: Record<string, unknown>;
-}
-export interface KtxSemanticLayerComputeValidationResult {
-    valid: boolean;
-    errors: string[];
-    warnings: string[];
-    perSourceWarnings: Record<string, string[]>;
-}
-export interface KtxSemanticLayerSourceGenerationColumnInput {
-    name: string;
-    type: string;
-    primaryKey?: boolean;
-    nullable?: boolean;
-    comment?: string | null;
-}
-export interface KtxSemanticLayerSourceGenerationTableInput {
-    name: string;
-    catalog?: string | null;
-    db?: string | null;
-    comment?: string | null;
-    columns: KtxSemanticLayerSourceGenerationColumnInput[];
-}
-export interface KtxSemanticLayerSourceGenerationLinkInput {
-    fromTable: string;
-    fromColumn: string;
-    toTable: string;
-    toColumn: string;
-    relationshipType: string;
-}
-export interface KtxSemanticLayerSourceGenerationInput {
-    tables: KtxSemanticLayerSourceGenerationTableInput[];
-    links: KtxSemanticLayerSourceGenerationLinkInput[];
-    dialect?: string;
-}
-export interface KtxSemanticLayerSourceGenerationResult {
-    sources: Array<Record<string, unknown>>;
-    sourceCount: number;
-}
-export interface KtxSemanticLayerComputePort {
-    /**
-     * Callers must pass sources sanitized through toResolvedWire. The Python
-     * daemon rejects authoring-only fields such as usage and inherits_columns_from.
-     */
-    query(input: {
-        sources: ResolvedSemanticLayerSource[];
-        query: SemanticLayerQueryInput;
-        dialect: string;
-    }): Promise<KtxSemanticLayerComputeQueryResult>;
-    /**
-     * Callers must pass sources sanitized through toResolvedWire. The Python
-     * daemon rejects authoring-only fields such as usage and inherits_columns_from.
-     */
-    validateSources(input: {
-        sources: ResolvedSemanticLayerSource[];
-        dialect: string;
-        recentlyTouched?: string[];
-    }): Promise<KtxSemanticLayerComputeValidationResult>;
-    generateSources(input: KtxSemanticLayerSourceGenerationInput): Promise<KtxSemanticLayerSourceGenerationResult>;
-}
-export type KtxDaemonCommand = 'semantic-query' | 'semantic-validate' | 'semantic-generate-sources';
-export type KtxDaemonJsonRunner = (subcommand: KtxDaemonCommand, payload: Record<string, unknown>) => Promise<Record<string, unknown>>;
-export type KtxDaemonHttpJsonRunner = (path: string, payload: Record<string, unknown>) => Promise<Record<string, unknown>>;
-export interface PythonSemanticLayerComputeOptions {
-    command?: string;
-    args?: string[];
-    cwd?: string;
-    env?: NodeJS.ProcessEnv;
-    runJson?: KtxDaemonJsonRunner;
-}
-export interface HttpSemanticLayerComputeOptions {
-    baseUrl: string;
-    requestJson?: KtxDaemonHttpJsonRunner;
-}
-export declare function createPythonSemanticLayerComputePort(options?: PythonSemanticLayerComputeOptions): KtxSemanticLayerComputePort;
-export declare function createHttpSemanticLayerComputePort(options: HttpSemanticLayerComputeOptions): KtxSemanticLayerComputePort;