feat(store): Phase 3 — Team, Projects, Attachments stores + cascade tests

- SqliteTeamStore: CRUD, slug uniqueness, getBySlug, list, MetaMixin
- SqliteProjectsStore: CRUD, cascade delete via FK + triggers
- SqliteAttachmentsStore: metadata registry (add/remove/list), optional url
- Wired team + projects in SqliteStore
- Fixed cleanup triggers: code/docs/files now also clean attachments
- Cascade delete tests: edges, attachments, vec0, tags all verified
- 70 tests passing (31 sqlite-specific + 39 contract)

Author: prih

src/store/sqlite/migrations/v001.ts

@@ -309,6 +309,7 @@ CREATE TRIGGER code_cleanup AFTER DELETE ON code BEGIN
   DELETE FROM edges WHERE
     (from_graph = 'code' AND from_id = old.id AND project_id = old.project_id) OR
     (to_graph = 'code' AND to_id = old.id AND project_id = old.project_id);
+  DELETE FROM attachments WHERE graph = 'code' AND entity_id = old.id AND project_id = old.project_id;
   DELETE FROM code_vec WHERE rowid = old.id;
 END;
 
@@ -352,6 +353,7 @@ CREATE TRIGGER docs_cleanup AFTER DELETE ON docs BEGIN
   DELETE FROM edges WHERE
     (from_graph = 'docs' AND from_id = old.id AND project_id = old.project_id) OR
     (to_graph = 'docs' AND to_id = old.id AND project_id = old.project_id);
+  DELETE FROM attachments WHERE graph = 'docs' AND entity_id = old.id AND project_id = old.project_id;
   DELETE FROM docs_vec WHERE rowid = old.id;
 END;
 
@@ -384,6 +386,7 @@ CREATE TRIGGER files_cleanup AFTER DELETE ON files BEGIN
   DELETE FROM edges WHERE
     (from_graph = 'files' AND from_id = old.id AND project_id = old.project_id) OR
     (to_graph = 'files' AND to_id = old.id AND project_id = old.project_id);
+  DELETE FROM attachments WHERE graph = 'files' AND entity_id = old.id AND project_id = old.project_id;
   DELETE FROM files_vec WHERE rowid = old.id;
 END;
 

src/store/sqlite/store.ts

@@ -13,21 +13,28 @@ import { openDatabase } from './lib/db';
 import { runMigrations } from './lib/migrate';
 import { MetaHelper } from './lib/meta';
 import { v001 } from './migrations/v001';
+import { SqliteTeamStore } from './stores/team';
+import { SqliteProjectsStore } from './stores/projects';
 
 const ALL_MIGRATIONS = [v001];
 
 export class SqliteStore implements Store {
   private db: Database.Database | null = null;
   private metaHelper: MetaHelper | null = null;
   private scopedCache = new Map<number, ProjectScopedStore>();
+  private _projects: SqliteProjectsStore | null = null;
+  private _team: SqliteTeamStore | null = null;
 
   // --- Sub-stores (workspace-level) ---
+
   get projects(): ProjectsStore {
-    throw new Error('Not implemented yet (Phase 3)');
+    this.requireDb();
+    return this._projects!;
   }
 
   get team(): TeamStore {
-    throw new Error('Not implemented yet (Phase 3)');
+    this.requireDb();
+    return this._team!;
   }
 
   // --- Lifecycle ---
@@ -37,11 +44,15 @@ export class SqliteStore implements Store {
     this.db = openDatabase(opts.dbPath);
     runMigrations(this.db, ALL_MIGRATIONS);
     this.metaHelper = new MetaHelper(this.db, '');
+    this._projects = new SqliteProjectsStore(this.db);
+    this._team = new SqliteTeamStore(this.db);
   }
 
   close(): void {
     if (!this.db) return;
     this.scopedCache.clear();
+    this._projects = null;
+    this._team = null;
     this.db.pragma('wal_checkpoint(TRUNCATE)');
     this.db.close();
     this.db = null;

src/store/sqlite/stores/attachments.ts

@@ -0,0 +1,63 @@
+import Database from 'better-sqlite3';
+import type {
+  AttachmentsStore,
+  AttachmentMeta,
+  GraphName,
+} from '../../types';
+import { num, now } from '../lib/bigint';
+
+export class SqliteAttachmentsStore implements AttachmentsStore {
+  private stmts: ReturnType<SqliteAttachmentsStore['prepareStatements']>;
+
+  constructor(private db: Database.Database, private projectId: number) {
+    this.stmts = this.prepareStatements();
+  }
+
+  private prepareStatements() {
+    return {
+      insert: this.db.prepare(`
+        INSERT INTO attachments (project_id, graph, entity_id, filename, mime_type, size, url, added_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `),
+      delete: this.db.prepare(
+        'DELETE FROM attachments WHERE project_id = ? AND graph = ? AND entity_id = ? AND filename = ?'
+      ),
+      deleteAll: this.db.prepare(
+        'DELETE FROM attachments WHERE project_id = ? AND graph = ? AND entity_id = ?'
+      ),
+      list: this.db.prepare(
+        'SELECT filename, mime_type, size, url, added_at FROM attachments WHERE project_id = ? AND graph = ? AND entity_id = ? ORDER BY added_at'
+      ),
+    };
+  }
+
+  private toMeta(row: Record<string, unknown>): AttachmentMeta {
+    return {
+      filename: row.filename as string,
+      mimeType: row.mime_type as string,
+      size: num(row.size as bigint),
+      url: (row.url as string) ?? undefined,
+      addedAt: num(row.added_at as bigint),
+    };
+  }
+
+  add(graph: GraphName, entityId: number, meta: AttachmentMeta): void {
+    this.stmts.insert.run(
+      this.projectId, graph, entityId,
+      meta.filename, meta.mimeType, meta.size, meta.url ?? null, meta.addedAt ?? now(),
+    );
+  }
+
+  remove(graph: GraphName, entityId: number, filename: string): void {
+    this.stmts.delete.run(this.projectId, graph, entityId, filename);
+  }
+
+  removeAll(graph: GraphName, entityId: number): void {
+    this.stmts.deleteAll.run(this.projectId, graph, entityId);
+  }
+
+  list(graph: GraphName, entityId: number): AttachmentMeta[] {
+    const rows = this.stmts.list.all(this.projectId, graph, entityId) as Array<Record<string, unknown>>;
+    return rows.map(r => this.toMeta(r));
+  }
+}

src/store/sqlite/stores/projects.ts

@@ -0,0 +1,98 @@
+import Database from 'better-sqlite3';
+import type {
+  ProjectsStore,
+  ProjectCreate,
+  ProjectPatch,
+  ProjectRecord,
+  PaginationOptions,
+} from '../../types';
+import { MetaHelper } from '../lib/meta';
+import { num, now } from '../lib/bigint';
+
+export class SqliteProjectsStore implements ProjectsStore {
+  private meta: MetaHelper;
+  private stmts: ReturnType<SqliteProjectsStore['prepareStatements']>;
+
+  constructor(private db: Database.Database) {
+    this.meta = new MetaHelper(db, 'projects');
+    this.stmts = this.prepareStatements();
+  }
+
+  private prepareStatements() {
+    return {
+      insert: this.db.prepare(`
+        INSERT INTO projects (slug, name, directory, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?)
+      `),
+      update: this.db.prepare(`
+        UPDATE projects SET name = ?, directory = ?, updated_at = ?
+        WHERE id = ?
+      `),
+      delete: this.db.prepare('DELETE FROM projects WHERE id = ?'),
+      getById: this.db.prepare('SELECT * FROM projects WHERE id = ?'),
+      getBySlug: this.db.prepare('SELECT * FROM projects WHERE slug = ?'),
+      list: this.db.prepare('SELECT * FROM projects ORDER BY name LIMIT ? OFFSET ?'),
+      count: this.db.prepare('SELECT COUNT(*) AS c FROM projects'),
+    };
+  }
+
+  private toRecord(row: Record<string, unknown>): ProjectRecord {
+    return {
+      id: num(row.id as bigint),
+      slug: row.slug as string,
+      name: row.name as string,
+      directory: row.directory as string,
+      createdAt: num(row.created_at as bigint),
+      updatedAt: num(row.updated_at as bigint),
+    };
+  }
+
+  create(data: ProjectCreate): ProjectRecord {
+    const ts = now();
+    const result = this.stmts.insert.run(data.slug, data.name, data.directory, ts, ts);
+    return this.get(num(result.lastInsertRowid))!;
+  }
+
+  update(projectId: number, patch: ProjectPatch): ProjectRecord {
+    const existing = this.get(projectId);
+    if (!existing) throw new Error(`Project ${projectId} not found`);
+
+    this.stmts.update.run(
+      patch.name ?? existing.name,
+      patch.directory ?? existing.directory,
+      now(),
+      projectId,
+    );
+    return this.get(projectId)!;
+  }
+
+  delete(projectId: number): void {
+    // CASCADE on FK handles: knowledge, tasks, epics, skills, code, docs, files, edges, tags
+    // Cleanup triggers on each entity table handle: vec0, edges, attachments
+    // But we need to clean vec0 for entities BEFORE cascade deletes them,
+    // because triggers fire per-row — which is fine, SQLite does this automatically.
+    this.stmts.delete.run(projectId);
+  }
+
+  get(projectId: number): ProjectRecord | null {
+    const row = this.stmts.getById.get(projectId) as Record<string, unknown> | undefined;
+    return row ? this.toRecord(row) : null;
+  }
+
+  getBySlug(slug: string): ProjectRecord | null {
+    const row = this.stmts.getBySlug.get(slug) as Record<string, unknown> | undefined;
+    return row ? this.toRecord(row) : null;
+  }
+
+  list(pagination?: PaginationOptions): { results: ProjectRecord[]; total: number } {
+    const limit = pagination?.limit ?? 50;
+    const offset = pagination?.offset ?? 0;
+    const rows = this.stmts.list.all(limit, offset) as Array<Record<string, unknown>>;
+    const total = num((this.stmts.count.get() as { c: bigint }).c);
+    return { results: rows.map(r => this.toRecord(r)), total };
+  }
+
+  getMeta(key: string): string | null { return this.meta.getMeta(key); }
+  setMeta(key: string, value: string): void { this.meta.setMeta(key, value); }
+  deleteMeta(key: string): void { this.meta.deleteMeta(key); }
+}

src/store/sqlite/stores/team.ts

@@ -0,0 +1,98 @@
+import Database from 'better-sqlite3';
+import type {
+  TeamStore,
+  TeamMemberCreate,
+  TeamMemberPatch,
+  TeamMemberRecord,
+  PaginationOptions,
+} from '../../types';
+import { MetaHelper } from '../lib/meta';
+import { num, now } from '../lib/bigint';
+
+export class SqliteTeamStore implements TeamStore {
+  private meta: MetaHelper;
+  private stmts: ReturnType<SqliteTeamStore['prepareStatements']>;
+
+  constructor(private db: Database.Database) {
+    this.meta = new MetaHelper(db, 'team');
+    this.stmts = this.prepareStatements();
+  }
+
+  private prepareStatements() {
+    return {
+      insert: this.db.prepare(`
+        INSERT INTO team_members (slug, name, email, role, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `),
+      update: this.db.prepare(`
+        UPDATE team_members SET name = ?, email = ?, role = ?, updated_at = ?
+        WHERE id = ?
+      `),
+      delete: this.db.prepare('DELETE FROM team_members WHERE id = ?'),
+      getById: this.db.prepare('SELECT * FROM team_members WHERE id = ?'),
+      getBySlug: this.db.prepare('SELECT * FROM team_members WHERE slug = ?'),
+      list: this.db.prepare('SELECT * FROM team_members ORDER BY name LIMIT ? OFFSET ?'),
+      count: this.db.prepare('SELECT COUNT(*) AS c FROM team_members'),
+    };
+  }
+
+  private toRecord(row: Record<string, unknown>): TeamMemberRecord {
+    return {
+      id: num(row.id as bigint),
+      slug: row.slug as string,
+      name: row.name as string,
+      email: (row.email as string) ?? null,
+      role: (row.role as string) ?? null,
+      createdAt: num(row.created_at as bigint),
+      updatedAt: num(row.updated_at as bigint),
+    };
+  }
+
+  create(data: TeamMemberCreate): TeamMemberRecord {
+    const ts = now();
+    const result = this.stmts.insert.run(
+      data.slug, data.name, data.email ?? null, data.role ?? null, ts, ts,
+    );
+    return this.get(num(result.lastInsertRowid))!;
+  }
+
+  update(memberId: number, patch: TeamMemberPatch): TeamMemberRecord {
+    const existing = this.get(memberId);
+    if (!existing) throw new Error(`Team member ${memberId} not found`);
+
+    this.stmts.update.run(
+      patch.name ?? existing.name,
+      patch.email !== undefined ? patch.email : existing.email,
+      patch.role !== undefined ? patch.role : existing.role,
+      now(),
+      memberId,
+    );
+    return this.get(memberId)!;
+  }
+
+  delete(memberId: number): void {
+    this.stmts.delete.run(memberId);
+  }
+
+  get(memberId: number): TeamMemberRecord | null {
+    const row = this.stmts.getById.get(memberId) as Record<string, unknown> | undefined;
+    return row ? this.toRecord(row) : null;
+  }
+
+  getBySlug(slug: string): TeamMemberRecord | null {
+    const row = this.stmts.getBySlug.get(slug) as Record<string, unknown> | undefined;
+    return row ? this.toRecord(row) : null;
+  }
+
+  list(pagination?: PaginationOptions): { results: TeamMemberRecord[]; total: number } {
+    const limit = pagination?.limit ?? 50;
+    const offset = pagination?.offset ?? 0;
+    const rows = this.stmts.list.all(limit, offset) as Array<Record<string, unknown>>;
+    const total = num((this.stmts.count.get() as { c: bigint }).c);
+    return { results: rows.map(r => this.toRecord(r)), total };
+  }
+
+  getMeta(key: string): string | null { return this.meta.getMeta(key); }
+  setMeta(key: string, value: string): void { this.meta.setMeta(key, value); }
+  deleteMeta(key: string): void { this.meta.deleteMeta(key); }
+}