@graphmemory/server 1.2.0 → 1.3.1

package/dist/graphs/code.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CodeGraphManager = exports.createCodeGraph = void 0;
 exports.updateCodeFile = updateCodeFile;
 exports.resolvePendingImports = resolvePendingImports;
+exports.resolvePendingEdges = resolvePendingEdges;
 exports.removeCodeFile = removeCodeFile;
 exports.getFileSymbols = getFileSymbols;
 exports.getCodeFileMtime = getCodeFileMtime;
@@ -20,6 +21,9 @@ const manager_types_1 = require("../graphs/manager-types");
 const code_1 = require("../lib/search/code");
 const files_1 = require("../lib/search/files");
 const bm25_1 = require("../lib/search/bm25");
+const embedding_codec_1 = require("../lib/embedding-codec");
+const graph_persistence_1 = require("../lib/graph-persistence");
+const defaults_1 = require("../lib/defaults");
 // ---------------------------------------------------------------------------
 // CRUD
 // ---------------------------------------------------------------------------
@@ -30,19 +34,31 @@ function updateCodeFile(graph, parsed) {
         graph.addNode(id, attrs);
     }
     const pendingImports = [];
+    const pendingEdges = [];
     for (const { from, to, attrs } of parsed.edges) {
         if (!graph.hasNode(to)) {
-            if (attrs.kind === 'imports')
+            if (attrs.kind === 'imports') {
                 pendingImports.push(to);
+            }
+            else if (attrs.kind === 'extends' || attrs.kind === 'implements') {
+                // Target class/interface may be in another file — defer resolution
+                const toName = to.split('::').pop();
+                pendingEdges.push({ from, toName, kind: attrs.kind });
+            }
             continue;
         }
         if (graph.hasNode(from) && !graph.hasEdge(from, to)) {
             graph.addEdgeWithKey(`${from}→${to}`, from, to, attrs);
         }
     }
-    // Store pending imports on the file node for post-drain resolution
-    if (pendingImports.length > 0 && graph.hasNode(parsed.fileId)) {
-        graph.setNodeAttribute(parsed.fileId, 'pendingImports', pendingImports);
+    // Store pending data on the file node for post-drain resolution
+    if (graph.hasNode(parsed.fileId)) {
+        if (pendingImports.length > 0) {
+            graph.setNodeAttribute(parsed.fileId, 'pendingImports', pendingImports);
+        }
+        if (pendingEdges.length > 0) {
+            graph.setNodeAttribute(parsed.fileId, 'pendingEdges', pendingEdges);
+        }
     }
 }
 /**
@@ -71,6 +87,67 @@ function resolvePendingImports(graph) {
     });
     return created;
 }
+/**
+ * Resolve pending extends/implements edges after all files have been indexed.
+ * When multiple candidates share the same name, prefers the one whose file
+ * is imported by the source file (falls back to first match).
+ */
+function resolvePendingEdges(graph) {
+    const nameIndex = new Map();
+    graph.forEachNode((id, attrs) => {
+        if (attrs.kind === 'class' || attrs.kind === 'interface') {
+            const list = nameIndex.get(attrs.name) ?? [];
+            list.push(id);
+            nameIndex.set(attrs.name, list);
+        }
+    });
+    // Build file → imported file IDs index for disambiguation
+    const fileImports = new Map();
+    graph.forEachNode((id, attrs) => {
+        if (attrs.kind === 'file') {
+            const imported = new Set();
+            graph.forEachOutEdge(id, (_edge, edgeAttrs, _src, target) => {
+                if (edgeAttrs.kind === 'imports')
+                    imported.add(target);
+            });
+            fileImports.set(id, imported);
+        }
+    });
+    let created = 0;
+    graph.forEachNode((id, attrs) => {
+        if (!attrs.pendingEdges || attrs.pendingEdges.length === 0)
+            return;
+        const remaining = [];
+        for (const edge of attrs.pendingEdges) {
+            const candidates = nameIndex.get(edge.toName);
+            if (candidates && candidates.length > 0 && graph.hasNode(edge.from)) {
+                let toId;
+                if (candidates.length === 1) {
+                    toId = candidates[0];
+                }
+                else {
+                    // Disambiguate: prefer candidate whose file is imported by edge.from's file
+                    const fromFileId = edge.from.split('::')[0];
+                    const imports = fileImports.get(fromFileId);
+                    const match = imports && candidates.find(c => {
+                        const cFileId = c.split('::')[0];
+                        return imports.has(cFileId);
+                    });
+                    toId = match ?? candidates[0];
+                }
+                if (toId !== edge.from && !graph.hasEdge(edge.from, toId)) {
+                    graph.addEdgeWithKey(`${edge.from}→${toId}`, edge.from, toId, { kind: edge.kind });
+                    created++;
+                }
+            }
+            else {
+                remaining.push(edge);
+            }
+        }
+        graph.setNodeAttribute(id, 'pendingEdges', remaining.length > 0 ? remaining : undefined);
+    });
+    return created;
+}
 /** Remove all nodes (and their incident edges) belonging to a file. */
 function removeCodeFile(graph, fileId) {
     const toRemove = graph.filterNodes((_, attrs) => attrs.fileId === fileId);
@@ -91,7 +168,7 @@ function getCodeFileMtime(graph, fileId) {
     return graph.getNodeAttribute(nodes[0], 'mtime');
 }
 /** List all indexed files with symbol counts. */
-function listCodeFiles(graph, filter, limit = 20) {
+function listCodeFiles(graph, filter, limit = defaults_1.LIST_LIMIT_SMALL) {
     const files = new Map();
     const lowerFilter = filter?.toLowerCase();
     graph.forEachNode((_, attrs) => {
@@ -112,23 +189,35 @@ function saveCodeGraph(graph, graphMemory, embeddingFingerprint) {
     fs_1.default.mkdirSync(graphMemory, { recursive: true });
     const file = path_1.default.join(graphMemory, 'code.json');
     const tmp = file + '.tmp';
-    fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: graph.export() }));
-    fs_1.default.renameSync(tmp, file);
+    try {
+        const exported = graph.export();
+        (0, embedding_codec_1.compressEmbeddings)(exported);
+        fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: exported }));
+        fs_1.default.renameSync(tmp, file);
+    }
+    catch (err) {
+        try {
+            fs_1.default.unlinkSync(tmp);
+        }
+        catch { /* ignore cleanup error */ }
+        throw err;
+    }
 }
 function loadCodeGraph(graphMemory, fresh = false, embeddingFingerprint) {
     const graph = (0, code_types_1.createCodeGraph)();
     if (fresh)
         return graph;
     const file = path_1.default.join(graphMemory, 'code.json');
-    if (!fs_1.default.existsSync(file))
+    const data = (0, graph_persistence_1.readJsonWithTmpFallback)(file);
+    if (!data)
         return graph;
     try {
-        const data = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
         const stored = data.embeddingModel;
         if (embeddingFingerprint && stored !== embeddingFingerprint) {
             process.stderr.write(`[code-graph] Embedding config changed, re-indexing code graph\n`);
             return graph;
         }
+        (0, embedding_codec_1.decompressEmbeddings)(data.graph);
         graph.import(data.graph);
         process.stderr.write(`[code-graph] Loaded ${graph.order} nodes, ${graph.size} edges\n`);
     }
@@ -144,7 +233,7 @@ class CodeGraphManager {
     _graph;
     embedFns;
     ext;
-    _bm25Index = new bm25_1.BM25Index((attrs) => `${attrs.name} ${attrs.signature} ${attrs.docComment}`);
+    _bm25Index = new bm25_1.BM25Index((attrs) => `${attrs.name} ${attrs.signature} ${attrs.docComment} ${attrs.body.slice(0, defaults_1.BM25_BODY_MAX_CHARS)}`);
     constructor(_graph, embedFns, ext = {}) {
         this._graph = _graph;
         this.embedFns = embedFns;

package/dist/graphs/docs.js

@@ -20,6 +20,9 @@ const manager_types_1 = require("../graphs/manager-types");
 const docs_1 = require("../lib/search/docs");
 const files_1 = require("../lib/search/files");
 const bm25_1 = require("../lib/search/bm25");
+const embedding_codec_1 = require("../lib/embedding-codec");
+const graph_persistence_1 = require("../lib/graph-persistence");
+const defaults_1 = require("../lib/defaults");
 function createGraph() {
     return new graphology_1.DirectedGraph({ multi: false, allowSelfLoops: false });
 }
@@ -107,7 +110,7 @@ function getFileMtime(graph, fileId) {
         return 0;
     return graph.getNodeAttribute(nodes[0], 'mtime');
 }
-function listFiles(graph, filter, limit = 20) {
+function listFiles(graph, filter, limit = defaults_1.LIST_LIMIT_SMALL) {
     const files = new Map();
     const lowerFilter = filter?.toLowerCase();
     graph.forEachNode((_, attrs) => {
@@ -133,23 +136,35 @@ function saveGraph(graph, graphMemory, embeddingFingerprint) {
     fs_1.default.mkdirSync(graphMemory, { recursive: true });
     const file = path_1.default.join(graphMemory, 'docs.json');
     const tmp = file + '.tmp';
-    fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: graph.export() }));
-    fs_1.default.renameSync(tmp, file);
+    try {
+        const exported = graph.export();
+        (0, embedding_codec_1.compressEmbeddings)(exported);
+        fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: exported }));
+        fs_1.default.renameSync(tmp, file);
+    }
+    catch (err) {
+        try {
+            fs_1.default.unlinkSync(tmp);
+        }
+        catch { /* ignore cleanup error */ }
+        throw err;
+    }
 }
 function loadGraph(graphMemory, fresh = false, embeddingFingerprint) {
     const graph = createGraph();
     if (fresh)
         return graph;
     const file = path_1.default.join(graphMemory, 'docs.json');
-    if (!fs_1.default.existsSync(file))
+    const data = (0, graph_persistence_1.readJsonWithTmpFallback)(file);
+    if (!data)
         return graph;
     try {
-        const data = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
         const stored = data.embeddingModel;
         if (embeddingFingerprint && stored !== embeddingFingerprint) {
             process.stderr.write(`[graph] Embedding config changed, re-indexing docs graph\n`);
             return graph;
         }
+        (0, embedding_codec_1.decompressEmbeddings)(data.graph);
         graph.import(data.graph);
         process.stderr.write(`[graph] Loaded ${graph.order} nodes, ${graph.size} edges\n`);
     }

package/dist/graphs/file-index.js

@@ -19,6 +19,9 @@ const file_index_types_1 = require("../graphs/file-index-types");
 const file_lang_1 = require("../graphs/file-lang");
 const manager_types_1 = require("../graphs/manager-types");
 const file_index_1 = require("../lib/search/file-index");
+const embedding_codec_1 = require("../lib/embedding-codec");
+const graph_persistence_1 = require("../lib/graph-persistence");
+const defaults_1 = require("../lib/defaults");
 // ---------------------------------------------------------------------------
 // CRUD
 // ---------------------------------------------------------------------------
@@ -147,7 +150,7 @@ function getFileEntryMtime(graph, filePath) {
  * Otherwise returns all file nodes matching the filters.
  */
 function listAllFiles(graph, options = {}) {
-    const { directory, extension, language, filter, limit = 50 } = options;
+    const { directory, extension, language, filter, limit = defaults_1.LIST_LIMIT_LARGE } = options;
     const lowerFilter = filter?.toLowerCase();
     const results = [];
     if (directory !== undefined) {
@@ -157,7 +160,8 @@ function listAllFiles(graph, options = {}) {
             return [];
         graph.forEachOutNeighbor(dirId, (childId) => {
             const attrs = graph.getNodeAttributes(childId);
-            if (graph.getEdgeAttribute(graph.edge(dirId, childId), 'kind') !== 'contains')
+            const edgeKey = graph.edge(dirId, childId);
+            if (!edgeKey || graph.getEdgeAttribute(edgeKey, 'kind') !== 'contains')
                 return;
             if (extension && attrs.extension !== extension)
                 return;
@@ -240,23 +244,35 @@ function saveFileIndexGraph(graph, graphMemory, embeddingFingerprint) {
     fs_1.default.mkdirSync(graphMemory, { recursive: true });
     const file = path_1.default.join(graphMemory, 'file-index.json');
     const tmp = file + '.tmp';
-    fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: graph.export() }));
-    fs_1.default.renameSync(tmp, file);
+    try {
+        const exported = graph.export();
+        (0, embedding_codec_1.compressEmbeddings)(exported);
+        fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: exported }));
+        fs_1.default.renameSync(tmp, file);
+    }
+    catch (err) {
+        try {
+            fs_1.default.unlinkSync(tmp);
+        }
+        catch { /* ignore cleanup error */ }
+        throw err;
+    }
 }
 function loadFileIndexGraph(graphMemory, fresh = false, embeddingFingerprint) {
     const graph = (0, file_index_types_1.createFileIndexGraph)();
     if (fresh)
         return graph;
     const file = path_1.default.join(graphMemory, 'file-index.json');
-    if (!fs_1.default.existsSync(file))
+    const data = (0, graph_persistence_1.readJsonWithTmpFallback)(file);
+    if (!data)
         return graph;
     try {
-        const data = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
         const stored = data.embeddingModel;
         if (embeddingFingerprint && stored !== embeddingFingerprint) {
             process.stderr.write(`[file-index] Embedding config changed, re-indexing file index\n`);
             return graph;
         }
+        (0, embedding_codec_1.decompressEmbeddings)(data.graph);
         graph.import(data.graph);
         process.stderr.write(`[file-index] Loaded ${graph.order} nodes, ${graph.size} edges\n`);
     }

package/dist/graphs/file-lang.js

@@ -15,7 +15,7 @@ exports.EXT_TO_LANGUAGE = {
     '.mjs': 'javascript',
     '.cjs': 'javascript',
     '.ts': 'typescript',
-    '.tsx': 'typescript',
+    '.tsx': 'tsx',
     '.mts': 'typescript',
     '.cts': 'typescript',
     // Web

package/dist/graphs/knowledge.js

@@ -28,6 +28,9 @@ const manager_types_1 = require("../graphs/manager-types");
 const knowledge_1 = require("../lib/search/knowledge");
 const bm25_1 = require("../lib/search/bm25");
 const file_mirror_1 = require("../lib/file-mirror");
+const embedding_codec_1 = require("../lib/embedding-codec");
+const graph_persistence_1 = require("../lib/graph-persistence");
+const defaults_1 = require("../lib/defaults");
 const attachment_types_1 = require("../graphs/attachment-types");
 const file_import_1 = require("../lib/file-import");
 // ---------------------------------------------------------------------------
@@ -161,7 +164,7 @@ function getNote(graph, noteId) {
     return { id: noteId, ...graph.getNodeAttributes(noteId) };
 }
 /** List notes with optional filter (substring in title/id) and tag filter. Excludes proxy nodes. */
-function listNotes(graph, filter, tag, limit = 20) {
+function listNotes(graph, filter, tag, limit = defaults_1.LIST_LIMIT_SMALL) {
     const lowerFilter = filter?.toLowerCase();
     const lowerTag = tag?.toLowerCase();
     const results = [];
@@ -178,7 +181,7 @@ function listNotes(graph, filter, tag, limit = 20) {
             if (!attrs.tags.some(t => t.toLowerCase() === lowerTag))
                 return;
         }
-        results.push({ id, title: attrs.title, content: attrs.content.slice(0, 500), tags: attrs.tags, updatedAt: attrs.updatedAt });
+        results.push({ id, title: attrs.title, content: attrs.content.slice(0, defaults_1.CONTENT_PREVIEW_LEN), tags: attrs.tags, updatedAt: attrs.updatedAt });
     });
     return results
         .sort((a, b) => b.updatedAt - a.updatedAt)
@@ -329,23 +332,35 @@ function saveKnowledgeGraph(graph, graphMemory, embeddingFingerprint) {
     fs_1.default.mkdirSync(graphMemory, { recursive: true });
     const file = path_1.default.join(graphMemory, 'knowledge.json');
     const tmp = file + '.tmp';
-    fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: graph.export() }));
-    fs_1.default.renameSync(tmp, file);
+    try {
+        const exported = graph.export();
+        (0, embedding_codec_1.compressEmbeddings)(exported);
+        fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: exported }));
+        fs_1.default.renameSync(tmp, file);
+    }
+    catch (err) {
+        try {
+            fs_1.default.unlinkSync(tmp);
+        }
+        catch { /* ignore cleanup error */ }
+        throw err;
+    }
 }
 function loadKnowledgeGraph(graphMemory, fresh = false, embeddingFingerprint) {
     const graph = (0, knowledge_types_1.createKnowledgeGraph)();
     if (fresh)
         return graph;
     const file = path_1.default.join(graphMemory, 'knowledge.json');
-    if (!fs_1.default.existsSync(file))
+    const data = (0, graph_persistence_1.readJsonWithTmpFallback)(file);
+    if (!data)
         return graph;
     try {
-        const data = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
         const stored = data.embeddingModel;
         if (embeddingFingerprint && stored !== embeddingFingerprint) {
             process.stderr.write(`[knowledge-graph] Embedding config changed, re-indexing knowledge graph\n`);
             return graph;
         }
+        (0, embedding_codec_1.decompressEmbeddings)(data.graph);
         graph.import(data.graph);
         process.stderr.write(`[knowledge-graph] Loaded ${graph.order} nodes, ${graph.size} edges\n`);
     }
@@ -552,7 +567,9 @@ class KnowledgeGraphManager {
         try {
             const actualToId = targetGraph ? proxyId(targetGraph, toId, pid) : toId;
             if (this._graph.hasEdge(fromId, actualToId)) {
-                kind = this._graph.getEdgeAttribute(this._graph.edge(fromId, actualToId), 'kind') ?? '';
+                const ek = this._graph.edge(fromId, actualToId);
+                if (ek)
+                    kind = this._graph.getEdgeAttribute(ek, 'kind') ?? '';
             }
         }
         catch { /* ignore */ }
@@ -586,6 +603,11 @@ class KnowledgeGraphManager {
             return null;
         if (!this._graph.hasNode(noteId) || isProxy(this._graph, noteId))
             return null;
+        if (data.length > attachment_types_1.MAX_ATTACHMENT_SIZE)
+            return null;
+        const existing = (0, attachment_types_1.scanAttachments)(path_1.default.join(dir, noteId));
+        if (existing.length >= attachment_types_1.MAX_ATTACHMENTS_PER_ENTITY)
+            return null;
         const safe = (0, file_mirror_1.sanitizeFilename)(filename);
         if (!safe)
             return null;
@@ -628,6 +650,8 @@ class KnowledgeGraphManager {
             return;
         const attachments = (0, attachment_types_1.scanAttachments)(path_1.default.join(dir, noteId));
         this._graph.setNodeAttribute(noteId, 'attachments', attachments);
+        this._graph.setNodeAttribute(noteId, 'updatedAt', Date.now());
+        this._graph.setNodeAttribute(noteId, 'version', (this._graph.getNodeAttribute(noteId, 'version') ?? 0) + 1);
         this.ctx.markDirty();
     }
     listAttachments(noteId) {

package/dist/graphs/skill.js

@@ -30,6 +30,9 @@ const manager_types_1 = require("../graphs/manager-types");
 const skills_1 = require("../lib/search/skills");
 const bm25_1 = require("../lib/search/bm25");
 const file_mirror_1 = require("../lib/file-mirror");
+const embedding_codec_1 = require("../lib/embedding-codec");
+const graph_persistence_1 = require("../lib/graph-persistence");
+const defaults_1 = require("../lib/defaults");
 const attachment_types_1 = require("../graphs/attachment-types");
 const file_import_1 = require("../lib/file-import");
 // ---------------------------------------------------------------------------
@@ -289,7 +292,7 @@ function getSkill(graph, skillId) {
 }
 /** List skills with optional filters. Excludes proxy nodes. */
 function listSkills(graph, opts = {}) {
-    const { source, tag, filter, limit = 50 } = opts;
+    const { source, tag, filter, limit = defaults_1.LIST_LIMIT_LARGE } = opts;
     const lowerFilter = filter?.toLowerCase();
     const lowerTag = tag?.toLowerCase();
     const results = [];
@@ -309,7 +312,7 @@ function listSkills(graph, opts = {}) {
         results.push({
             id,
             title: attrs.title,
-            description: attrs.description?.slice(0, 500),
+            description: attrs.description?.slice(0, defaults_1.CONTENT_PREVIEW_LEN),
             steps: attrs.steps,
             triggers: attrs.triggers,
             inputHints: attrs.inputHints,
@@ -473,23 +476,35 @@ function saveSkillGraph(graph, graphMemory, embeddingFingerprint) {
     fs_1.default.mkdirSync(graphMemory, { recursive: true });
     const file = path_1.default.join(graphMemory, 'skills.json');
     const tmp = file + '.tmp';
-    fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: graph.export() }));
-    fs_1.default.renameSync(tmp, file);
+    try {
+        const exported = graph.export();
+        (0, embedding_codec_1.compressEmbeddings)(exported);
+        fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: exported }));
+        fs_1.default.renameSync(tmp, file);
+    }
+    catch (err) {
+        try {
+            fs_1.default.unlinkSync(tmp);
+        }
+        catch { /* ignore cleanup error */ }
+        throw err;
+    }
 }
 function loadSkillGraph(graphMemory, fresh = false, embeddingFingerprint) {
     const graph = (0, skill_types_1.createSkillGraph)();
     if (fresh)
         return graph;
     const file = path_1.default.join(graphMemory, 'skills.json');
-    if (!fs_1.default.existsSync(file))
+    const data = (0, graph_persistence_1.readJsonWithTmpFallback)(file);
+    if (!data)
         return graph;
     try {
-        const data = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
         const stored = data.embeddingModel;
         if (embeddingFingerprint && stored !== embeddingFingerprint) {
             process.stderr.write(`[skill-graph] Embedding config changed, re-indexing skill graph\n`);
             return graph;
         }
+        (0, embedding_codec_1.decompressEmbeddings)(data.graph);
         graph.import(data.graph);
         process.stderr.write(`[skill-graph] Loaded ${graph.order} nodes, ${graph.size} edges\n`);
     }
@@ -760,7 +775,9 @@ class SkillGraphManager {
         try {
             const proxyNodeId = proxyId(targetGraph, targetId, pid);
             if (this._graph.hasEdge(skillId, proxyNodeId)) {
-                kind = this._graph.getEdgeAttribute(this._graph.edge(skillId, proxyNodeId), 'kind') ?? '';
+                const ek = this._graph.edge(skillId, proxyNodeId);
+                if (ek)
+                    kind = this._graph.getEdgeAttribute(ek, 'kind') ?? '';
             }
         }
         catch { /* ignore */ }
@@ -788,7 +805,9 @@ class SkillGraphManager {
         let kind = '';
         try {
             if (this._graph.hasEdge(fromId, toId)) {
-                kind = this._graph.getEdgeAttribute(this._graph.edge(fromId, toId), 'kind') ?? '';
+                const ek = this._graph.edge(fromId, toId);
+                if (ek)
+                    kind = this._graph.getEdgeAttribute(ek, 'kind') ?? '';
             }
         }
         catch { /* ignore */ }
@@ -812,10 +831,15 @@ class SkillGraphManager {
             return null;
         if (!this._graph.hasNode(skillId) || isProxy(this._graph, skillId))
             return null;
+        if (data.length > attachment_types_1.MAX_ATTACHMENT_SIZE)
+            return null;
+        const entityDir = path_1.default.join(dir, skillId);
+        const existing = (0, attachment_types_1.scanAttachments)(entityDir);
+        if (existing.length >= attachment_types_1.MAX_ATTACHMENTS_PER_ENTITY)
+            return null;
         const safe = (0, file_mirror_1.sanitizeFilename)(filename);
         if (!safe)
             return null;
-        const entityDir = path_1.default.join(dir, skillId);
         (0, file_mirror_1.writeAttachment)(dir, skillId, safe, data);
         this.mirrorTracker?.recordWrite(path_1.default.join(entityDir, 'attachments', safe));
         (0, file_mirror_1.mirrorAttachmentEvent)(entityDir, 'add', safe);
@@ -856,6 +880,8 @@ class SkillGraphManager {
             return;
         const attachments = (0, attachment_types_1.scanAttachments)(path_1.default.join(dir, skillId));
         this._graph.setNodeAttribute(skillId, 'attachments', attachments);
+        this._graph.setNodeAttribute(skillId, 'updatedAt', Date.now());
+        this._graph.setNodeAttribute(skillId, 'version', (this._graph.getNodeAttribute(skillId, 'version') ?? 0) + 1);
         this.ctx.markDirty();
     }
     listAttachments(skillId) {

package/dist/graphs/task.js

@@ -30,6 +30,9 @@ const manager_types_1 = require("../graphs/manager-types");
 const tasks_1 = require("../lib/search/tasks");
 const bm25_1 = require("../lib/search/bm25");
 const file_mirror_1 = require("../lib/file-mirror");
+const embedding_codec_1 = require("../lib/embedding-codec");
+const graph_persistence_1 = require("../lib/graph-persistence");
+const defaults_1 = require("../lib/defaults");
 const attachment_types_1 = require("../graphs/attachment-types");
 const file_import_1 = require("../lib/file-import");
 // ---------------------------------------------------------------------------
@@ -300,7 +303,7 @@ function getTask(graph, taskId) {
 }
 /** List tasks with optional filters. Excludes proxy nodes. */
 function listTasks(graph, opts = {}) {
-    const { status, priority, tag, filter, assignee, limit = 50 } = opts;
+    const { status, priority, tag, filter, assignee, limit = defaults_1.LIST_LIMIT_LARGE } = opts;
     const lowerFilter = filter?.toLowerCase();
     const lowerTag = tag?.toLowerCase();
     const results = [];
@@ -324,7 +327,7 @@ function listTasks(graph, opts = {}) {
         results.push({
             id,
             title: attrs.title,
-            description: attrs.description?.slice(0, 500),
+            description: attrs.description?.slice(0, defaults_1.CONTENT_PREVIEW_LEN),
             status: attrs.status,
             priority: attrs.priority,
             tags: attrs.tags,
@@ -494,23 +497,35 @@ function saveTaskGraph(graph, graphMemory, embeddingFingerprint) {
     fs_1.default.mkdirSync(graphMemory, { recursive: true });
     const file = path_1.default.join(graphMemory, 'tasks.json');
     const tmp = file + '.tmp';
-    fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: graph.export() }));
-    fs_1.default.renameSync(tmp, file);
+    try {
+        const exported = graph.export();
+        (0, embedding_codec_1.compressEmbeddings)(exported);
+        fs_1.default.writeFileSync(tmp, JSON.stringify({ embeddingModel: embeddingFingerprint, graph: exported }));
+        fs_1.default.renameSync(tmp, file);
+    }
+    catch (err) {
+        try {
+            fs_1.default.unlinkSync(tmp);
+        }
+        catch { /* ignore cleanup error */ }
+        throw err;
+    }
 }
 function loadTaskGraph(graphMemory, fresh = false, embeddingFingerprint) {
     const graph = (0, task_types_1.createTaskGraph)();
     if (fresh)
         return graph;
     const file = path_1.default.join(graphMemory, 'tasks.json');
-    if (!fs_1.default.existsSync(file))
+    const data = (0, graph_persistence_1.readJsonWithTmpFallback)(file);
+    if (!data)
         return graph;
     try {
-        const data = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
         const stored = data.embeddingModel;
         if (embeddingFingerprint && stored !== embeddingFingerprint) {
             process.stderr.write(`[task-graph] Embedding config changed, re-indexing task graph\n`);
             return graph;
         }
+        (0, embedding_codec_1.decompressEmbeddings)(data.graph);
         graph.import(data.graph);
         process.stderr.write(`[task-graph] Loaded ${graph.order} nodes, ${graph.size} edges\n`);
     }
@@ -733,7 +748,9 @@ class TaskGraphManager {
         try {
             const proxyNodeId = proxyId(targetGraph, targetId, pid);
             if (this._graph.hasEdge(taskId, proxyNodeId)) {
-                kind = this._graph.getEdgeAttribute(this._graph.edge(taskId, proxyNodeId), 'kind') ?? '';
+                const ek = this._graph.edge(taskId, proxyNodeId);
+                if (ek)
+                    kind = this._graph.getEdgeAttribute(ek, 'kind') ?? '';
             }
         }
         catch { /* ignore */ }
@@ -759,7 +776,9 @@ class TaskGraphManager {
         let kind = '';
         try {
             if (this._graph.hasEdge(fromId, toId)) {
-                kind = this._graph.getEdgeAttribute(this._graph.edge(fromId, toId), 'kind') ?? '';
+                const ek = this._graph.edge(fromId, toId);
+                if (ek)
+                    kind = this._graph.getEdgeAttribute(ek, 'kind') ?? '';
             }
         }
         catch { /* ignore */ }
@@ -783,10 +802,15 @@ class TaskGraphManager {
             return null;
         if (!this._graph.hasNode(taskId) || isProxy(this._graph, taskId))
             return null;
+        if (data.length > attachment_types_1.MAX_ATTACHMENT_SIZE)
+            return null;
+        const entityDir = path_1.default.join(dir, taskId);
+        const existing = (0, attachment_types_1.scanAttachments)(entityDir);
+        if (existing.length >= attachment_types_1.MAX_ATTACHMENTS_PER_ENTITY)
+            return null;
         const safe = (0, file_mirror_1.sanitizeFilename)(filename);
         if (!safe)
             return null;
-        const entityDir = path_1.default.join(dir, taskId);
         (0, file_mirror_1.writeAttachment)(dir, taskId, safe, data);
         this.mirrorTracker?.recordWrite(path_1.default.join(entityDir, 'attachments', safe));
         (0, file_mirror_1.mirrorAttachmentEvent)(entityDir, 'add', safe);
@@ -827,6 +851,8 @@ class TaskGraphManager {
             return;
         const attachments = (0, attachment_types_1.scanAttachments)(path_1.default.join(dir, taskId));
         this._graph.setNodeAttribute(taskId, 'attachments', attachments);
+        this._graph.setNodeAttribute(taskId, 'updatedAt', Date.now());
+        this._graph.setNodeAttribute(taskId, 'version', (this._graph.getNodeAttribute(taskId, 'version') ?? 0) + 1);
         this.ctx.markDirty();
     }
     listAttachments(taskId) {