opencode-telos 1.0.1 → 1.0.2

package/src/sdd/cache/snapshot-store.ts

@@ -7,9 +7,11 @@
  * Solução G: Snapshot persistente do grafo.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs"
+import { existsSync, readFileSync, mkdirSync } from "fs"
 import { join, dirname } from "path"
 import type { KnowledgeGraph, AnyNode, Relationship } from "../domain/types.js"
+import { atomicWriteFile } from "./atomic.js"
+import { graphFingerprint } from "./fingerprint.js"
 
 const SNAPSHOT_FILE = ".sdd/graph-cache.json"
 const SNAPSHOT_MAX_AGE_MS = 60 * 60 * 1000 // 1 hour
@@ -31,6 +33,7 @@ interface SerializedSnapshot {
   graph: KnowledgeGraph
   indices: SerializedIndices
   graphHash: string
+  sourceSignature: string
 }
 
 export class GraphSnapshotStore {
@@ -43,27 +46,28 @@ export class GraphSnapshotStore {
   /**
    * Save full graph + indices to disk.
    */
-  save(graph: KnowledgeGraph, graphHash: string): void {
+  save(graph: KnowledgeGraph, graphHash: string, sourceSignature: string): void {
     const snapshot: SerializedSnapshot = {
-      version: 2,
+      version: 3,
       timestamp: Date.now(),
       graph,
       indices: this.serializeIndices(graph),
       graphHash,
+      sourceSignature,
     }
 
     const path = join(this.projectDir, SNAPSHOT_FILE)
     const dir = dirname(path)
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
 
-    writeFileSync(path, JSON.stringify(snapshot), "utf-8")
+    atomicWriteFile(path, JSON.stringify(snapshot))
   }
 
   /**
    * Load graph from snapshot if valid.
    * Returns null if snapshot is missing, stale, or corrupted.
    */
-  load(): { graph: KnowledgeGraph; graphHash: string } | null {
+  load(): { graph: KnowledgeGraph; graphHash: string; sourceSignature: string } | null {
     const path = join(this.projectDir, SNAPSHOT_FILE)
     if (!existsSync(path)) return null
 
@@ -72,17 +76,19 @@ export class GraphSnapshotStore {
       const snapshot: SerializedSnapshot = JSON.parse(raw)
 
       // Validate version
-      if (snapshot.version !== 2) return null
+      if (snapshot.version !== 3) return null
 
       // Validate age
       if (Date.now() - snapshot.timestamp > SNAPSHOT_MAX_AGE_MS) return null
 
       // Validate graph structure
       if (!snapshot.graph || !Array.isArray(snapshot.graph.nodes)) return null
+      if (!snapshot.sourceSignature || snapshot.graphHash !== graphFingerprint(snapshot.graph)) return null
 
       return {
         graph: snapshot.graph,
         graphHash: snapshot.graphHash || "",
+        sourceSignature: snapshot.sourceSignature,
       }
     } catch {
       return null
@@ -99,7 +105,8 @@ export class GraphSnapshotStore {
     try {
       const raw = readFileSync(path, "utf-8")
       const snapshot: SerializedSnapshot = JSON.parse(raw)
-      return snapshot.version === 2 && (Date.now() - snapshot.timestamp) < SNAPSHOT_MAX_AGE_MS
+      return snapshot.version === 3 && Boolean(snapshot.sourceSignature) &&
+        (Date.now() - snapshot.timestamp) < SNAPSHOT_MAX_AGE_MS
     } catch {
       return false
     }

package/src/sdd/persistence/sqlite.ts

@@ -10,6 +10,7 @@ import { GraphIndices } from "../graph/index.js"
 import { ensureDir } from "./yaml.js"
 import { join } from "path"
 import { getCacheManager } from "../cache/manager.js"
+import { fileSignature } from "../cache/fingerprint.js"
 import type { GraphRepository } from "./repository.js"
 import { recordLegitimateSave, validateGraphIntegrity } from "../graph/integrity-guard.js"
 
@@ -30,7 +31,7 @@ export class SqliteGraphRepository {
   private baseDir: string
   private dbPath: string
   private db: any
-  private static cache: Map<string, { graph: KnowledgeGraph; indices: GraphIndices }> = new Map()
+  private static cache: Map<string, { graph: KnowledgeGraph; indices: GraphIndices; sourceSignature: string }> = new Map()
 
   constructor(projectDir: string) {
     this.baseDir = join(projectDir, ".sdd")
@@ -106,18 +107,34 @@ export class SqliteGraphRepository {
   }
 
   loadGraph(): KnowledgeGraph {
+    const cacheMgr = getCacheManager(require("path").dirname(this.baseDir))
+    const sourcePaths = [this.dbPath, `${this.dbPath}-wal`, `${this.dbPath}-shm`]
+    const currentSourceSignature = fileSignature(sourcePaths)
+
     // Check cache with revalidation
     const cached = SqliteGraphRepository.cache.get(this.dbPath)
     if (cached) {
-      // Revalidation: check if db was modified externally
-      const cacheMgr = getCacheManager(require("path").dirname(this.baseDir))
-      if (!cacheMgr.checkCrossProcessInvalidation(this.dbPath)) {
+      // Revalidation: check content signature and durable invalidation events.
+      if (cached.sourceSignature === currentSourceSignature && !cacheMgr.checkCrossProcessInvalidation(this.dbPath)) {
         return structuredClone(cached.graph)
       }
       // DB was modified externally, invalidate cache
       SqliteGraphRepository.cache.delete(this.dbPath)
     }
 
+    const snapshot = cacheMgr.loadGraphSnapshot()
+    if (snapshot?.sourceSignature === currentSourceSignature) {
+      const graph = snapshot.graph
+      const indices = GraphIndices.from(graph)
+      SqliteGraphRepository.cache.set(this.dbPath, {
+        graph: structuredClone(graph),
+        indices,
+        sourceSignature: currentSourceSignature,
+      })
+      cacheMgr.initGraphHash(graph.nodes.length, graph.relationships.length)
+      return structuredClone(graph)
+    }
+
     const db = this.getDb()
 
     // Load metadata
@@ -168,7 +185,7 @@ export class SqliteGraphRepository {
 
     // Build indices and cache
     const indices = GraphIndices.from(graph)
-    SqliteGraphRepository.cache.set(this.dbPath, { graph, indices })
+    SqliteGraphRepository.cache.set(this.dbPath, { graph, indices, sourceSignature: currentSourceSignature })
 
     // Anti-bypass: check for out-of-band modifications
     const projectDir = require("path").dirname(this.baseDir)
@@ -184,21 +201,26 @@ export class SqliteGraphRepository {
 
   saveGraph(graph: KnowledgeGraph): void {
     const db = this.getDb()
+    const cacheMgr = getCacheManager(require("path").dirname(this.baseDir))
+    if (!cacheMgr.acquireWriteLock()) {
+      throw new Error("Another process is writing the SDD graph; retry the mutation")
+    }
 
     // Use transaction for atomicity
-    db.exec("BEGIN TRANSACTION")
-
     try {
-      // Differential persistence: update only changed rows and delete only
-      // rows that disappeared. This keeps SQLite useful for large graphs.
-      const upsertMeta = db.prepare(
-        "INSERT INTO graph_metadata (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
-      )
-      upsertMeta.run("project_id", graph.project_id)
-      upsertMeta.run("version", graph.version)
-      upsertMeta.run("created_at", graph.metadata.created_at)
-      upsertMeta.run("updated_at", graph.metadata.updated_at)
-      upsertMeta.run("sdd_version", graph.metadata.sdd_version)
+      db.exec("BEGIN TRANSACTION")
+
+      try {
+        // Differential persistence: update only changed rows and delete only
+        // rows that disappeared. This keeps SQLite useful for large graphs.
+        const upsertMeta = db.prepare(
+          "INSERT INTO graph_metadata (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+        )
+        upsertMeta.run("project_id", graph.project_id)
+        upsertMeta.run("version", graph.version)
+        upsertMeta.run("created_at", graph.metadata.created_at)
+        upsertMeta.run("updated_at", graph.metadata.updated_at)
+        upsertMeta.run("sdd_version", graph.metadata.sdd_version)
 
       // Save nodes in batches for performance
       const upsertNode = db.prepare(`
@@ -258,10 +280,13 @@ export class SqliteGraphRepository {
       const deleteRelationship = db.prepare("DELETE FROM relationships WHERE id = ?")
       for (const row of existingRelationshipIds) if (!relationshipIds.has(row.id)) deleteRelationship.run(row.id)
 
-      db.exec("COMMIT")
-    } catch (e) {
-      db.exec("ROLLBACK")
-      throw e
+        db.exec("COMMIT")
+      } catch (e) {
+        db.exec("ROLLBACK")
+        throw e
+      }
+    } finally {
+      cacheMgr.releaseWriteLock()
     }
 
     // Compare against the immutable cached snapshot before replacing it.
@@ -270,7 +295,9 @@ export class SqliteGraphRepository {
     const snapshot = structuredClone(graph) as KnowledgeGraph
     const dirty = computeDirtyState(cached?.graph || null, snapshot)
     const indices = GraphIndices.from(snapshot)
-    SqliteGraphRepository.cache.set(this.dbPath, { graph: snapshot, indices })
+    const sourcePaths = [this.dbPath, `${this.dbPath}-wal`, `${this.dbPath}-shm`]
+    const sourceSignature = fileSignature(sourcePaths)
+    SqliteGraphRepository.cache.set(this.dbPath, { graph: snapshot, indices, sourceSignature })
     /*
     if (cached) {
       const oldGraph = cached.graph
@@ -313,7 +340,6 @@ export class SqliteGraphRepository {
     */
 
     // Update incremental hash
-    const cacheMgr = getCacheManager(require("path").dirname(this.baseDir))
     cacheMgr.initGraphHash(graph.nodes.length, graph.relationships.length)
 
     // A: Granular invalidation — only invalidate caches for changed types
@@ -326,7 +352,7 @@ export class SqliteGraphRepository {
     }
 
     // G: Save graph snapshot to disk for cross-session restore
-    cacheMgr.saveGraphSnapshot(graph)
+    cacheMgr.saveGraphSnapshot(graph, sourceSignature)
 
     // Anti-bypass: record legitimate save for integrity tracking
     const projectDir = require("path").dirname(this.baseDir)

package/src/sdd/persistence/yaml.ts

@@ -1,10 +1,12 @@
 import * as yaml from "js-yaml"
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "fs"
+import { readFileSync, existsSync, mkdirSync, readdirSync } from "fs"
 import { join, dirname } from "path"
 import type { KnowledgeGraph, AnyNode, NodeType, NodeStatus, Relationship } from "../domain/types.js"
 import { GraphIndices } from "../graph/index.js"
 import type { GraphRepository } from "./repository.js"
 import { getCacheManager } from "../cache/manager.js"
+import { atomicWriteFile } from "../cache/atomic.js"
+import { fileSignature } from "../cache/fingerprint.js"
 import { recordLegitimateSave, validateGraphIntegrity, isGraphTampered } from "../graph/integrity-guard.js"
 
 export function readYaml<T>(filePath: string): T {
@@ -21,7 +23,7 @@ export function writeYaml(filePath: string, data: unknown): void {
     quotingType: '"',
     forceQuotes: false,
   })
-  writeFileSync(filePath, content, "utf-8")
+  atomicWriteFile(filePath, content)
 }
 
 export function readJson<T>(filePath: string): T {
@@ -32,7 +34,7 @@ export function readJson<T>(filePath: string): T {
 export function writeJson(filePath: string, data: unknown): void {
   const dir = dirname(filePath)
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
-  writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8")
+  atomicWriteFile(filePath, JSON.stringify(data, null, 2))
 }
 
 export function ensureDir(dirPath: string): void {
@@ -73,6 +75,7 @@ interface GraphCache {
   graph: KnowledgeGraph
   indices: GraphIndices
   lastModified: number
+  sourceSignature: string
 }
 
 // ── Repository ───────────────────────────────────────────────────────
@@ -110,29 +113,36 @@ export class YamlGraphRepository implements GraphRepository {
       throw new Error("SDD not initialized. Run sdd.initialize first.")
     }
 
+    const cacheMgr = getCacheManager(require("path").dirname(this.baseDir))
+    const currentSourceSignature = fileSignature([this.graphPath])
+    const externallyInvalidated = cacheMgr.checkCrossProcessInvalidation(this.graphPath)
+
     // Check cache with revalidation
     const cached = YamlGraphRepository.cache.get(this.graphPath)
     if (cached) {
-      // Revalidation: check if file was modified externally
-      const currentMtime = (() => { try { return require("fs").statSync(this.graphPath).mtimeMs } catch { return 0 } })()
-      if (currentMtime <= cached.lastModified) {
-        // Cache is valid — also check incremental hash
-        const cacheMgr = getCacheManager(require("path").dirname(this.baseDir))
-        if (cacheMgr.isGraphHashValid(cached.indices.totalNodes + ":" + cached.indices.totalRelationships)) {
-          // Never expose the cached snapshot itself: callers intentionally
-          // mutate the graph before saveGraph(), and leaking this reference
-          // makes old/new comparisons impossible.
-          return structuredClone(cached.graph)
-        }
+      if (!externallyInvalidated && cached.sourceSignature === currentSourceSignature) {
+        // Never expose the cached snapshot itself: callers intentionally
+        // mutate the graph before saveGraph(), and leaking this reference
+        // makes old/new comparisons impossible.
+        return structuredClone(cached.graph)
       }
       // File was modified externally or hash mismatch, invalidate cache
       YamlGraphRepository.cache.delete(this.graphPath)
     }
+    if (externallyInvalidated) YamlGraphRepository.cache.delete(this.graphPath)
 
-    // Cross-process check
-    const cacheMgr = getCacheManager(require("path").dirname(this.baseDir))
-    if (cacheMgr.checkCrossProcessInvalidation(this.graphPath)) {
-      YamlGraphRepository.cache.delete(this.graphPath)
+    const snapshot = cacheMgr.loadGraphSnapshot()
+    if (snapshot?.sourceSignature === currentSourceSignature) {
+      const graph = snapshot.graph
+      const indices = GraphIndices.from(graph)
+      YamlGraphRepository.cache.set(this.graphPath, {
+        graph: structuredClone(graph),
+        indices,
+        lastModified: Date.now(),
+        sourceSignature: currentSourceSignature,
+      })
+      cacheMgr.initGraphHash(graph.nodes.length, graph.relationships.length)
+      return structuredClone(graph)
     }
 
     const graph = readYaml<KnowledgeGraph>(this.graphPath)
@@ -143,9 +153,10 @@ export class YamlGraphRepository implements GraphRepository {
       graph,
       indices,
       lastModified: stat,
+      sourceSignature: currentSourceSignature,
     })
 
-    // Initialize incremental hash
+    // Initialize the legacy mutation counter used by compatibility APIs.
     cacheMgr.initGraphHash(graph.nodes.length, graph.relationships.length)
 
     // Anti-bypass: check for out-of-band modifications
@@ -174,7 +185,9 @@ export class YamlGraphRepository implements GraphRepository {
 
     // Acquire cross-process lock
     const cacheMgr = getCacheManager(require("path").dirname(this.baseDir))
-    cacheMgr.acquireWriteLock()
+    if (!cacheMgr.acquireWriteLock()) {
+      throw new Error("Another process is writing the SDD graph; retry the mutation")
+    }
 
     try {
       writeYaml(this.graphPath, graph)
@@ -199,11 +212,12 @@ export class YamlGraphRepository implements GraphRepository {
     // readonly totals/search entries after additions and removals. YAML is
     // limited to small graphs; large graphs migrate to SQLite.
     const indices = GraphIndices.from(snapshot)
-    YamlGraphRepository.cache.set(this.graphPath, {
-      graph: snapshot,
-      indices,
-      lastModified: Date.now(),
-    })
+      YamlGraphRepository.cache.set(this.graphPath, {
+        graph: snapshot,
+        indices,
+        lastModified: Date.now(),
+        sourceSignature: fileSignature([this.graphPath]),
+      })
     /*
     if (cached) {
       // Compute dirty nodes incrementally
@@ -273,7 +287,7 @@ export class YamlGraphRepository implements GraphRepository {
     }
 
     // G: Save graph snapshot to disk for cross-session restore
-    cacheMgr.saveGraphSnapshot(graph)
+    cacheMgr.saveGraphSnapshot(graph, fileSignature([this.graphPath]))
   }
 
   getStorageType(): "yaml" {