refactor(store): split edge project_id into from/to, rename orchestrator to StoreManager

Edges table now stores from_project_id and to_project_id separately,
enabling cross-project edges for workspace mode. Cleanup triggers
simplified since entity IDs are globally unique. Renamed
GraphOrchestrator → StoreManager for clarity.

Author: prih

src/lib/orchestrator.ts src/lib/store-manager.tssrc/lib/orchestrator.ts renamed to src/lib/store-manager.ts

@@ -1,9 +1,9 @@
 /**
- * GraphOrchestrator — thin layer between API (MCP/REST) and Store (SQLite).
+ * StoreManager — thin layer between API (MCP/REST) and Store (SQLite).
  *
  * Handles: embedding generation, file mirror sync, event emission.
  * Does NOT own the store — receives it as dependency.
- * One orchestrator per project.
+ * One StoreManager per project.
  */
 import { EventEmitter } from 'events';
 import type {
@@ -54,15 +54,15 @@ import {
 } from './file-mirror';
 import { createLogger } from './logger';
 
-const log = createLogger('orchestrator');
+const log = createLogger('store-manager');
 
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
 
 export type EmbedFn = (text: string) => Promise<number[]>;
 
-export interface OrchestratorConfig {
+export interface StoreManagerConfig {
   store: Store;
   projectId: number;
   projectDir: string;
@@ -72,18 +72,18 @@ export interface OrchestratorConfig {
 }
 
 // ---------------------------------------------------------------------------
-// GraphOrchestrator
+// StoreManager
 // ---------------------------------------------------------------------------
 
-export class GraphOrchestrator {
+export class StoreManager {
   readonly store: Store;
   readonly scoped: ProjectScopedStore;
   readonly projectId: number;
   readonly projectDir: string;
   private embedFn: EmbedFn;
   private emitter: EventEmitter;
 
-  constructor(config: OrchestratorConfig) {
+  constructor(config: StoreManagerConfig) {
     this.store = config.store;
     this.projectId = config.projectId;
     this.projectDir = config.projectDir;

src/store/sqlite/lib/edge-helper.ts

@@ -9,27 +9,28 @@ import { num } from './bigint';
 export class EdgeHelper {
   constructor(private db: Database.Database) {}
 
-  createEdge(projectId: number, edge: Edge): void {
+  createEdge(fromProjectId: number, toProjectId: number, edge: Edge): void {
     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);
+      INSERT OR IGNORE INTO edges (from_project_id, from_graph, from_id, to_project_id, to_graph, to_id, kind)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(fromProjectId, edge.fromGraph, edge.fromId, toProjectId, edge.toGraph, edge.toId, edge.kind);
   }
 
-  deleteEdge(projectId: number, edge: Edge): void {
+  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(projectId, edge.fromGraph, edge.fromId, edge.toGraph, edge.toId, edge.kind);
+      WHERE from_graph = ? AND from_id = ? AND to_graph = ? AND to_id = ? AND kind = ?
+    `).run(edge.fromGraph, edge.fromId, edge.toGraph, edge.toId, edge.kind);
   }
 
-  listEdges(filter: EdgeFilter & { projectId?: number }): Edge[] {
+  listEdges(filter: EdgeFilter): Edge[] {
     const conditions: string[] = [];
     const params: unknown[] = [];
 
-    if (filter.projectId !== undefined) { conditions.push('project_id = ?'); params.push(filter.projectId); }
+    if (filter.fromProjectId !== undefined) { conditions.push('from_project_id = ?'); params.push(filter.fromProjectId); }
     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.toProjectId !== undefined) { conditions.push('to_project_id = ?'); params.push(filter.toProjectId); }
     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); }
@@ -49,10 +50,14 @@ export class EdgeHelper {
   }
 
   findIncomingEdges(targetGraph: GraphName, targetId: number, projectId?: number): Edge[] {
-    return this.listEdges({ toGraph: targetGraph, toId: targetId, projectId });
+    const filter: EdgeFilter = { toGraph: targetGraph, toId: targetId };
+    if (projectId !== undefined) filter.toProjectId = projectId;
+    return this.listEdges(filter);
   }
 
   findOutgoingEdges(fromGraph: GraphName, fromId: number, projectId?: number): Edge[] {
-    return this.listEdges({ fromGraph, fromId, projectId });
+    const filter: EdgeFilter = { fromGraph, fromId };
+    if (projectId !== undefined) filter.fromProjectId = projectId;
+    return this.listEdges(filter);
   }
 }

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

@@ -14,11 +14,11 @@ export class EntityHelpers {
   setTags(graph: string, entityId: number, tags: string[]): void {
     // 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 }>;
+      `SELECT from_id FROM edges WHERE to_graph = ? AND to_id = ? AND from_graph = 'tags' AND kind = 'tagged'`
+    ).all(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);
+    this.db.prepare(`DELETE FROM edges WHERE to_graph = ? AND to_id = ? AND from_graph = 'tags' AND kind = 'tagged'`)
+      .run(graph, entityId);
 
     // Clean up orphaned tags in one query
     if (oldTagIds.length > 0) {
@@ -27,7 +27,7 @@ export class EntityHelpers {
       this.db.prepare(`
         DELETE FROM tags WHERE project_id = ? AND id IN (${ph})
         AND NOT EXISTS (
-          SELECT 1 FROM edges WHERE project_id = tags.project_id AND from_graph = 'tags' AND from_id = tags.id AND kind = 'tagged'
+          SELECT 1 FROM edges WHERE from_graph = 'tags' AND from_id = tags.id AND kind = 'tagged'
         )
       `).run(this.projectId, ...ids);
     }
@@ -36,22 +36,22 @@ export class EntityHelpers {
     const uniqueTags = [...new Set(tags)];
     const insertTag = this.db.prepare('INSERT OR IGNORE INTO tags (project_id, name) VALUES (?, ?)');
     const selectTag = this.db.prepare('SELECT id FROM tags WHERE project_id = ? AND name = ?');
-    const insertEdge = this.db.prepare(`INSERT OR IGNORE INTO edges (project_id, from_graph, from_id, to_graph, to_id, kind) VALUES (?, 'tags', ?, ?, ?, 'tagged')`);
+    const insertEdge = this.db.prepare(`INSERT OR IGNORE INTO edges (from_project_id, from_graph, from_id, to_project_id, to_graph, to_id, kind) VALUES (?, 'tags', ?, ?, ?, ?, 'tagged')`);
     for (const tag of uniqueTags) {
       insertTag.run(this.projectId, tag);
       const row = selectTag.get(this.projectId, tag) as { id: bigint } | undefined;
       if (!row) throw new Error(`Failed to resolve tag: ${tag}`);
-      insertEdge.run(this.projectId, num(row.id), graph, entityId);
+      insertEdge.run(this.projectId, num(row.id), this.projectId, graph, entityId);
     }
   }
 
   fetchTags(graph: string, entityId: number): string[] {
     const rows = this.db.prepare(`
       SELECT t.name FROM tags t
-      JOIN edges e ON e.from_graph = 'tags' AND e.from_id = t.id AND e.project_id = ?
+      JOIN edges e ON e.from_graph = 'tags' AND e.from_id = t.id
       WHERE e.to_graph = ? AND e.to_id = ? AND e.kind = 'tagged'
       ORDER BY t.name
-    `).all(this.projectId, graph, entityId) as Array<{ name: string }>;
+    `).all(graph, entityId) as Array<{ name: string }>;
     return rows.map(r => r.name);
   }
 
@@ -66,11 +66,11 @@ export class EntityHelpers {
       const rows = this.db.prepare(`
         SELECT e.to_id AS entity_id, t.name
         FROM edges e
-        JOIN tags t ON t.id = e.from_id AND t.project_id = e.project_id
-        WHERE e.project_id = ? AND e.from_graph = 'tags' AND e.to_graph = ? AND e.kind = 'tagged'
+        JOIN tags t ON t.id = e.from_id
+        WHERE e.from_graph = 'tags' AND e.to_graph = ? AND e.kind = 'tagged'
         AND e.to_id IN (${ph})
         ORDER BY t.name
-      `).all(this.projectId, graph, ...batch) as Array<{ entity_id: bigint; name: string }>;
+      `).all(graph, ...batch) as Array<{ entity_id: bigint; name: string }>;
 
       for (const r of rows) {
         const id = num(r.entity_id);
@@ -129,10 +129,10 @@ export class EntityHelpers {
   fetchEdges(graph: string, entityId: number): Edge[] {
     const rows = this.db.prepare(`
       SELECT from_graph, from_id, to_graph, to_id, kind FROM edges
-      WHERE project_id = ? AND (
+      WHERE (
         (from_graph = ? AND from_id = ?) OR (to_graph = ? AND to_id = ?)
       ) AND from_graph != 'tags'
-    `).all(this.projectId, graph, entityId, graph, entityId) as Array<Record<string, unknown>>;
+    `).all(graph, entityId, graph, entityId) as Array<Record<string, unknown>>;
     return rows.map(r => ({
       fromGraph: r.from_graph as GraphName,
       fromId: num(r.from_id as bigint),

src/store/sqlite/migrations/v001.ts

@@ -64,16 +64,19 @@ CREATE INDEX idx_attachments_entity ON attachments(project_id, graph, entity_id)
 -- =============================================
 
 CREATE TABLE edges (
-  project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-  from_graph TEXT NOT NULL,
-  from_id    INTEGER NOT NULL,
-  to_graph   TEXT NOT NULL,
-  to_id      INTEGER NOT NULL,
-  kind       TEXT NOT NULL,
-  PRIMARY KEY (project_id, from_graph, from_id, to_graph, to_id, kind)
+  from_project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  from_graph      TEXT NOT NULL,
+  from_id         INTEGER NOT NULL,
+  to_project_id   INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  to_graph        TEXT NOT NULL,
+  to_id           INTEGER NOT NULL,
+  kind            TEXT NOT NULL,
+  PRIMARY KEY (from_graph, from_id, to_graph, to_id, kind)
 );
-CREATE INDEX idx_edges_target ON edges(project_id, to_graph, to_id);
-CREATE INDEX idx_edges_source ON edges(project_id, from_graph, from_id);
+CREATE INDEX idx_edges_target ON edges(to_graph, to_id);
+CREATE INDEX idx_edges_source ON edges(from_graph, from_id);
+CREATE INDEX idx_edges_from_project ON edges(from_project_id);
+CREATE INDEX idx_edges_to_project ON edges(to_project_id);
 
 -- =============================================
 -- Knowledge (notes)
@@ -113,8 +116,8 @@ CREATE VIRTUAL TABLE knowledge_vec USING vec0(embedding float[${d('knowledge')}]
 
 CREATE TRIGGER knowledge_cleanup AFTER DELETE ON knowledge BEGIN
   DELETE FROM edges WHERE
-    (from_graph = 'knowledge' AND from_id = old.id AND project_id = old.project_id) OR
-    (to_graph = 'knowledge' AND to_id = old.id AND project_id = old.project_id);
+    (from_graph = 'knowledge' AND from_id = old.id) OR
+    (to_graph = 'knowledge' AND to_id = old.id);
   DELETE FROM attachments WHERE graph = 'knowledge' AND entity_id = old.id AND project_id = old.project_id;
   DELETE FROM knowledge_vec WHERE rowid = old.id;
 END;
@@ -166,8 +169,8 @@ CREATE VIRTUAL TABLE tasks_vec USING vec0(embedding float[${d('tasks')}]);
 
 CREATE TRIGGER tasks_cleanup AFTER DELETE ON tasks BEGIN
   DELETE FROM edges WHERE
-    (from_graph = 'tasks' AND from_id = old.id AND project_id = old.project_id) OR
-    (to_graph = 'tasks' AND to_id = old.id AND project_id = old.project_id);
+    (from_graph = 'tasks' AND from_id = old.id) OR
+    (to_graph = 'tasks' AND to_id = old.id);
   DELETE FROM attachments WHERE graph = 'tasks' AND entity_id = old.id AND project_id = old.project_id;
   DELETE FROM tasks_vec WHERE rowid = old.id;
 END;
@@ -213,8 +216,8 @@ CREATE VIRTUAL TABLE epics_vec USING vec0(embedding float[${d('epics')}]);
 
 CREATE TRIGGER epics_cleanup AFTER DELETE ON epics BEGIN
   DELETE FROM edges WHERE
-    (from_graph = 'epics' AND from_id = old.id AND project_id = old.project_id) OR
-    (to_graph = 'epics' AND to_id = old.id AND project_id = old.project_id);
+    (from_graph = 'epics' AND from_id = old.id) OR
+    (to_graph = 'epics' AND to_id = old.id);
   DELETE FROM attachments WHERE graph = 'epics' AND entity_id = old.id AND project_id = old.project_id;
   DELETE FROM epics_vec WHERE rowid = old.id;
 END;
@@ -265,8 +268,8 @@ CREATE VIRTUAL TABLE skills_vec USING vec0(embedding float[${d('skills')}]);
 
 CREATE TRIGGER skills_cleanup AFTER DELETE ON skills BEGIN
   DELETE FROM edges WHERE
-    (from_graph = 'skills' AND from_id = old.id AND project_id = old.project_id) OR
-    (to_graph = 'skills' AND to_id = old.id AND project_id = old.project_id);
+    (from_graph = 'skills' AND from_id = old.id) OR
+    (to_graph = 'skills' AND to_id = old.id);
   DELETE FROM attachments WHERE graph = 'skills' AND entity_id = old.id AND project_id = old.project_id;
   DELETE FROM skills_vec WHERE rowid = old.id;
 END;
@@ -317,8 +320,8 @@ CREATE VIRTUAL TABLE code_vec USING vec0(embedding float[${d('code')}]);
 
 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);
+    (from_graph = 'code' AND from_id = old.id) OR
+    (to_graph = 'code' AND to_id = old.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;
@@ -361,8 +364,8 @@ CREATE VIRTUAL TABLE docs_vec USING vec0(embedding float[${d('docs')}]);
 
 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);
+    (from_graph = 'docs' AND from_id = old.id) OR
+    (to_graph = 'docs' AND to_id = old.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;
@@ -393,17 +396,17 @@ CREATE VIRTUAL TABLE files_vec USING vec0(embedding float[${d('files')}]);
 
 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);
+    (from_graph = 'files' AND from_id = old.id) OR
+    (to_graph = 'files' AND to_id = old.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;
 
 -- Tags cleanup: when a tag is deleted, remove its edges
 CREATE TRIGGER tags_cleanup AFTER DELETE ON tags BEGIN
   DELETE FROM edges WHERE
-    (from_graph = 'tags' AND from_id = old.id AND project_id = old.project_id) OR
-    (to_graph = 'tags' AND to_id = old.id AND project_id = old.project_id);
+    (from_graph = 'tags' AND from_id = old.id) OR
+    (to_graph = 'tags' AND to_id = old.id);
 END;
 `,
   };

src/store/sqlite/store.ts

@@ -84,17 +84,17 @@ export class SqliteStore implements Store {
 
   // --- Edges ---
 
-  createEdge(projectId: number, edge: Edge): void {
+  createEdge(fromProjectId: number, toProjectId: number, edge: Edge): void {
     this.requireDb();
-    this.edgeHelper!.createEdge(projectId, edge);
+    this.edgeHelper!.createEdge(fromProjectId, toProjectId, edge);
   }
 
-  deleteEdge(projectId: number, edge: Edge): void {
+  deleteEdge(edge: Edge): void {
     this.requireDb();
-    this.edgeHelper!.deleteEdge(projectId, edge);
+    this.edgeHelper!.deleteEdge(edge);
   }
 
-  listEdges(filter: EdgeFilter & { projectId?: number }): Edge[] {
+  listEdges(filter: EdgeFilter): Edge[] {
     this.requireDb();
     return this.edgeHelper!.listEdges(filter);
   }

src/store/sqlite/stores/code.ts

@@ -95,8 +95,8 @@ export class SqliteCodeStore implements CodeStore {
     `);
     const insertVec = this.db.prepare('INSERT INTO code_vec (rowid, embedding) VALUES (?, ?)');
     const insertEdge = this.db.prepare(`
-      INSERT OR IGNORE INTO edges (project_id, from_graph, from_id, to_graph, to_id, kind)
-      VALUES (?, 'code', ?, 'code', ?, ?)
+      INSERT OR IGNORE INTO edges (from_project_id, from_graph, from_id, to_project_id, to_graph, to_id, kind)
+      VALUES (?, 'code', ?, ?, 'code', ?, ?)
     `);
 
     const nameToId = new Map<string, number>();
@@ -119,15 +119,15 @@ export class SqliteCodeStore implements CodeStore {
       }
 
       // Edge: file → symbol (contains)
-      insertEdge.run(this.projectId, fileNodeId, nodeId, 'contains');
+      insertEdge.run(this.projectId, fileNodeId, this.projectId, nodeId, 'contains');
     }
 
     // 4. Insert intra-file edges
     for (const edge of edges) {
       const fromId = nameToId.get(edge.fromName);
       const toId = nameToId.get(edge.toName);
       if (fromId !== undefined && toId !== undefined) {
-        insertEdge.run(this.projectId, fromId, toId, edge.kind);
+        insertEdge.run(this.projectId, fromId, this.projectId, toId, edge.kind);
       }
     }
   }
@@ -149,16 +149,16 @@ export class SqliteCodeStore implements CodeStore {
   resolveEdges(edges: Array<{ fromName: string; toName: string; kind: string }>): void {
     const findByName = this.db.prepare("SELECT id FROM code WHERE project_id = ? AND name = ? AND kind != 'file'");
     const insertEdge = this.db.prepare(`
-      INSERT OR IGNORE INTO edges (project_id, from_graph, from_id, to_graph, to_id, kind)
-      VALUES (?, 'code', ?, 'code', ?, ?)
+      INSERT OR IGNORE INTO edges (from_project_id, from_graph, from_id, to_project_id, to_graph, to_id, kind)
+      VALUES (?, 'code', ?, ?, 'code', ?, ?)
     `);
 
     for (const edge of edges) {
       const fromRows = findByName.all(this.projectId, edge.fromName) as Array<{ id: bigint }>;
       const toRows = findByName.all(this.projectId, edge.toName) as Array<{ id: bigint }>;
       for (const fromRow of fromRows) {
         for (const toRow of toRows) {
-          insertEdge.run(this.projectId, num(fromRow.id), num(toRow.id), edge.kind);
+          insertEdge.run(this.projectId, num(fromRow.id), this.projectId, num(toRow.id), edge.kind);
         }
       }
     }