test(store): add missing coverage for utilities, embedding dims, epics reorder

- bigint.ts: tests for likeEscape, assertEmbeddingDim, chunk, safeJson (was 70% → 100%)
- search.ts: test assertIdentifier SQL injection guard
- migrate.ts: test invalid migration version rejection
- epics: reorder, version conflict, embedding update, tag filter, dim mismatch
- tasks/knowledge: embedding dimension mismatch on create and update

Author: prih

src/tests/store/contract/epics.test.ts

@@ -144,6 +144,49 @@ describe('EpicsStore contract', () => {
     expect(epics.get(epic.id)!.progress.total).toBe(1);
   });
 
+  // --- Reorder ---
+
+  it('reorders an epic', () => {
+    const epic = epics.create({ title: 'E', description: '' }, seedEmbedding(1));
+    const reordered = epics.reorder(epic.id, 5000);
+    expect(reordered.order).toBe(5000);
+    expect(reordered.version).toBe(2);
+  });
+
+  // --- Version conflict ---
+
+  it('update throws on version conflict', () => {
+    const epic = epics.create({ title: 'E', description: '' }, seedEmbedding(1));
+    expect(() => epics.update(epic.id, { title: 'X' }, null, undefined, 99)).toThrow('Version conflict');
+  });
+
+  it('update with embedding replaces vec0', () => {
+    const epic = epics.create({ title: 'E', description: '' }, seedEmbedding(1));
+    const updated = epics.update(epic.id, { title: 'E2' }, seedEmbedding(2));
+    expect(updated.title).toBe('E2');
+    // Verify vector search still works after replacement
+    const results = epics.search({ embedding: seedEmbedding(2), searchMode: 'vector' });
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].id).toBe(epic.id);
+  });
+
+  // --- Tag filter ---
+
+  it('list with tag filter', () => {
+    epics.create({ title: 'Tagged', description: '', tags: ['important'] }, seedEmbedding(1));
+    epics.create({ title: 'Untagged', description: '' }, seedEmbedding(2));
+
+    const result = epics.list({ tag: 'important' });
+    expect(result.results.length).toBe(1);
+    expect(result.results[0].title).toBe('Tagged');
+  });
+
+  // --- Embedding dim mismatch ---
+
+  it('create throws on wrong embedding dimension', () => {
+    expect(() => epics.create({ title: 'Bad', description: '' }, [1, 2, 3])).toThrow('Embedding dimension mismatch');
+  });
+
   // --- Hybrid search ---
 
   it('hybrid search combines keyword and vector', () => {

src/tests/store/contract/knowledge.test.ts

@@ -219,4 +219,15 @@ describe('KnowledgeStore contract', () => {
     expect(knowledge.getMeta('key')).toBe('val');
     expect(store.getMeta('key')).toBeNull();
   });
+
+  // --- Embedding dimension ---
+
+  it('create throws on wrong embedding dimension', () => {
+    expect(() => knowledge.create({ title: 'Bad', content: '' }, [1, 2, 3])).toThrow('Embedding dimension mismatch');
+  });
+
+  it('update throws on wrong embedding dimension', () => {
+    const note = knowledge.create({ title: 'N', content: '' }, seedEmbedding(1));
+    expect(() => knowledge.update(note.id, { title: 'N2' }, [1, 2, 3])).toThrow('Embedding dimension mismatch');
+  });
 });

src/tests/store/contract/tasks.test.ts

@@ -282,4 +282,15 @@ describe('TasksStore contract', () => {
     const after = Number((db.prepare("SELECT COUNT(*) AS c FROM tags WHERE project_id = ? AND name = 'old-tag'").get(projectId) as { c: bigint }).c);
     expect(after).toBe(0);
   });
+
+  // --- Embedding dimension ---
+
+  it('create throws on wrong embedding dimension', () => {
+    expect(() => tasks.create({ title: 'Bad', description: '' }, [1, 2, 3])).toThrow('Embedding dimension mismatch');
+  });
+
+  it('update throws on wrong embedding dimension', () => {
+    const task = tasks.create({ title: 'T', description: '' }, seedEmbedding(1));
+    expect(() => tasks.update(task.id, { title: 'T2' }, [1, 2, 3])).toThrow('Embedding dimension mismatch');
+  });
 });

src/tests/store/sqlite/bigint.test.ts

@@ -1,4 +1,4 @@
-import { num, now } from '@/store/sqlite/lib/bigint';
+import { num, now, likeEscape, assertEmbeddingDim, chunk, safeJson } from '@/store/sqlite/lib/bigint';
 
 describe('BigInt helpers', () => {
   it('num converts BigInt to number', () => {
@@ -22,3 +22,74 @@ describe('BigInt helpers', () => {
     expect(ts <= after).toBe(true);
   });
 });
+
+describe('likeEscape', () => {
+  it('escapes % and _ characters', () => {
+    expect(likeEscape('100%')).toBe('100\\%');
+    expect(likeEscape('file_name')).toBe('file\\_name');
+  });
+
+  it('escapes backslashes', () => {
+    expect(likeEscape('path\\to')).toBe('path\\\\to');
+  });
+
+  it('handles combined special characters', () => {
+    expect(likeEscape('50%_done\\ok')).toBe('50\\%\\_done\\\\ok');
+  });
+
+  it('returns plain text unchanged', () => {
+    expect(likeEscape('hello world')).toBe('hello world');
+  });
+});
+
+describe('assertEmbeddingDim', () => {
+  it('passes for correct dimension', () => {
+    expect(() => assertEmbeddingDim([1, 2, 3], 3)).not.toThrow();
+  });
+
+  it('throws for wrong dimension', () => {
+    expect(() => assertEmbeddingDim([1, 2], 3)).toThrow('Embedding dimension mismatch: expected 3, got 2');
+  });
+
+  it('throws for empty embedding', () => {
+    expect(() => assertEmbeddingDim([], 384)).toThrow('expected 384, got 0');
+  });
+});
+
+describe('chunk', () => {
+  it('returns single chunk for small array', () => {
+    const result = chunk([1, 2, 3], 10);
+    expect(result).toEqual([[1, 2, 3]]);
+  });
+
+  it('splits array into multiple chunks', () => {
+    const result = chunk([1, 2, 3, 4, 5], 2);
+    expect(result).toEqual([[1, 2], [3, 4], [5]]);
+  });
+
+  it('handles empty array', () => {
+    const result = chunk([], 10);
+    expect(result).toEqual([[]]);
+  });
+
+  it('handles exact chunk size', () => {
+    const result = chunk([1, 2, 3, 4], 2);
+    expect(result).toEqual([[1, 2], [3, 4]]);
+  });
+});
+
+describe('safeJson', () => {
+  it('parses valid JSON', () => {
+    expect(safeJson('["a","b"]', [])).toEqual(['a', 'b']);
+    expect(safeJson('{"x":1}', {})).toEqual({ x: 1 });
+  });
+
+  it('returns fallback for invalid JSON', () => {
+    expect(safeJson('not json', [])).toEqual([]);
+    expect(safeJson('{broken', 'default')).toBe('default');
+  });
+
+  it('returns fallback for empty string', () => {
+    expect(safeJson('', null)).toBeNull();
+  });
+});

src/tests/store/sqlite/migrate.test.ts

@@ -87,4 +87,12 @@ describe('SQLite migrations', () => {
     expect(applied).toBe(0);
     expect(getSchemaVersion(db)).toBe(v1);
   });
+
+  it('rejects invalid migration version', () => {
+    const db = store.getDb();
+    const { runMigrations } = require('@/store/sqlite/lib/migrate');
+
+    expect(() => runMigrations(db, [{ version: 1.5, sql: 'SELECT 1' }])).toThrow('Invalid migration version');
+    expect(() => runMigrations(db, [{ version: 999.5, sql: 'SELECT 1' }])).toThrow('Invalid migration version');
+  });
 });

src/tests/store/sqlite/search.test.ts

@@ -178,6 +178,13 @@ describe('hybridSearch', () => {
     expect(hybrid.map(r => r.id)).toEqual(keyword.map(r => r.id));
   });
 
+  it('throws on invalid table identifier', () => {
+    expect(() => hybridSearch(db, {
+      ...config,
+      ftsTable: 'test; DROP TABLE test_items',
+    }, { text: 'hello', searchMode: 'keyword' }, projectId)).toThrow('Invalid ftsTable');
+  });
+
   it('hybrid with only embedding (no text) behaves like vector', () => {
     const hybrid = hybridSearch(db, config, {
       embedding: seedEmbedding(2),