feat(store): Phase 6 — ProjectScopedStore, edges, integration + audit fixes

ProjectScopedStore wraps all sub-stores with fixed projectId, cached
via store.project(id). Full edge CRUD at both scoped and workspace
levels. GraphName extended with epics/tags.

Audit fixes: recursive ensureDirectory chain, minScore in all
FilesStore search modes, orphaned tags cleanup in setTags, removed
template literal SQL interpolation, simplified isExported check.

Author: prih

src/store/sqlite/lib/entity-helpers.ts

@@ -12,8 +12,25 @@ export class EntityHelpers {
   // --- Tags ---
 
   setTags(graph: string, entityId: number, tags: string[]): void {
-    this.db.prepare(`DELETE FROM edges WHERE project_id = ? AND to_graph = ? AND to_id = ? AND from_graph = 'tags'`)
+    // Collect old tag ids before deleting edges
+    const oldTagIds = this.db.prepare(
+      `SELECT from_id FROM edges WHERE project_id = ? AND to_graph = ? AND to_id = ? AND from_graph = 'tags' AND kind = 'tagged'`
+    ).all(this.projectId, graph, entityId) as Array<{ from_id: bigint }>;
+
+    this.db.prepare(`DELETE FROM edges WHERE project_id = ? AND to_graph = ? AND to_id = ? AND from_graph = 'tags' AND kind = 'tagged'`)
       .run(this.projectId, graph, entityId);
+
+    // Clean up orphaned tags (tags with no remaining edges)
+    for (const old of oldTagIds) {
+      const edgeCount = num((this.db.prepare(
+        `SELECT COUNT(*) AS c FROM edges WHERE project_id = ? AND from_graph = 'tags' AND from_id = ? AND kind = 'tagged'`
+      ).get(this.projectId, num(old.from_id)) as { c: bigint }).c);
+      if (edgeCount === 0) {
+        this.db.prepare('DELETE FROM tags WHERE id = ? AND project_id = ?').run(num(old.from_id), this.projectId);
+      }
+    }
+
+    // Insert new tags
     for (const tag of tags) {
       this.db.prepare('INSERT OR IGNORE INTO tags (project_id, name) VALUES (?, ?)').run(this.projectId, tag);
       const row = this.db.prepare('SELECT id FROM tags WHERE project_id = ? AND name = ?').get(this.projectId, tag) as { id: bigint };

src/store/sqlite/store.ts

@@ -12,9 +12,11 @@ import type {
 import { openDatabase } from './lib/db';
 import { runMigrations } from './lib/migrate';
 import { MetaHelper } from './lib/meta';
+import { num } from './lib/bigint';
 import { v001 } from './migrations/v001';
 import { SqliteTeamStore } from './stores/team';
 import { SqliteProjectsStore } from './stores/projects';
+import { SqliteProjectScopedStore } from './stores/project-scoped';
 
 const ALL_MIGRATIONS = [v001];
 
@@ -61,30 +63,66 @@ export class SqliteStore implements Store {
 
   // --- Project scoping ---
 
-  project(_projectId: number): ProjectScopedStore {
-    throw new Error('Not implemented yet (Phase 6)');
+  project(projectId: number): ProjectScopedStore {
+    this.requireDb();
+    let scoped = this.scopedCache.get(projectId);
+    if (!scoped) {
+      scoped = new SqliteProjectScopedStore(this.db!, projectId);
+      this.scopedCache.set(projectId, scoped);
+    }
+    return scoped;
   }
 
   // --- Edges ---
 
-  createEdge(_projectId: number, _edge: Edge): void {
-    throw new Error('Not implemented yet (Phase 6)');
+  createEdge(projectId: number, edge: Edge): void {
+    this.requireDb();
+    this.db!.prepare(`
+      INSERT OR IGNORE INTO edges (project_id, from_graph, from_id, to_graph, to_id, kind)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(projectId, edge.fromGraph, edge.fromId, edge.toGraph, edge.toId, edge.kind);
   }
 
-  deleteEdge(_projectId: number, _edge: Edge): void {
-    throw new Error('Not implemented yet (Phase 6)');
+  deleteEdge(projectId: number, edge: Edge): void {
+    this.requireDb();
+    this.db!.prepare(`
+      DELETE FROM edges
+      WHERE project_id = ? AND from_graph = ? AND from_id = ? AND to_graph = ? AND to_id = ? AND kind = ?
+    `).run(projectId, edge.fromGraph, edge.fromId, edge.toGraph, edge.toId, edge.kind);
   }
 
-  listEdges(_filter: EdgeFilter & { projectId?: number }): Edge[] {
-    throw new Error('Not implemented yet (Phase 6)');
+  listEdges(filter: EdgeFilter & { projectId?: number }): Edge[] {
+    this.requireDb();
+    const conditions: string[] = [];
+    const params: unknown[] = [];
+
+    if (filter.projectId !== undefined) { conditions.push('project_id = ?'); params.push(filter.projectId); }
+    if (filter.fromGraph) { conditions.push('from_graph = ?'); params.push(filter.fromGraph); }
+    if (filter.fromId !== undefined) { conditions.push('from_id = ?'); params.push(filter.fromId); }
+    if (filter.toGraph) { conditions.push('to_graph = ?'); params.push(filter.toGraph); }
+    if (filter.toId !== undefined) { conditions.push('to_id = ?'); params.push(filter.toId); }
+    if (filter.kind) { conditions.push('kind = ?'); params.push(filter.kind); }
+
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const rows = this.db!.prepare(
+      `SELECT from_graph, from_id, to_graph, to_id, kind FROM edges ${where}`
+    ).all(...params) as Array<Record<string, unknown>>;
+
+    return rows.map(r => ({
+      fromGraph: r.from_graph as GraphName,
+      fromId: num(r.from_id as bigint),
+      toGraph: r.to_graph as GraphName,
+      toId: num(r.to_id as bigint),
+      kind: r.kind as string,
+    }));
   }
 
-  findIncomingEdges(_targetGraph: GraphName, _targetId: number, _projectId?: number): Edge[] {
-    throw new Error('Not implemented yet (Phase 6)');
+  findIncomingEdges(targetGraph: GraphName, targetId: number, projectId?: number): Edge[] {
+    return this.listEdges({ toGraph: targetGraph, toId: targetId, projectId });
   }
 
-  findOutgoingEdges(_fromGraph: GraphName, _fromId: number, _projectId?: number): Edge[] {
-    throw new Error('Not implemented yet (Phase 6)');
+  findOutgoingEdges(fromGraph: GraphName, fromId: number, projectId?: number): Edge[] {
+    return this.listEdges({ fromGraph, fromId, projectId });
   }
 
   // --- Transaction ---
@@ -113,7 +151,7 @@ export class SqliteStore implements Store {
 
   // --- Internal ---
 
-  /** Get the raw database handle (for sub-stores) */
+  /** Get the raw database handle (for sub-stores and tests) */
   getDb(): Database.Database {
     this.requireDb();
     return this.db!;

src/store/sqlite/stores/code.ts

@@ -41,7 +41,7 @@ export class SqliteCodeStore implements CodeStore {
       body: row.body as string,
       startLine: num(row.start_line as bigint),
       endLine: num(row.end_line as bigint),
-      isExported: (row.is_exported as number | bigint) === 1 || (row.is_exported as number | bigint) === BigInt(1),
+      isExported: row.is_exported === BigInt(1),
       mtime: num(row.mtime as bigint),
     };
   }

src/store/sqlite/stores/files.ts

@@ -40,15 +40,22 @@ export class SqliteFilesStore implements FilesStore {
   }
 
   private ensureDirectory(dirPath: string): number {
+    if (!dirPath || dirPath === '.' || dirPath === '') return -1;
+
     // Check if directory already exists
     const existing = this.db.prepare(
       "SELECT id FROM files WHERE project_id = ? AND file_path = ? AND kind = 'directory'"
     ).get(this.projectId, dirPath) as { id: bigint } | undefined;
 
     if (existing) return num(existing.id);
 
-    const dirName = path.basename(dirPath) || dirPath;
+    // Recursively ensure parent exists first
     const parentDir = path.dirname(dirPath);
+    if (parentDir !== dirPath && parentDir !== '.' && parentDir !== '') {
+      this.ensureDirectory(parentDir);
+    }
+
+    const dirName = path.basename(dirPath) || dirPath;
 
     const result = this.db.prepare(`
       INSERT INTO files (project_id, kind, file_path, file_name, directory, extension, size, file_count, mtime)
@@ -229,14 +236,18 @@ export class SqliteFilesStore implements FilesStore {
     const mode = query.searchMode ?? 'hybrid';
     const maxResults = query.maxResults ?? 20;
 
+    const minScore = query.minScore ?? 0;
+
     if (mode === 'keyword' && query.text) {
       // Fallback: LIKE-based search on file_path
       const rows = this.db.prepare(`
         SELECT id FROM files WHERE project_id = ? AND file_path LIKE ? AND kind = 'file'
         ORDER BY file_path ASC LIMIT ?
       `).all(this.projectId, `%${query.text}%`, maxResults) as Array<{ id: bigint }>;
 
-      return rows.map((r, i) => ({ id: num(r.id), score: 1 / (60 + i + 1) }));
+      return rows
+        .map((r, i) => ({ id: num(r.id), score: 1 / (60 + i + 1) }))
+        .filter(r => r.score >= minScore);
     }
 
     if (mode === 'vector' && query.embedding) {
@@ -251,10 +262,9 @@ export class SqliteFilesStore implements FilesStore {
         WHERE v.embedding MATCH ? AND v.k = ?
       `).all(this.projectId, embeddingBuf, topK * 3) as Array<{ id: bigint; distance: number }>;
 
-      return rows.slice(0, maxResults).map((r, i) => ({
-        id: num(r.id),
-        score: 1 / (60 + i + 1),
-      }));
+      return rows.slice(0, maxResults)
+        .map((r, i) => ({ id: num(r.id), score: 1 / (60 + i + 1) }))
+        .filter(r => r.score >= minScore);
     }
 
     // Hybrid: combine LIKE + vector
@@ -288,7 +298,6 @@ export class SqliteFilesStore implements FilesStore {
       for (const r of likeResults) scores.set(r.id, (scores.get(r.id) ?? 0) + 1 / (K + r.rn));
       for (const r of vecResults) scores.set(r.id, (scores.get(r.id) ?? 0) + 1 / (K + r.rn));
 
-      const minScore = query.minScore ?? 0;
       return [...scores.entries()]
         .map(([id, score]) => ({ id, score }))
         .filter(r => r.score >= minScore)

src/store/sqlite/stores/knowledge.ts

@@ -148,7 +148,7 @@ export class SqliteKnowledgeStore implements KnowledgeStore {
     if (tag) {
       conditions.push(`EXISTS (
         SELECT 1 FROM edges e JOIN tags t ON t.id = e.from_id AND t.project_id = e.project_id
-        WHERE e.project_id = k.project_id AND e.to_graph = '${GRAPH}' AND e.to_id = k.id
+        WHERE e.project_id = k.project_id AND e.to_graph = 'knowledge' AND e.to_id = k.id
         AND e.from_graph = 'tags' AND e.kind = 'tagged' AND t.name = ?
       )`);
       params.push(tag);

src/store/sqlite/stores/project-scoped.ts

@@ -0,0 +1,91 @@
+import Database from 'better-sqlite3';
+import type {
+  ProjectScopedStore,
+  CodeStore,
+  DocsStore,
+  FilesStore,
+  KnowledgeStore,
+  TasksStore,
+  SkillsStore,
+  AttachmentsStore,
+  Edge,
+  EdgeFilter,
+  GraphName,
+} from '../../types';
+import { num } from '../lib/bigint';
+import { SqliteCodeStore } from './code';
+import { SqliteDocsStore } from './docs';
+import { SqliteFilesStore } from './files';
+import { SqliteKnowledgeStore } from './knowledge';
+import { SqliteTasksStore } from './tasks';
+import { SqliteSkillsStore } from './skills';
+import { SqliteAttachmentsStore } from './attachments';
+
+export class SqliteProjectScopedStore implements ProjectScopedStore {
+  readonly code: CodeStore;
+  readonly docs: DocsStore;
+  readonly files: FilesStore;
+  readonly knowledge: KnowledgeStore;
+  readonly tasks: TasksStore;
+  readonly skills: SkillsStore;
+  readonly attachments: AttachmentsStore;
+
+  constructor(private db: Database.Database, readonly projectId: number) {
+    this.code = new SqliteCodeStore(db, projectId);
+    this.docs = new SqliteDocsStore(db, projectId);
+    this.files = new SqliteFilesStore(db, projectId);
+    this.knowledge = new SqliteKnowledgeStore(db, projectId);
+    this.tasks = new SqliteTasksStore(db, projectId);
+    this.skills = new SqliteSkillsStore(db, projectId);
+    this.attachments = new SqliteAttachmentsStore(db, projectId);
+  }
+
+  // =========================================================================
+  // Edges
+  // =========================================================================
+
+  createEdge(edge: Edge): void {
+    this.db.prepare(`
+      INSERT OR IGNORE INTO edges (project_id, from_graph, from_id, to_graph, to_id, kind)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(this.projectId, edge.fromGraph, edge.fromId, edge.toGraph, edge.toId, edge.kind);
+  }
+
+  deleteEdge(edge: Edge): void {
+    this.db.prepare(`
+      DELETE FROM edges
+      WHERE project_id = ? AND from_graph = ? AND from_id = ? AND to_graph = ? AND to_id = ? AND kind = ?
+    `).run(this.projectId, edge.fromGraph, edge.fromId, edge.toGraph, edge.toId, edge.kind);
+  }
+
+  listEdges(filter: EdgeFilter): Edge[] {
+    const conditions: string[] = ['project_id = ?'];
+    const params: unknown[] = [this.projectId];
+
+    if (filter.fromGraph) { conditions.push('from_graph = ?'); params.push(filter.fromGraph); }
+    if (filter.fromId !== undefined) { conditions.push('from_id = ?'); params.push(filter.fromId); }
+    if (filter.toGraph) { conditions.push('to_graph = ?'); params.push(filter.toGraph); }
+    if (filter.toId !== undefined) { conditions.push('to_id = ?'); params.push(filter.toId); }
+    if (filter.kind) { conditions.push('kind = ?'); params.push(filter.kind); }
+
+    const rows = this.db.prepare(
+      `SELECT from_graph, from_id, to_graph, to_id, kind FROM edges WHERE ${conditions.join(' AND ')}`
+    ).all(...params) as Array<Record<string, unknown>>;
+
+    return rows.map(r => ({
+      fromGraph: r.from_graph as GraphName,
+      fromId: num(r.from_id as bigint),
+      toGraph: r.to_graph as GraphName,
+      toId: num(r.to_id as bigint),
+      kind: r.kind as string,
+    }));
+  }
+
+  findIncomingEdges(targetGraph: GraphName, targetId: number): Edge[] {
+    return this.listEdges({ toGraph: targetGraph, toId: targetId });
+  }
+
+  findOutgoingEdges(fromGraph: GraphName, fromId: number): Edge[] {
+    return this.listEdges({ fromGraph, fromId });
+  }
+}

src/store/types/common.ts

@@ -1,6 +1,6 @@
 /** Shared types used across all store modules. */
 
-export type GraphName = 'code' | 'docs' | 'files' | 'knowledge' | 'tasks' | 'skills';
+export type GraphName = 'code' | 'docs' | 'files' | 'knowledge' | 'tasks' | 'skills' | 'epics' | 'tags';
 
 // ---------------------------------------------------------------------------
 // Search

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

@@ -232,6 +232,20 @@ describe('DocsStore contract', () => {
     }
   });
 
+  it('searchSnippets filters by language', () => {
+    docs.updateFile('docs/guide.md', makeChunks(), 1000, makeEmbeddings());
+
+    const yaml = docs.searchSnippets({ text: 'configure', searchMode: 'keyword' }, 'yaml');
+    const python = docs.searchSnippets({ text: 'configure', searchMode: 'keyword' }, 'python');
+
+    // yaml snippet matches, python does not
+    for (const r of yaml) {
+      const node = docs.getNode(r.id);
+      expect(node!.language).toBe('yaml');
+    }
+    expect(python.length).toBe(0);
+  });
+
   // --- Meta ---
 
   it('meta is prefixed', () => {

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

@@ -42,6 +42,17 @@ describe('FilesStore contract', () => {
     expect(dir!.fileName).toBe('utils');
   });
 
+  it('creates full directory chain for deeply nested files', () => {
+    files.updateFile('a/b/c/file.ts', 100, 1000, seedEmbedding(1));
+
+    expect(files.getFileInfo('a')).not.toBeNull();
+    expect(files.getFileInfo('a')!.kind).toBe('directory');
+    expect(files.getFileInfo('a/b')).not.toBeNull();
+    expect(files.getFileInfo('a/b')!.kind).toBe('directory');
+    expect(files.getFileInfo('a/b/c')).not.toBeNull();
+    expect(files.getFileInfo('a/b/c')!.kind).toBe('directory');
+  });
+
   it('updates existing file', () => {
     files.updateFile('src/index.ts', 1024, 1000, seedEmbedding(1));
     files.updateFile('src/index.ts', 2048, 2000, seedEmbedding(2));