@namzu/sdk 14.0.6 → 15.0.0

package/src/rag/__tests__/namespace-isolation.test.ts

@@ -1,109 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { EmbeddingProvider, TenantScope } from '../../types/rag/index.js'
-import { DefaultIngestionPipeline } from '../ingestion.js'
-import { DefaultRetriever } from '../retriever.js'
-import { InMemoryVectorStore } from '../vector-store.js'
-
-/**
- * `TenantScope.namespace` and `KnowledgeBaseConfig.namespace` were declared
- * from the start and neither reached storage. Ingestion copied
- * `scope.tenantId` onto every chunk and dropped the namespace; the store
- * filtered on tenant alone. So a partition a host asked for did not exist,
- * and every namespace in a tenant saw every other one's documents.
- */
-
-/** Deterministic and content-derived, so similarity is stable across runs. */
-const embedder: EmbeddingProvider = {
-	async embed(texts: string[]) {
-		return texts.map((t) => [t.length % 7, t.charCodeAt(0) % 5, 1])
-	},
-	async embedQuery(text: string) {
-		return [text.length % 7, text.charCodeAt(0) % 5, 1]
-	},
-	dimensions: 3,
-	model: 'test-embedder',
-	id: 'test-embedder',
-}
-
-const tenant = 'tnt_one' as TenantScope['tenantId']
-
-function scope(namespace?: string): TenantScope {
-	return { tenantId: tenant, ...(namespace !== undefined ? { namespace } : {}) }
-}
-
-async function seed() {
-	const store = new InMemoryVectorStore()
-	const ingestion = new DefaultIngestionPipeline(store, embedder)
-	const kb = 'kb_one' as never
-
-	await ingestion.ingest('alpha partition content', {}, scope('alpha'), kb)
-	await ingestion.ingest('beta partition content', {}, scope('beta'), kb)
-	await ingestion.ingest('default partition content', {}, scope(), kb)
-
-	return { store, retriever: new DefaultRetriever(store, embedder), kb }
-}
-
-const texts = (r: { chunks: { chunk: { content: string } }[] }) =>
-	r.chunks.map((c) => c.chunk.content)
-
-describe('a namespace partitions what a query can see', () => {
-	it('returns only its own partition', async () => {
-		const { retriever, kb } = await seed()
-
-		const found = await retriever.retrieve({ text: 'partition content' }, scope('alpha'), kb)
-
-		expect(texts(found)).toEqual(['alpha partition content'])
-	})
-
-	it('does not leak the other partition', async () => {
-		const { retriever, kb } = await seed()
-
-		const found = await retriever.retrieve({ text: 'partition content' }, scope('beta'), kb)
-
-		expect(texts(found).join()).not.toContain('alpha')
-	})
-
-	it('treats an absent namespace as the default partition, not as no filter', async () => {
-		const { retriever, kb } = await seed()
-
-		const found = await retriever.retrieve({ text: 'partition content' }, scope(), kb)
-
-		// The whole point. Reading absence as "no filter" is how the boundary
-		// leaks: a caller who never asked for a namespace would see every
-		// namespaced chunk in the tenant.
-		expect(texts(found)).toEqual(['default partition content'])
-	})
-
-	it('keeps tenants apart as it always did', async () => {
-		const { retriever, kb } = await seed()
-
-		const found = await retriever.retrieve(
-			{ text: 'partition content' },
-			{
-				tenantId: 'tnt_other' as TenantScope['tenantId'],
-				namespace: 'alpha',
-			},
-			kb,
-		)
-
-		expect(found.chunks).toEqual([])
-	})
-
-	it('stamps the namespace onto the chunk at ingest', async () => {
-		const { store } = await seed()
-
-		const results = await store.search({
-			embedding: await embedder.embedQuery('partition content'),
-			topK: 10,
-			tenantId: tenant,
-			namespace: 'alpha',
-		})
-
-		// Ingest is where it has to land — filtering at search against a value
-		// nothing writes returns zero rows, and "no results" reads as "nothing
-		// matched" rather than "this scope was never stored".
-		expect(results.every((r) => r.chunk.content.startsWith('alpha'))).toBe(true)
-		expect(results.length).toBeGreaterThan(0)
-	})
-})

package/src/rag/__tests__/retrieval-math.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { TextChunker, splitKeepingSeparator } from '../chunking.js'
-
-/**
- * Retrieval arithmetic, pinned by the counterexample that proves each
- * defect. Every test here fails against the previous formula.
- */
-
-describe('splitKeepingSeparator', () => {
-	it('does not delete the separator it split on', () => {
-		// `'A. B. C.'.split('. ')` returns ['A','B','C.'] — the sentence
-		// terminators are gone, so the retrieved chunk no longer says what
-		// the document said.
-		expect(splitKeepingSeparator('A. B. C.', '. ')).toEqual(['A. ', 'B. ', 'C.'])
-	})
-
-	it('reconstructs the input exactly', () => {
-		const text = 'First para.\n\nSecond para.\n\nThird.'
-		expect(splitKeepingSeparator(text, '\n\n').join('')).toBe(text)
-	})
-
-	it('handles a trailing separator without emitting an empty tail', () => {
-		expect(splitKeepingSeparator('a\n\nb\n\n', '\n\n')).toEqual(['a\n\n', 'b\n\n'])
-	})
-
-	it('returns the whole text when the separator is absent', () => {
-		expect(splitKeepingSeparator('no breaks here', '\n\n')).toEqual(['no breaks here'])
-	})
-
-	it('handles consecutive separators', () => {
-		const text = 'a\n\n\n\nb'
-		expect(splitKeepingSeparator(text, '\n\n').join('')).toBe(text)
-	})
-})
-
-describe('TextChunker preserves the source text', () => {
-	it('keeps sentence terminators in recursive chunks', () => {
-		// The seam, not the helper: the chunker used `text.split(sep)`, so a
-		// recursive split on '. ' returned chunks with the periods removed.
-		const text = `${'Alpha beta gamma. '.repeat(20)}Delta epsilon zeta.`
-		const chunks = new TextChunker().chunk(text, {
-			strategy: 'recursive',
-			chunkSize: 100,
-			chunkOverlap: 0,
-		})
-
-		expect(chunks.length).toBeGreaterThan(1)
-		// Every sentence in a chunk still ends the way the document did.
-		const joined = chunks.map((c) => c.content).join(' ')
-		expect(joined).toContain('Alpha beta gamma.')
-		expect(joined).not.toContain('Alpha beta gamma Alpha')
-	})
-})

package/src/rag/chunking.test.ts

@@ -1,107 +0,0 @@
-/**
- * Current-code invariants asserted (2026-04-21, ses_006 Phase 4):
- *
- *   - `TextChunker.chunk(content, config)` dispatches by
- *     `config.strategy`. Unknown strategy hits an exhaustive-check
- *     throw (unreachable via types).
- *   - `fixed` strategy: slides a window of `chunkSize` by
- *     `chunkSize − chunkOverlap` (min 1) and emits trimmed non-empty
- *     slices. Indices are 0-based and contiguous.
- *   - `sentence` / `paragraph` strategies split by their separator
- *     sets and then merge small parts until the budget fills.
- *   - `recursive` strategy: short content returns as a single chunk;
- *     otherwise it splits by the first separator that produces >1
- *     parts, merges, and recurses into parts that still exceed
- *     `chunkSize`. Falls back to `fixed` when no separator splits.
- *   - Overlap is applied in `mergeSmallParts` via
- *     `current.slice(current.length - chunkOverlap) + part`.
- */
-
-import { describe, expect, it } from 'vitest'
-
-import type { ChunkingConfig } from '../types/rag/index.js'
-
-import { TextChunker } from './chunking.js'
-
-const chunker = new TextChunker()
-
-describe('TextChunker — fixed', () => {
-	const fixed: ChunkingConfig = { strategy: 'fixed', chunkSize: 10, chunkOverlap: 2 }
-
-	it('emits trimmed non-empty slices with contiguous indices', () => {
-		const result = chunker.chunk('0123456789abcdefghij', fixed)
-		expect(result).toHaveLength(3)
-		expect(result.map((c) => c.index)).toEqual([0, 1, 2])
-	})
-
-	it('skips whitespace-only slices', () => {
-		const result = chunker.chunk('abc           def', {
-			strategy: 'fixed',
-			chunkSize: 5,
-			chunkOverlap: 0,
-		})
-		expect(result.map((c) => c.content)).not.toContain('')
-	})
-
-	it('clamps step to at least 1 when overlap >= chunkSize', () => {
-		const result = chunker.chunk('abcdefghij', {
-			strategy: 'fixed',
-			chunkSize: 3,
-			chunkOverlap: 3,
-		})
-		// step = max(1, 3-3) = 1; eagerly emits many overlapping slices
-		expect(result.length).toBeGreaterThan(1)
-	})
-})
-
-describe('TextChunker — sentence', () => {
-	it('splits by sentence separators and merges up to the budget', () => {
-		const result = chunker.chunk('First sentence. Second sentence. Third sentence.', {
-			strategy: 'sentence',
-			chunkSize: 100,
-			chunkOverlap: 0,
-		})
-		expect(result.length).toBeGreaterThanOrEqual(1)
-		expect(result[0]?.content).toContain('First sentence')
-	})
-})
-
-describe('TextChunker — paragraph', () => {
-	it('splits by paragraph separators', () => {
-		const result = chunker.chunk('para one\n\npara two\n\npara three', {
-			strategy: 'paragraph',
-			chunkSize: 200,
-			chunkOverlap: 0,
-		})
-		expect(result.length).toBeGreaterThanOrEqual(1)
-	})
-})
-
-describe('TextChunker — recursive', () => {
-	it('short content fits into a single chunk', () => {
-		const result = chunker.chunk('tiny', {
-			strategy: 'recursive',
-			chunkSize: 100,
-			chunkOverlap: 0,
-		})
-		expect(result).toEqual([{ content: 'tiny', index: 0 }])
-	})
-
-	it('long content recursively splits to stay within chunkSize', () => {
-		const content = 'paragraph one. more text.\n\nparagraph two. more.'
-		const result = chunker.chunk(content, {
-			strategy: 'recursive',
-			chunkSize: 30,
-			chunkOverlap: 0,
-		})
-		for (const c of result) {
-			expect(c.content.length).toBeLessThanOrEqual(30)
-		}
-	})
-
-	it('empty or whitespace-only content yields empty result', () => {
-		expect(chunker.chunk('   ', { strategy: 'recursive', chunkSize: 10, chunkOverlap: 0 })).toEqual(
-			[],
-		)
-	})
-})

package/src/rag/context-assembler.test.ts

@@ -1,114 +0,0 @@
-/**
- * Current-code invariants asserted (2026-04-21, ses_006 Phase 4):
- *
- *   - `assembleRAGContext([], cfg)` returns `{content: '', sources: [],
- *     tokenCount: 0}` immediately.
- *   - Token estimation: `Math.ceil(text.length / 4)`.
- *   - `headerTemplate` is prepended before any chunks.
- *   - Chunks are included in order while their accumulated token count
- *     stays below `maxTokens`; the first chunk that would overflow is
- *     dropped along with every subsequent chunk (early break).
- *   - `includeMetadata: true` prefixes each chunk with a bracketed
- *     metadata line (`Source: …`, `Title: …`, `Relevance: XX.X%`).
- *   - `sources[]` captures a truncated preview (first 200 chars) of
- *     each INCLUDED chunk; skipped chunks are NOT present.
- *   - `content` is the joined parts with `config.separator`;
- *     `tokenCount` is re-estimated from the joined content.
- */
-
-import { describe, expect, it } from 'vitest'
-
-import type { ChunkId, DocumentId, KnowledgeBaseId, TenantId } from '../types/ids/index.js'
-import type { VectorSearchResult } from '../types/rag/index.js'
-
-import { assembleRAGContext } from './context-assembler.js'
-
-function result(
-	content: string,
-	score = 0.9,
-	meta: Record<string, unknown> = {},
-): VectorSearchResult {
-	return {
-		chunk: {
-			id: `c_${content.slice(0, 3)}` as ChunkId,
-			documentId: 'doc_1' as DocumentId,
-			knowledgeBaseId: 'kb_1' as KnowledgeBaseId,
-			tenantId: 't_1' as TenantId,
-			content,
-			index: 0,
-			tokenCount: 0,
-			metadata: meta,
-			createdAt: 0,
-		},
-		score,
-	}
-}
-
-describe('assembleRAGContext', () => {
-	it('returns empty for empty input', () => {
-		expect(assembleRAGContext([])).toEqual({ content: '', sources: [], tokenCount: 0 })
-	})
-
-	it('joins non-empty chunks with the configured separator', () => {
-		const ctx = assembleRAGContext([result('alpha'), result('beta')], {
-			separator: ' | ',
-			maxTokens: 1000,
-			includeMetadata: false,
-			headerTemplate: undefined,
-		})
-		expect(ctx.content).toBe('alpha | beta')
-	})
-
-	it('includes a headerTemplate before chunks when provided', () => {
-		const ctx = assembleRAGContext([result('body')], {
-			separator: '\n',
-			maxTokens: 1000,
-			includeMetadata: false,
-			headerTemplate: '### Knowledge',
-		})
-		expect(ctx.content.startsWith('### Knowledge\n')).toBe(true)
-	})
-
-	it('early-breaks once a chunk would overflow maxTokens (and drops subsequent)', () => {
-		const long = 'a'.repeat(200) // ~50 tokens per the /4 estimate
-		const ctx = assembleRAGContext([result('tiny'), result(long), result('also-tiny')], {
-			separator: '\n',
-			maxTokens: 20,
-			includeMetadata: false,
-			headerTemplate: undefined,
-		})
-		expect(ctx.content).toBe('tiny')
-		// third chunk was NOT included even though it would fit — the loop breaks on first overflow.
-		expect(ctx.sources.map((s) => s.chunk.slice(0, 10))).toEqual(['tiny'])
-	})
-
-	it('includeMetadata prefixes entries with bracketed metadata', () => {
-		const ctx = assembleRAGContext([result('body', 0.7567, { source: 'repo', title: 'README' })], {
-			separator: '\n',
-			maxTokens: 1000,
-			includeMetadata: true,
-		})
-		expect(ctx.content).toContain('[Source: repo | Title: README | Relevance: 75.7%]')
-	})
-
-	it('sources[] carries the first 200 chars of each included chunk', () => {
-		const long = 'x'.repeat(500)
-		const ctx = assembleRAGContext([result(long)], {
-			separator: '\n',
-			maxTokens: 10000,
-			includeMetadata: false,
-		})
-		expect(ctx.sources[0]?.chunk).toHaveLength(200)
-	})
-
-	it('tokenCount is derived from the final joined content', () => {
-		const ctx = assembleRAGContext([result('abcd'), result('efgh')], {
-			separator: '',
-			maxTokens: 1000,
-			includeMetadata: false,
-			headerTemplate: undefined,
-		})
-		// 'abcdefgh' → Math.ceil(8 / 4) = 2
-		expect(ctx.tokenCount).toBe(2)
-	})
-})

package/src/rag/embedding.test.ts

@@ -1,185 +0,0 @@
-/**
- * Current-code invariants asserted (2026-04-21, ses_006 Phase 4):
- *
- *   - `HttpEmbeddingProvider`:
- *     - Defaults: dimensions = 1536; baseUrl = openrouter.ai/api/v1;
- *       batchSize = 64.
- *     - `embed(texts)` batches into `batchSize` slices and concatenates
- *       results in input order.
- *     - Each HTTP call posts `{model, input, dimensions}` to
- *       `${baseUrl}/embeddings` with the Bearer authorization header.
- *     - The API response is sorted by `index` ascending before extracting
- *       `.embedding`, so results match input order even if the server
- *       re-orders.
- *     - `embedQuery(query)` returns the first result from `embed([query])`;
- *       throws when the response is empty.
- *     - `!response.ok` → throws with `Embedding API error (<status>): <body>`.
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { HttpEmbeddingProvider } from './embedding.js'
-
-describe('HttpEmbeddingProvider', () => {
-	let fetchMock: ReturnType<typeof vi.fn>
-
-	beforeEach(() => {
-		fetchMock = vi.fn()
-		global.fetch = fetchMock as unknown as typeof fetch
-	})
-
-	afterEach(() => {
-		vi.restoreAllMocks()
-	})
-
-	it('carries model / dimensions defaults + batchSize', () => {
-		const p = new HttpEmbeddingProvider({
-			apiKey: 'k',
-			model: 'm',
-			baseUrl: 'https://embeddings.test/v1',
-		})
-		expect(p.model).toBe('m')
-		expect(p.dimensions).toBe(1536)
-	})
-
-	it('honors overrides for dimensions + baseUrl + batchSize', async () => {
-		fetchMock.mockResolvedValue({
-			ok: true,
-			json: async () => ({ data: [{ index: 0, embedding: [1, 2, 3] }] }),
-		})
-		const p = new HttpEmbeddingProvider({
-			apiKey: 'k',
-			model: 'm',
-			dimensions: 256,
-			baseUrl: 'https://custom.example/api',
-		})
-		await p.embed(['x'])
-
-		expect(fetchMock).toHaveBeenCalledWith(
-			'https://custom.example/api/embeddings',
-			expect.objectContaining({
-				method: 'POST',
-				headers: expect.objectContaining({
-					Authorization: 'Bearer k',
-					'Content-Type': 'application/json',
-				}),
-			}),
-		)
-		const body = JSON.parse((fetchMock.mock.calls[0]?.[1] as { body: string }).body)
-		expect(body).toEqual({ model: 'm', input: ['x'], dimensions: 256 })
-		expect(p.dimensions).toBe(256)
-	})
-
-	it('batches into batchSize slices', async () => {
-		fetchMock.mockResolvedValue({
-			ok: true,
-			json: async () => ({
-				data: [
-					{ index: 0, embedding: [1] },
-					{ index: 1, embedding: [2] },
-				],
-			}),
-		})
-		const p = new HttpEmbeddingProvider({
-			apiKey: 'k',
-			model: 'm',
-			baseUrl: 'https://embeddings.test/v1',
-			batchSize: 2,
-		})
-		await p.embed(['a', 'b', 'c', 'd'])
-		expect(fetchMock).toHaveBeenCalledTimes(2)
-	})
-
-	it('sorts response by index before extracting embeddings', async () => {
-		fetchMock.mockResolvedValue({
-			ok: true,
-			json: async () => ({
-				data: [
-					{ index: 2, embedding: [3] },
-					{ index: 0, embedding: [1] },
-					{ index: 1, embedding: [2] },
-				],
-			}),
-		})
-		const p = new HttpEmbeddingProvider({
-			apiKey: 'k',
-			model: 'm',
-			baseUrl: 'https://embeddings.test/v1',
-		})
-		expect(await p.embed(['a', 'b', 'c'])).toEqual([[1], [2], [3]])
-	})
-
-	it('embedQuery returns the first result', async () => {
-		fetchMock.mockResolvedValue({
-			ok: true,
-			json: async () => ({ data: [{ index: 0, embedding: [9, 9] }] }),
-		})
-		const p = new HttpEmbeddingProvider({
-			apiKey: 'k',
-			model: 'm',
-			baseUrl: 'https://embeddings.test/v1',
-		})
-		expect(await p.embedQuery('hi')).toEqual([9, 9])
-	})
-
-	it('embedQuery throws when the response is empty', async () => {
-		fetchMock.mockResolvedValue({
-			ok: true,
-			json: async () => ({ data: [] }),
-		})
-		const p = new HttpEmbeddingProvider({
-			apiKey: 'k',
-			model: 'm',
-			baseUrl: 'https://embeddings.test/v1',
-		})
-		await expect(p.embedQuery('hi')).rejects.toThrow(/no results/)
-	})
-
-	it('throws on non-OK HTTP response', async () => {
-		fetchMock.mockResolvedValue({
-			ok: false,
-			status: 503,
-			text: async () => 'service unavailable',
-		})
-		const p = new HttpEmbeddingProvider({
-			apiKey: 'k',
-			model: 'm',
-			baseUrl: 'https://embeddings.test/v1',
-		})
-		await expect(p.embed(['hi'])).rejects.toThrow(/503.*service unavailable/)
-	})
-})
-
-describe('the endpoint is the caller\u2019s decision', () => {
-	it('appends the path to whatever root the caller named', async () => {
-		const fetchMock = vi.fn().mockResolvedValue({
-			ok: true,
-			json: async () => ({ data: [{ index: 0, embedding: [1] }] }),
-		})
-		global.fetch = fetchMock as unknown as typeof fetch
-
-		await new HttpEmbeddingProvider({
-			apiKey: 'k',
-			model: 'm',
-			baseUrl: 'https://vectors.internal/v2',
-		}).embed(['x'])
-
-		expect(fetchMock.mock.calls[0]?.[0]).toBe('https://vectors.internal/v2/embeddings')
-	})
-
-	it('tolerates a trailing slash instead of building a double one', async () => {
-		const fetchMock = vi.fn().mockResolvedValue({
-			ok: true,
-			json: async () => ({ data: [{ index: 0, embedding: [1] }] }),
-		})
-		global.fetch = fetchMock as unknown as typeof fetch
-
-		await new HttpEmbeddingProvider({
-			apiKey: 'k',
-			model: 'm',
-			baseUrl: 'https://vectors.internal/v2/',
-		}).embed(['x'])
-
-		expect(fetchMock.mock.calls[0]?.[0]).toBe('https://vectors.internal/v2/embeddings')
-	})
-})

package/src/rag/ingestion.test.ts

@@ -1,114 +0,0 @@
-/**
- * Current-code invariants asserted (2026-04-21, ses_006 Phase 4):
- *
- *   - `DefaultIngestionPipeline.ingest(content, metadata, scope, kbId)`:
- *     - Generates a fresh `documentId` per call.
- *     - Chunks via `TextChunker.chunk(content, chunkingConfig)`.
- *     - Returns zero-chunk result when the chunker emits nothing.
- *     - Calls `embeddingProvider.embed([...chunkTexts])` exactly once
- *       with every chunk in order.
- *     - Each resulting `Chunk` carries:
- *       - a fresh `id`,
- *       - the generated `documentId`,
- *       - the passed `knowledgeBaseId`,
- *       - `scope.tenantId`,
- *       - the original `chunkContent` + `chunkIndex` metadata,
- *       - `tokenCount = Math.ceil(content.length / 4)`.
- *     - Calls `vectorStore.upsert(chunks)` exactly once.
- *     - Totals `tokenCount` across chunks and reports `durationMs`.
- *   - `remove(documentId)` delegates to `vectorStore.deleteByDocument`.
- */
-
-import { describe, expect, it, vi } from 'vitest'
-import { z } from 'zod'
-
-import type { DocumentId, KnowledgeBaseId, TenantId } from '../types/ids/index.js'
-import type { Chunk, EmbeddingProvider, TenantScope, VectorStore } from '../types/rag/index.js'
-
-import { DefaultIngestionPipeline } from './ingestion.js'
-
-const KB = 'kb_1' as KnowledgeBaseId
-const TENANT = 't_1' as TenantId
-const scope: TenantScope = { tenantId: TENANT }
-
-function makeVectorStore(): VectorStore {
-	return {
-		upsert: vi.fn<(chunks: Chunk[]) => Promise<void>>(),
-		search: vi.fn(),
-		delete: vi.fn(),
-		deleteByDocument: vi.fn(),
-		deleteByKnowledgeBase: vi.fn(),
-	} as unknown as VectorStore
-}
-
-function makeEmbedder(): EmbeddingProvider {
-	return {
-		id: 'mock',
-		model: 'x',
-		dimensions: 3,
-		embed: vi.fn(async (texts: string[]) => texts.map(() => [1, 0, 0])),
-		embedQuery: vi.fn(async () => [1, 0, 0]),
-	}
-}
-
-describe('DefaultIngestionPipeline — ingest', () => {
-	it('returns zero-chunk result when the chunker emits nothing', async () => {
-		const vs = makeVectorStore()
-		const emb = makeEmbedder()
-		// chunkSize 10, no content at all → chunker returns []
-		const pipeline = new DefaultIngestionPipeline(vs, emb, {
-			strategy: 'fixed',
-			chunkSize: 10,
-			chunkOverlap: 0,
-		})
-		const result = await pipeline.ingest('   ', {}, scope, KB)
-		expect(result.chunkCount).toBe(0)
-		expect(result.totalTokens).toBe(0)
-		expect(vs.upsert).not.toHaveBeenCalled()
-	})
-
-	it('chunks content, embeds every chunk once, upserts once', async () => {
-		const vs = makeVectorStore()
-		const emb = makeEmbedder()
-		const pipeline = new DefaultIngestionPipeline(vs, emb, {
-			strategy: 'fixed',
-			chunkSize: 10,
-			chunkOverlap: 0,
-		})
-
-		const result = await pipeline.ingest('a'.repeat(25), { source: 'repo' }, scope, KB)
-
-		expect(emb.embed).toHaveBeenCalledTimes(1)
-		expect(vs.upsert).toHaveBeenCalledTimes(1)
-		expect(result.chunkCount).toBeGreaterThan(1)
-
-		const upsertedChunks = vi.mocked(vs.upsert).mock.calls[0]?.[0] ?? []
-		for (const c of upsertedChunks) {
-			expect(c.documentId).toBe(result.documentId)
-			expect(c.knowledgeBaseId).toBe(KB)
-			expect(c.tenantId).toBe(TENANT)
-			expect(c.metadata.source).toBe('repo')
-			expect(c.metadata.chunkIndex).toBeDefined()
-			expect(c.tokenCount).toBe(Math.ceil(c.content.length / 4))
-		}
-	})
-
-	it('generates a fresh documentId per ingest call', async () => {
-		const pipeline = new DefaultIngestionPipeline(makeVectorStore(), makeEmbedder())
-		const a = await pipeline.ingest('alpha', {}, scope, KB)
-		const b = await pipeline.ingest('beta', {}, scope, KB)
-		expect(a.documentId).not.toBe(b.documentId)
-	})
-})
-
-describe('DefaultIngestionPipeline — remove', () => {
-	it('delegates to vectorStore.deleteByDocument', async () => {
-		const vs = makeVectorStore()
-		const pipeline = new DefaultIngestionPipeline(vs, makeEmbedder())
-		await pipeline.remove('doc_9' as DocumentId)
-		expect(vs.deleteByDocument).toHaveBeenCalledWith('doc_9')
-	})
-})
-
-// Avoid the unused zod import — used in type coverage indirectly.
-void z