@kaelio/ktx 0.5.0 → 0.6.0

package/dist/context/memory/local-memory.test.d.ts

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

package/dist/context/memory/local-memory.test.js

@@ -1,173 +0,0 @@
-import { access, mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { initKtxProject } from '../../context/project/project.js';
-import { createLocalProjectMemoryIngest } from './local-memory.js';
-import { LocalMemoryRunStore } from './local-memory-runs.js';
-vi.mock('ai', () => ({
-    generateText: vi.fn().mockResolvedValue({ text: '', toolCalls: [] }),
-    stepCountIs: (stepBudget) => stepBudget,
-    tool: (definition) => definition,
-}));
-async function expectPathMissing(path) {
-    await expect(access(path)).rejects.toThrow();
-}
-describe('LocalMemoryRunStore', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-local-memory-runs-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('persists running, done, and reloadable memory run status in SQLite', async () => {
-        const store = new LocalMemoryRunStore({
-            projectDir: tempDir,
-            idFactory: () => 'memory-run-1',
-        });
-        const created = await store.createRunning({ inputHash: 'hash-1', chatId: 'chat-1' });
-        expect(created).toEqual({ id: 'memory-run-1' });
-        await store.markRunning('memory-run-1', 'capturing');
-        await store.markDone('memory-run-1', {
-            signalDetected: true,
-            actions: [{ target: 'wiki', type: 'created', key: 'revenue', detail: 'Revenue definition' }],
-            skillsLoaded: ['wiki_capture'],
-            commitHash: 'abc123',
-        });
-        await expect(access(join(tempDir, '.ktx/db.sqlite'))).resolves.toBeUndefined();
-        await expectPathMissing(join(tempDir, '.ktx/memory-runs/memory-run-1.json'));
-        await expect(store.findById('memory-run-1')).resolves.toMatchObject({
-            id: 'memory-run-1',
-            status: 'done',
-            stage: 'done',
-            inputHash: 'hash-1',
-            chatId: 'chat-1',
-            error: null,
-            outputSummary: {
-                signalDetected: true,
-                commitHash: 'abc123',
-            },
-        });
-        const reloaded = new LocalMemoryRunStore({ projectDir: tempDir });
-        await expect(reloaded.findById('memory-run-1')).resolves.toMatchObject({
-            id: 'memory-run-1',
-            status: 'done',
-            stage: 'done',
-            inputHash: 'hash-1',
-            chatId: 'chat-1',
-            outputSummary: {
-                actions: [{ target: 'wiki', type: 'created', key: 'revenue', detail: 'Revenue definition' }],
-                skillsLoaded: ['wiki_capture'],
-                signalDetected: true,
-                commitHash: 'abc123',
-            },
-        });
-    });
-});
-describe('createLocalProjectMemoryIngest', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-local-memory-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('warns when embeddings are configured but memory ingest is created without an embedding provider', async () => {
-        const project = await initKtxProject({ projectDir: tempDir });
-        project.config.ingest.embeddings = {
-            backend: 'openai',
-            model: 'text-embedding-3-small',
-            dimensions: 1536,
-        };
-        const logger = { log: vi.fn(), warn: vi.fn(), error: vi.fn() };
-        createLocalProjectMemoryIngest(project, {
-            agentRunner: { runLoop: vi.fn() },
-            logger: logger,
-        });
-        expect(logger.warn).toHaveBeenCalledWith('[memory-ingest] embeddings backend "openai" is configured but no embedding provider was passed; semantic search will fall back to a no-op embedding port.');
-    });
-    it('captures a wiki page through the local memory agent and persists pollable status', async () => {
-        const project = await initKtxProject({ projectDir: tempDir });
-        const agentRunner = {
-            runLoop: async ({ toolSet, }) => {
-                await toolSet.load_skill.execute({ name: 'wiki_capture' });
-                await toolSet.wiki_write.execute({
-                    key: 'revenue',
-                    summary: 'Revenue definition',
-                    content: 'Revenue means paid order value net of refunds.',
-                    tags: ['finance'],
-                }, { toolCallId: 'wiki-write' });
-                return { stopReason: 'natural' };
-            },
-        };
-        const ingest = createLocalProjectMemoryIngest(project, {
-            agentRunner: agentRunner,
-            runIdFactory: () => 'memory-run-1',
-        });
-        await expect(ingest.ingest({
-            userId: 'local-user',
-            chatId: 'chat-1',
-            userMessage: 'define revenue as paid order value net of refunds',
-            assistantMessage: 'Captured.',
-            sourceType: 'external_ingest',
-        })).resolves.toEqual({ runId: 'memory-run-1' });
-        await ingest.waitForRun('memory-run-1');
-        await expect(access(join(project.projectDir, '.ktx/db.sqlite'))).resolves.toBeUndefined();
-        await expectPathMissing(join(project.projectDir, '.ktx/memory-runs/memory-run-1.json'));
-        await expect(ingest.status('memory-run-1')).resolves.toMatchObject({
-            runId: 'memory-run-1',
-            status: 'done',
-            done: true,
-            captured: { wiki: ['revenue'], sl: [], xrefs: [] },
-            skillsLoaded: ['wiki_capture'],
-            signalDetected: true,
-        });
-        await expect(readFile(join(project.projectDir, 'wiki/global/revenue.md'), 'utf-8')).resolves.toContain('Revenue means paid order value net of refunds.');
-    });
-    it('captures a semantic-layer source for a named local connection id', async () => {
-        const project = await initKtxProject({ projectDir: tempDir });
-        project.config.connections.warehouse = { driver: 'postgres' };
-        const agentRunner = {
-            runLoop: async ({ toolSet, }) => {
-                await toolSet.load_skill.execute({ name: 'sl' });
-                await toolSet.sl_write_source.execute({
-                    connectionId: 'warehouse',
-                    sourceName: 'orders',
-                    source: {
-                        name: 'orders',
-                        table: 'public.orders',
-                        grain: ['id'],
-                        columns: [{ name: 'id', type: 'number' }],
-                        joins: [],
-                        measures: [{ name: 'order_count', expr: 'count(*)' }],
-                    },
-                }, { toolCallId: 'sl-write' });
-                return { stopReason: 'natural' };
-            },
-        };
-        const ingest = createLocalProjectMemoryIngest(project, {
-            agentRunner: agentRunner,
-            runIdFactory: () => 'memory-run-2',
-        });
-        await ingest.ingest({
-            userId: 'local-user',
-            chatId: 'chat-2',
-            userMessage: 'going forward define orders count as count of public orders',
-            assistantMessage: 'Captured.',
-            connectionId: 'warehouse',
-            sourceType: 'external_ingest',
-        });
-        await ingest.waitForRun('memory-run-2');
-        await expect(access(join(project.projectDir, '.ktx/db.sqlite'))).resolves.toBeUndefined();
-        await expectPathMissing(join(project.projectDir, '.ktx/memory-runs/memory-run-2.json'));
-        await expect(ingest.status('memory-run-2')).resolves.toMatchObject({
-            runId: 'memory-run-2',
-            status: 'done',
-            captured: { wiki: [], sl: ['orders'], xrefs: [] },
-            skillsLoaded: ['sl'],
-            signalDetected: true,
-        });
-        await expect(readFile(join(project.projectDir, 'semantic-layer/warehouse/orders.yaml'), 'utf-8')).resolves.toContain('order_count');
-    });
-});

package/dist/context/memory/memory-agent.service.ingest.test.d.ts

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

package/dist/context/memory/memory-agent.service.ingest.test.js

@@ -1,355 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-// Module-level mock for 'ai' so generateText is a stub. This file is separate from
-// memory-agent.service.spec.ts so the existing pure-helper tests don't load the mock.
-vi.mock('ai', () => ({
-    generateText: vi.fn().mockResolvedValue({ text: '', toolCalls: [] }),
-    stepCountIs: (n) => n,
-    tool: (def) => def,
-}));
-// Imported AFTER vi.mock so the mocked module is used.
-import { generateText } from 'ai';
-import { SYSTEM_GIT_AUTHOR } from '../../context/tools/authors.js';
-import { MemoryAgentService } from './memory-agent.service.js';
-const buildMocks = (overrides = {}) => {
-    const scopedConfig = { writeFile: vi.fn(), deleteFile: vi.fn() };
-    const scopedGit = { revParseHead: vi.fn().mockResolvedValue('basesha') };
-    const sessionWorktree = {
-        chatId: 'chat-1',
-        workdir: '/tmp/wt/session-chat-1',
-        branch: 'session/chat-1',
-        baseSha: 'basesha',
-        createdAt: new Date(),
-        git: scopedGit,
-        config: scopedConfig,
-    };
-    const defaults = {
-        appSettings: {
-            settings: {
-                ai: {
-                    knowledge: { userScopedKnowledgeEnabled: false },
-                    slValidation: { probeRowCount: 1 },
-                },
-                llm: { memoryIngestionModel: 'test-model' },
-            },
-        },
-        prompt: { loadPrompt: vi.fn().mockResolvedValue('base framing') },
-        eventTracker: { trackEvent: vi.fn(), createTelemetryIntegration: vi.fn().mockReturnValue(undefined) },
-        telemetry: {
-            isEnabled: () => false,
-            appSettingsService: { settings: { telemetry: { recordInputs: false, recordOutputs: false } } },
-            systemConfigService: { config: { instance: { name: 'test-instance' } } },
-        },
-        skillsRegistry: {
-            listSkills: vi.fn().mockResolvedValue([]),
-            buildSkillsPrompt: vi.fn().mockReturnValue(''),
-            getSkill: vi.fn(),
-            stripFrontmatter: vi.fn(),
-        },
-        wikiService: {
-            forWorktree: vi.fn().mockReturnThis(),
-            readPage: vi.fn(),
-            syncSinglePage: vi.fn(),
-            deleteFromIndex: vi.fn(),
-        },
-        indexRepository: { listPagesForUser: vi.fn().mockResolvedValue([]) },
-        knowledgeSlRefsRepository: { syncFromWiki: vi.fn().mockResolvedValue({ inserted: 0, deleted: 0 }) },
-        knowledgeRepository: {},
-        embeddingService: { computeEmbedding: vi.fn() },
-        semanticLayerService: {
-            forWorktree: vi.fn().mockReturnThis(),
-            loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
-            readSourceFile: vi.fn(),
-        },
-        slSearchService: { indexSources: vi.fn(), buildSearchText: vi.fn() },
-        dataSourcesService: {
-            listEnabledConnections: vi.fn().mockResolvedValue([]),
-            getConnectionById: vi.fn().mockResolvedValue({
-                id: 'conn-1',
-                name: 'Warehouse',
-                connectionType: 'POSTGRESQL',
-            }),
-            executeQuery: vi.fn(),
-        },
-        configService: {
-            enqueueCommitMessageJobForExternalCommit: vi.fn().mockResolvedValue(undefined),
-            writeFile: vi.fn(),
-            deleteFile: vi.fn(),
-        },
-        gitService: {
-            revParseHead: vi.fn().mockResolvedValue('basesha'),
-            squashMergeIntoMain: vi.fn().mockResolvedValue({ ok: true, squashSha: 'cafebabe', touchedPaths: ['a.yaml'] }),
-        },
-        lockingService: {
-            withLock: vi.fn().mockImplementation((_key, fn) => fn()),
-        },
-        slSourcesRepository: { deleteByConnectionAndName: vi.fn() },
-        sessionWorktreeService: {
-            create: vi.fn().mockResolvedValue(sessionWorktree),
-            cleanup: vi.fn().mockResolvedValue(undefined),
-        },
-        semanticLayerSourceReconciler: { upsertRow: vi.fn() },
-        agentRunner: { runLoop: vi.fn().mockResolvedValue({ stopReason: 'natural' }) },
-        slValidator: { validateSingleSource: vi.fn().mockResolvedValue({ errors: [], warnings: [] }) },
-        toolsetFactory: {
-            createIngestWuToolset: vi.fn().mockReturnValue({
-                toRuntimeTools: vi.fn().mockReturnValue({}),
-                getAllTools: vi.fn().mockReturnValue([]),
-            }),
-            createToolset: vi.fn().mockReturnValue({
-                toRuntimeTools: vi.fn().mockReturnValue({}),
-                getAllTools: vi.fn().mockReturnValue([]),
-            }),
-        },
-        logger: { log: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-    };
-    return { ...defaults, ...overrides };
-};
-const buildService = (mocks) => new MemoryAgentService({
-    settings: {
-        knowledge: {
-            userScopedKnowledgeEnabled: mocks.appSettings.settings.ai.knowledge.userScopedKnowledgeEnabled,
-        },
-        slValidation: {
-            probeRowCount: mocks.appSettings.settings.ai.slValidation.probeRowCount,
-        },
-        llm: {
-            memoryIngestionModel: mocks.appSettings.settings.llm.memoryIngestionModel,
-        },
-    },
-    promptService: mocks.prompt,
-    skillsRegistry: mocks.skillsRegistry,
-    wikiService: mocks.wikiService,
-    knowledgeIndex: mocks.indexRepository,
-    knowledgeSlRefs: mocks.knowledgeSlRefsRepository,
-    semanticLayerService: mocks.semanticLayerService,
-    slSearchService: mocks.slSearchService,
-    connections: {
-        listEnabledConnections: vi.fn().mockResolvedValue([]),
-        getConnectionById: mocks.dataSourcesService.getConnectionById ??
-            vi.fn().mockResolvedValue({
-                id: 'conn-1',
-                name: 'Warehouse',
-                connectionType: 'POSTGRESQL',
-            }),
-        executeQuery: mocks.dataSourcesService.executeQuery,
-    },
-    rootFileStore: mocks.configService,
-    gitService: mocks.gitService,
-    lockingService: mocks.lockingService,
-    slSourcesRepository: mocks.slSourcesRepository,
-    sessionWorktreeService: mocks.sessionWorktreeService,
-    semanticLayerSourceReconciler: mocks.semanticLayerSourceReconciler,
-    agentRunner: mocks.agentRunner,
-    slValidator: mocks.slValidator,
-    toolsetFactory: mocks.toolsetFactory,
-    telemetry: {
-        trackMemoryIngestion: mocks.eventTracker.trackEvent,
-    },
-    logger: mocks.logger,
-});
-const baseInput = {
-    userId: 'u1',
-    chatId: 'chat-1',
-    // Long enough + with a definition keyword so the prefilter doesn't skip.
-    userMessage: 'going forward exclude cancelled orders from revenue, this is the canonical definition',
-};
-const generateTextMock = vi.mocked(generateText);
-beforeEach(() => {
-    generateTextMock.mockReset();
-    generateTextMock.mockResolvedValue({ text: '', toolCalls: [] });
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-});
-describe('MemoryAgentService.ingest — session-branch orchestration', () => {
-    it('happy path: creates worktree, runs LLM loop, squash-merges, enqueues note, cleans up', async () => {
-        const mocks = buildMocks();
-        const svc = buildService(mocks);
-        const result = await svc.ingest(baseInput);
-        // Phase 1: session worktree was created from main's HEAD.
-        expect(mocks.sessionWorktreeService.create).toHaveBeenCalledWith('chat-1', 'basesha');
-        // Phase 2: LLM loop ran with the assembled tools/system/prompt.
-        expect(mocks.agentRunner.runLoop).toHaveBeenCalledOnce();
-        // Phase 3: squash-merged onto main.
-        expect(mocks.gitService.squashMergeIntoMain).toHaveBeenCalledWith('session/chat-1', SYSTEM_GIT_AUTHOR.name, SYSTEM_GIT_AUTHOR.email, expect.stringContaining('[chat=chat-1]'));
-        // Note enqueue happened on the ROOT configService, not the scoped one. The single
-        // touched path is passed as the diff scope.
-        expect(mocks.configService.enqueueCommitMessageJobForExternalCommit).toHaveBeenCalledWith({ commitHash: 'cafebabe' }, expect.stringContaining('[chat=chat-1]'), 'a.yaml');
-        // Cleanup ran with success.
-        expect(mocks.sessionWorktreeService.cleanup).toHaveBeenCalledWith(expect.objectContaining({ chatId: 'chat-1' }), 'success', expect.any(Object));
-        expect(result.commitHash).toBe('cafebabe');
-    });
-    it('normalizes load_skill output to markdown while preserving structured payload', async () => {
-        const tempDir = await mkdtemp(join(tmpdir(), 'ktx-memory-skill-'));
-        const skillDir = join(tempDir, 'memory_agent');
-        await mkdir(skillDir, { recursive: true });
-        await writeFile(join(skillDir, 'SKILL.md'), '---\nname: memory_agent\n---\nSkill body', 'utf-8');
-        try {
-            const agentRunner = {
-                runLoop: vi.fn(async (params) => {
-                    const result = await params.toolSet.load_skill.execute({ name: 'memory_agent' });
-                    expect(result.markdown).toContain('memory_agent');
-                    expect(result.structured).toMatchObject({ name: 'memory_agent' });
-                    return { stopReason: 'natural' };
-                }),
-            };
-            const mocks = buildMocks({
-                agentRunner,
-                skillsRegistry: {
-                    listSkills: vi.fn().mockResolvedValue([{ name: 'memory_agent', path: skillDir }]),
-                    buildSkillsPrompt: vi.fn().mockReturnValue(''),
-                    getSkill: vi.fn().mockResolvedValue({ name: 'memory_agent', path: skillDir }),
-                    stripFrontmatter: vi.fn().mockReturnValue('Skill body'),
-                },
-            });
-            const svc = buildService(mocks);
-            await svc.ingest(baseInput);
-            expect(agentRunner.runLoop).toHaveBeenCalled();
-        }
-        finally {
-            await rm(tempDir, { recursive: true, force: true });
-        }
-    });
-    it('logs prompt debug output when KTX_MEMORY_AGENT_DEBUG_PROMPTS is enabled', async () => {
-        const previousDebugPrompts = process.env.KTX_MEMORY_AGENT_DEBUG_PROMPTS;
-        const mocks = buildMocks();
-        const svc = buildService(mocks);
-        try {
-            process.env.KTX_MEMORY_AGENT_DEBUG_PROMPTS = '1';
-            await svc.ingest(baseInput);
-            expect(mocks.logger.debug).toHaveBeenCalledWith(expect.stringContaining('[memory-agent prompt-debug] system='));
-            expect(mocks.logger.debug).toHaveBeenCalledWith(expect.stringContaining('[memory-agent prompt-debug] user='));
-        }
-        finally {
-            if (previousDebugPrompts === undefined) {
-                delete process.env.KTX_MEMORY_AGENT_DEBUG_PROMPTS;
-            }
-            else {
-                process.env.KTX_MEMORY_AGENT_DEBUG_PROMPTS = previousDebugPrompts;
-            }
-        }
-    });
-    it('empty path: squash returns no touched paths → no enqueue, cleanup(empty), commitHash=null', async () => {
-        const mocks = buildMocks();
-        mocks.gitService.squashMergeIntoMain.mockResolvedValue({
-            ok: true,
-            squashSha: 'basesha',
-            touchedPaths: [],
-        });
-        const svc = buildService(mocks);
-        const result = await svc.ingest(baseInput);
-        expect(mocks.configService.enqueueCommitMessageJobForExternalCommit).not.toHaveBeenCalled();
-        expect(mocks.sessionWorktreeService.cleanup).toHaveBeenCalledWith(expect.any(Object), 'empty', expect.any(Object));
-        expect(result.commitHash).toBeNull();
-    });
-    it('conflict path: rolls back DB, cleanup(conflict, conflictPaths), returns commitHash=null with empty actions', async () => {
-        const mocks = buildMocks();
-        mocks.gitService.squashMergeIntoMain.mockResolvedValue({
-            ok: false,
-            conflict: true,
-            conflictPaths: ['semantic-layer/conn-x/fct_intakes.yaml'],
-        });
-        // Have the wikiService report a still-existing page in main, so rollback re-syncs.
-        mocks.wikiService.readPage.mockResolvedValue({
-            pageKey: 'phantom',
-            frontmatter: { summary: 'x', usage_mode: 'auto' },
-            content: 'body',
-        });
-        const svc = buildService(mocks);
-        const result = await svc.ingest(baseInput);
-        expect(mocks.gitService.squashMergeIntoMain).toHaveBeenCalled();
-        // Cleanup got the conflict outcome + the paths.
-        expect(mocks.sessionWorktreeService.cleanup).toHaveBeenCalledWith(expect.any(Object), 'conflict', {
-            conflictPaths: ['semantic-layer/conn-x/fct_intakes.yaml'],
-        });
-        expect(mocks.configService.enqueueCommitMessageJobForExternalCommit).not.toHaveBeenCalled();
-        expect(result.commitHash).toBeNull();
-        expect(result.actions).toEqual([]);
-    });
-    it('crash path: post-loop step throws → cleanup(crash), commitHash=null', async () => {
-        const mocks = buildMocks();
-        // Force the cross-ref reconciler to throw, escaping into the outer try/catch and
-        // landing in the crash branch.
-        mocks.knowledgeSlRefsRepository.syncFromWiki.mockRejectedValue(new Error('db down'));
-        // squashMergeIntoMain shouldn't even be reached.
-        mocks.gitService.squashMergeIntoMain.mockRejectedValue(new Error('should not be called after crash'));
-        // Need a wiki action to trigger the cross-ref code path. Easiest: have the LLM mock
-        // not push actions, so syncFromWiki is never called and crash won't happen here.
-        // Instead, force the squash to throw.
-        mocks.knowledgeSlRefsRepository.syncFromWiki.mockResolvedValue({ inserted: 0, deleted: 0 });
-        mocks.gitService.squashMergeIntoMain.mockRejectedValue(new Error('git crashed'));
-        const svc = buildService(mocks);
-        const result = await svc.ingest(baseInput);
-        expect(mocks.sessionWorktreeService.cleanup).toHaveBeenCalledWith(expect.any(Object), 'crash', expect.any(Object));
-        expect(result.commitHash).toBeNull();
-    });
-});
-describe('MemoryAgentService.ingest — concurrency regression', () => {
-    it('two parallel ingest() calls produce distinct squash commits (no absorption)', async () => {
-        // FIFO lock: each acquisition chains onto the previous holder's release. This is the
-        // same shape as production withLock — the test asserts that two parallel ingests
-        // sequence both their phase-1 (worktree create) and phase-3 (squash merge) calls
-        // without deadlocking, and produce distinct commits.
-        let chain = Promise.resolve();
-        const lockingService = {
-            withLock: vi.fn().mockImplementation(async (_key, fn) => {
-                const previous = chain;
-                let releaseMe;
-                chain = new Promise((resolve) => {
-                    releaseMe = resolve;
-                });
-                await previous;
-                try {
-                    return await fn();
-                }
-                finally {
-                    releaseMe();
-                }
-            }),
-        };
-        let createCount = 0;
-        const sessionWorktreeService = {
-            create: vi.fn().mockImplementation((chatId) => {
-                createCount += 1;
-                return Promise.resolve({
-                    chatId,
-                    workdir: `/tmp/wt/session-${chatId}`,
-                    branch: `session/${chatId}`,
-                    baseSha: 'basesha',
-                    createdAt: new Date(),
-                    git: { revParseHead: vi.fn().mockResolvedValue('basesha') },
-                    config: { writeFile: vi.fn() },
-                });
-            }),
-            cleanup: vi.fn().mockResolvedValue(undefined),
-        };
-        let mergeCount = 0;
-        const gitService = {
-            revParseHead: vi.fn().mockResolvedValue('basesha'),
-            squashMergeIntoMain: vi.fn().mockImplementation(() => {
-                mergeCount += 1;
-                return Promise.resolve({
-                    ok: true,
-                    squashSha: `sha-${mergeCount}`,
-                    touchedPaths: [`${mergeCount}.yaml`],
-                });
-            }),
-        };
-        const mocksA = buildMocks({ lockingService, sessionWorktreeService, gitService });
-        const mocksB = buildMocks({ lockingService, sessionWorktreeService, gitService });
-        const svcA = buildService(mocksA);
-        const svcB = buildService(mocksB);
-        const [a, b] = await Promise.all([
-            svcA.ingest({ ...baseInput, chatId: 'chat-A' }),
-            svcB.ingest({ ...baseInput, chatId: 'chat-B' }),
-        ]);
-        expect(createCount).toBe(2);
-        expect(gitService.squashMergeIntoMain).toHaveBeenCalledTimes(2);
-        expect(a.commitHash).not.toBeNull();
-        expect(b.commitHash).not.toBeNull();
-        expect(a.commitHash).not.toBe(b.commitHash);
-    });
-});

package/dist/context/memory/memory-agent.service.test.d.ts

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