hmem-mcp 6.0.3 → 6.1.1

package/dist/hmem-store.d.ts

@@ -425,8 +425,24 @@ export declare class HmemStore {
      */
     private parseTimeWindow;
     private nextSeq;
+    /** Read-only preview of the next root ID that write() would assign for this prefix.
+     *  Used by mcp-server's id-reservation loop (multi-agent collision prevention). */
+    peekNextId(prefix: string): string;
+    /** Read-only preview of the top-level child IDs that appendChildren() would create.
+     *  Used by mcp-server's sub-node reservation loop (multi-agent collision prevention).
+     *  Returns the IDs of direct children only — nested grandchildren don't need separate
+     *  reservation because they're parented under nodes this same call would create. */
+    peekAppendTopLevelIds(parentId: string, content: string): string[];
     /** Clear all active markers — called at MCP server start so each session starts neutral. */
     clearAllActive(): void;
+    /**
+     * Atomically set ONE project as the active P-entry in this agent's DB.
+     * Deactivates all other P-entries in the same .hmem file. Multi-agent isolation
+     * happens at the .hmem-file level (each agent has its own DB), so within a single
+     * file there must only ever be one active project — otherwise getActiveProject()
+     * (LIMIT 1) becomes nondeterministic and log-exchange routes to the wrong O-entry.
+     */
+    setActiveProject(id: string): void;
     /** Auto-resolve linked entries on an entry (extracted for reuse in chain resolution). */
     private resolveEntryLinks;
     /** Get child nodes created after a given ISO timestamp (for "new since last session" detection). */
@@ -571,6 +587,20 @@ export declare class HmemStore {
      * Rewrites all IDs, parent_ids, root_ids, tags, and FTS rowid map entries.
      */
     private _moveSubtree;
+    /**
+     * Rename an entire L2 session subtree (L2 node + all L3/L4/L5 descendants)
+     * to a new id prefix. Updates memory_nodes (id, parent_id, seq), memory_tags,
+     * and hmem_fts_rowid_map. The root-level parent of the L2 node stays at oId.
+     * Caller must ensure newId does not yet exist.
+     */
+    private _renameL2Subtree;
+    /**
+     * Reorder L2 sessions under an O-entry so their seq matches chronological
+     * order by created_at (ascending). Uses 2-phase rename via _TMP staging IDs
+     * to avoid collisions during renumbering. Returns the number of sessions
+     * actually renamed.
+     */
+    reorderSessionsByDate(oId: string): number;
     /**
      * Remove empty L2 (sessions) and L3 (batches) nodes in an O-entry.
      */

package/dist/hmem-store.js

@@ -361,6 +361,24 @@ export class HmemStore {
             if (prefix === "P") {
                 this.db.prepare("UPDATE memories SET active = 1 WHERE id = ?").run(rootId);
             }
+            // Auto-scaffold E-entries: create standard L2 structure when no children provided
+            if (prefix === "E" && nodes.length === 0) {
+                const eSchema = ["Analysis", "Possible fixes", "Fixing attempts", "Solution", "Cause", "Key Learnings"];
+                for (let i = 0; i < eSchema.length; i++) {
+                    const nodeId = `${rootId}.${i + 1}`;
+                    insertNode.run(nodeId, rootId, rootId, 2, i + 1, eSchema[i], eSchema[i], timestamp, timestamp);
+                }
+                // Move L1 body into .1 Analysis as content (the short description stays on L1)
+                if (level1 !== title) {
+                    // level1 contains body text — move it to Analysis node
+                    this.db.prepare("UPDATE memory_nodes SET content = ?, title = ? WHERE id = ?")
+                        .run(level1, "Analysis", `${rootId}.1`);
+                }
+                // Auto-add #open tag on root (visible in bulk-read title line)
+                if (!validatedTags.includes("#open")) {
+                    this.addTag(rootId, "#open");
+                }
+            }
         })();
         return { id: rootId, timestamp };
     }
@@ -714,7 +732,7 @@ export class HmemStore {
         // Step 0.5: Detect active-prefixes — prefixes where at least one entry has active=1.
         // Non-active entries in these prefixes are still shown (as compact titles) but don't get expansion slots.
         // P and I prefixes ALWAYS treated as active-prefix — only expand when explicitly activated.
-        const activePrefixes = new Set(["P", "I"]);
+        const activePrefixes = new Set(["P", "I", "E"]);
         for (const r of activeRows) {
             if (r.active === 1)
                 activePrefixes.add(r.prefix);
@@ -1608,14 +1626,21 @@ export class HmemStore {
                 if (trimmed.length > nodeLimit * HmemStore.CHAR_LIMIT_TOLERANCE) {
                     throw new Error(`Content exceeds ${nodeLimit} character limit (${trimmed.length} chars) for L${nodeRow.depth}.`);
                 }
-                // Parse > body lines: first non-> line = title, > lines = body (content)
+                // Parse body: "> " prefix (legacy) or blank-line separator (git-commit style)
                 const lines = trimmed.split("\n");
                 const titleLines = [];
                 const bodyLines = [];
+                let bodyMode = false;
                 for (const line of lines) {
                     if (line.startsWith("> ") || line === ">") {
                         bodyLines.push(line.replace(/^> ?/, ""));
                     }
+                    else if (line === "" && titleLines.length > 0) {
+                        bodyMode = true;
+                    }
+                    else if (bodyMode) {
+                        bodyLines.push(line);
+                    }
                     else {
                         titleLines.push(line);
                     }
@@ -1671,18 +1696,26 @@ export class HmemStore {
         else {
             // Root entry in memories
             if (trimmed) {
-                // Split into title lines, body lines (> prefix), and child lines (indented)
+                // Split into title lines, body lines ("> " legacy or blank-line separator), and child lines (indented)
                 const lines = trimmed.split("\n");
                 const titleLines = [];
                 const bodyLines = [];
                 const childLines = [];
+                let bodyMode = false;
                 for (const line of lines) {
                     if (line.startsWith("\t") || (line.length > 0 && line[0] === " " && line.trimStart() !== line)) {
                         childLines.push(line);
+                        bodyMode = false; // indented line exits body mode
                     }
                     else if (line.startsWith("> ") || line === ">") {
                         bodyLines.push(line.replace(/^> ?/, ""));
                     }
+                    else if (line === "" && titleLines.length > 0 && childLines.length === 0) {
+                        bodyMode = true;
+                    }
+                    else if (bodyMode) {
+                        bodyLines.push(line);
+                    }
                     else {
                         titleLines.push(line);
                     }
@@ -2305,10 +2338,53 @@ export class HmemStore {
         const row = this.db.prepare("SELECT MAX(seq) as maxSeq FROM memories WHERE prefix = ?").get(prefix);
         return (row?.maxSeq || 0) + 1;
     }
+    /** Read-only preview of the next root ID that write() would assign for this prefix.
+     *  Used by mcp-server's id-reservation loop (multi-agent collision prevention). */
+    peekNextId(prefix) {
+        prefix = prefix.toUpperCase();
+        const seq = this.nextSeq(prefix);
+        return `${prefix}${String(seq).padStart(4, "0")}`;
+    }
+    /** Read-only preview of the top-level child IDs that appendChildren() would create.
+     *  Used by mcp-server's sub-node reservation loop (multi-agent collision prevention).
+     *  Returns the IDs of direct children only — nested grandchildren don't need separate
+     *  reservation because they're parented under nodes this same call would create. */
+    peekAppendTopLevelIds(parentId, content) {
+        const parentIsRoot = !parentId.includes(".");
+        // Verify parent exists (mirrors appendChildren guard, but throws same shape)
+        if (parentIsRoot) {
+            if (!this.db.prepare("SELECT id FROM memories WHERE id = ?").get(parentId))
+                return [];
+        }
+        else {
+            if (!this.db.prepare("SELECT id FROM memory_nodes WHERE id = ?").get(parentId))
+                return [];
+        }
+        const parentDepth = parentIsRoot ? 1 : (parentId.match(/\./g).length + 1);
+        const maxSeqRow = this.db.prepare("SELECT MAX(seq) as maxSeq FROM memory_nodes WHERE parent_id = ?").get(parentId);
+        const startSeq = (maxSeqRow?.maxSeq ?? 0) + 1;
+        const nodes = this.parseRelativeTree(content, parentId, parentDepth, startSeq);
+        return nodes.filter(n => n.parent_id === parentId).map(n => n.id);
+    }
     /** Clear all active markers — called at MCP server start so each session starts neutral. */
     clearAllActive() {
         this.db.prepare("UPDATE memories SET active = 0 WHERE active = 1").run();
     }
+    /**
+     * Atomically set ONE project as the active P-entry in this agent's DB.
+     * Deactivates all other P-entries in the same .hmem file. Multi-agent isolation
+     * happens at the .hmem-file level (each agent has its own DB), so within a single
+     * file there must only ever be one active project — otherwise getActiveProject()
+     * (LIMIT 1) becomes nondeterministic and log-exchange routes to the wrong O-entry.
+     */
+    setActiveProject(id) {
+        const now = new Date().toISOString();
+        const tx = this.db.transaction(() => {
+            this.db.prepare("UPDATE memories SET active = 0, updated_at = ? WHERE prefix = 'P' AND active = 1 AND id != ?").run(now, id);
+            this.db.prepare("UPDATE memories SET active = 1, updated_at = ? WHERE id = ?").run(now, id);
+        });
+        tx();
+    }
     /** Auto-resolve linked entries on an entry (extracted for reuse in chain resolution). */
     resolveEntryLinks(entry, opts) {
         const linkDepth = opts.resolveLinks === false ? 0 : (opts.linkDepth ?? 1);
@@ -2691,6 +2767,7 @@ export class HmemStore {
         if (!targetExists) {
             return { moved: 0, errors: [`Target ${targetOId} does not exist`] };
         }
+        const l2MovedIntoTarget = new Set();
         const doMove = this.db.transaction(() => {
             for (const nodeId of nodeIds) {
                 const node = this.readNode(nodeId);
@@ -2707,6 +2784,7 @@ export class HmemStore {
                 if (node.depth === 2) {
                     // L2 session — re-parent directly under target O
                     this._moveSubtree(nodeId, sourceOId, targetOId, targetOId, 2);
+                    l2MovedIntoTarget.add(targetOId);
                 }
                 else if (node.depth === 3) {
                     // L3 batch — find/create session in target O
@@ -2727,6 +2805,12 @@ export class HmemStore {
                 this._cleanupEmptyParents(sourceOId);
                 moved++;
             }
+            // After moving L2 sessions into a target O, re-sort siblings by created_at
+            // so the moved session lands in its chronologically correct slot rather than
+            // at the end of the seq space.
+            for (const oId of l2MovedIntoTarget) {
+                this.reorderSessionsByDate(oId);
+            }
         });
         doMove();
         return { moved, errors };
@@ -2815,6 +2899,74 @@ export class HmemStore {
         const timestamp = new Date().toISOString();
         this.db.prepare("UPDATE memories SET updated_at = ? WHERE id = ?").run(timestamp, targetOId);
     }
+    /**
+     * Rename an entire L2 session subtree (L2 node + all L3/L4/L5 descendants)
+     * to a new id prefix. Updates memory_nodes (id, parent_id, seq), memory_tags,
+     * and hmem_fts_rowid_map. The root-level parent of the L2 node stays at oId.
+     * Caller must ensure newId does not yet exist.
+     */
+    _renameL2Subtree(oId, oldId, newId) {
+        const nodes = this.db.prepare("SELECT id, parent_id FROM memory_nodes WHERE id = ? OR id LIKE ?").all(oldId, `${oldId}.%`);
+        const newSeqMatch = newId.match(/\.(\d+)$/);
+        const newSeq = newSeqMatch ? parseInt(newSeqMatch[1], 10) : null;
+        for (const n of nodes) {
+            const nid = n.id === oldId ? newId : n.id.replace(oldId + ".", newId + ".");
+            const pid = n.id === oldId
+                ? oId
+                : (n.parent_id === oldId ? newId : n.parent_id.replace(oldId + ".", newId + "."));
+            if (n.id === oldId && newSeq !== null) {
+                this.db.prepare("UPDATE memory_nodes SET id = ?, parent_id = ?, seq = ? WHERE id = ?")
+                    .run(nid, pid, newSeq, n.id);
+            }
+            else {
+                this.db.prepare("UPDATE memory_nodes SET id = ?, parent_id = ? WHERE id = ?")
+                    .run(nid, pid, n.id);
+            }
+        }
+        // Tags
+        const tagRows = this.db.prepare("SELECT entry_id, tag FROM memory_tags WHERE entry_id = ? OR entry_id LIKE ?").all(oldId, `${oldId}.%`);
+        for (const t of tagRows) {
+            const newEntryId = t.entry_id === oldId ? newId : t.entry_id.replace(oldId + ".", newId + ".");
+            this.db.prepare("DELETE FROM memory_tags WHERE entry_id = ? AND tag = ?").run(t.entry_id, t.tag);
+            this.db.prepare("INSERT OR IGNORE INTO memory_tags (entry_id, tag) VALUES (?, ?)").run(newEntryId, t.tag);
+        }
+        // FTS rowid map
+        const ftsRows = this.db.prepare("SELECT fts_rowid, node_id FROM hmem_fts_rowid_map WHERE node_id = ? OR node_id LIKE ?").all(oldId, `${oldId}.%`);
+        for (const f of ftsRows) {
+            const newNodeId = f.node_id === oldId ? newId : f.node_id.replace(oldId + ".", newId + ".");
+            this.db.prepare("UPDATE hmem_fts_rowid_map SET node_id = ? WHERE fts_rowid = ?").run(newNodeId, f.fts_rowid);
+        }
+    }
+    /**
+     * Reorder L2 sessions under an O-entry so their seq matches chronological
+     * order by created_at (ascending). Uses 2-phase rename via _TMP staging IDs
+     * to avoid collisions during renumbering. Returns the number of sessions
+     * actually renamed.
+     */
+    reorderSessionsByDate(oId) {
+        const sessions = this.db.prepare("SELECT id, seq, created_at FROM memory_nodes WHERE parent_id = ? AND depth = 2 ORDER BY created_at ASC, seq ASC").all(oId);
+        const renames = [];
+        for (let i = 0; i < sessions.length; i++) {
+            const desiredSeq = i + 1;
+            if (sessions[i].seq !== desiredSeq) {
+                renames.push({ from: sessions[i].id, to: `${oId}.${desiredSeq}` });
+            }
+        }
+        if (renames.length === 0)
+            return 0;
+        const tx = this.db.transaction(() => {
+            // Phase 1: move every affected session into staging
+            for (let i = 0; i < renames.length; i++) {
+                this._renameL2Subtree(oId, renames[i].from, `${oId}._TMP${i}`);
+            }
+            // Phase 2: rename staging → final
+            for (let i = 0; i < renames.length; i++) {
+                this._renameL2Subtree(oId, `${oId}._TMP${i}`, renames[i].to);
+            }
+        });
+        tx();
+        return renames.length;
+    }
     /**
      * Remove empty L2 (sessions) and L3 (batches) nodes in an O-entry.
      */
@@ -3178,8 +3330,12 @@ export class HmemStore {
         const nodes = [];
         const l1Title = [];
         const l1Body = [];
+        let l1BodyMode = false; // true after blank line at L1 depth
         // Auto-detect space indentation unit: use first indented line (if no tabs present)
-        const rawLines = content.split("\n").map(l => l.trimEnd()).filter(Boolean);
+        const rawLines = content.split("\n").map(l => l.trimEnd());
+        // Keep blank lines for body detection but trim trailing empties
+        while (rawLines.length > 0 && rawLines[rawLines.length - 1] === "")
+            rawLines.pop();
         let spaceUnit = 4;
         if (!rawLines.some(l => l.startsWith("\t"))) {
             for (const l of rawLines) {
@@ -3190,10 +3346,19 @@ export class HmemStore {
                 }
             }
         }
+        // Track body mode per depth: after a blank line, subsequent lines at that depth are body
+        const bodyModeAtDepth = new Map();
         for (const line of rawLines) {
             const trimmedEnd = line;
-            if (!trimmedEnd)
+            // Blank line: activate body mode for L1 and for the last node's depth
+            if (!trimmedEnd) {
+                l1BodyMode = true;
+                // Activate body mode for the last node's depth (L2+)
+                if (nodes.length > 0) {
+                    bodyModeAtDepth.set(nodes[nodes.length - 1].depth, true);
+                }
                 continue;
+            }
             // Count leading tabs; fall back to auto-detected space unit
             const tabMatch = trimmedEnd.match(/^\t*/);
             const leadingTabs = tabMatch ? tabMatch[0].length : 0;
@@ -3207,9 +3372,11 @@ export class HmemStore {
                 depth = spaceTabs > 0 ? Math.min(spaceTabs, 4) + 1 : 1;
             }
             const text = trimmedEnd.trim();
-            // Body line detection: "> " prefix marks body text for the preceding node
-            const isBodyLine = text.startsWith("> ") || text === ">";
-            const bodyText = isBodyLine ? text.replace(/^> ?/, "") : "";
+            // Body line detection: "> " prefix (legacy) OR blank-line-activated body mode
+            const isLegacyBody = text.startsWith("> ") || text === ">";
+            const isBlankLineBody = depth === 1 ? l1BodyMode : bodyModeAtDepth.get(depth) === true;
+            const isBodyLine = isLegacyBody || isBlankLineBody;
+            const bodyText = isLegacyBody ? text.replace(/^> ?/, "") : text;
             if (depth === 1) {
                 if (isBodyLine) {
                     l1Body.push(bodyText);
@@ -3219,6 +3386,10 @@ export class HmemStore {
                 }
                 continue;
             }
+            // Depth changed → exit body mode for other depths
+            if (!isBodyLine) {
+                bodyModeAtDepth.delete(depth);
+            }
             if (isBodyLine) {
                 // Append body to the last node at this depth
                 const lastNode = nodes.length > 0 ? nodes[nodes.length - 1] : null;
@@ -3233,6 +3404,8 @@ export class HmemStore {
                 }
                 continue;
             }
+            // New node resets body mode for this depth
+            bodyModeAtDepth.delete(depth);
             // L2+: determine parent and generate compound ID
             const parentId = depth === 2 ? rootId : (lastIdAtDepth.get(depth - 1) ?? rootId);
             const seq = (seqAtParent.get(parentId) ?? 0) + 1;
@@ -3278,7 +3451,9 @@ export class HmemStore {
         seqAtParent.set(parentId, startSeq - 1);
         const lastIdAtRelDepth = new Map();
         const nodes = [];
-        const rawLines = content.split("\n").map(l => l.trimEnd()).filter(Boolean);
+        const rawLines = content.split("\n").map(l => l.trimEnd());
+        while (rawLines.length > 0 && rawLines[rawLines.length - 1] === "")
+            rawLines.pop();
         // Auto-detect space unit if no tabs used
         let spaceUnit = 4;
         if (!rawLines.some(l => l.startsWith("\t"))) {
@@ -3291,10 +3466,16 @@ export class HmemStore {
             }
         }
         const maxAbsDepth = this.cfg.maxDepth;
+        const bodyModeAtDepth = new Map();
         for (const line of rawLines) {
             const text = line.trim();
-            if (!text)
+            // Blank line: activate body mode for the last node's depth
+            if (!text) {
+                if (nodes.length > 0) {
+                    bodyModeAtDepth.set(nodes[nodes.length - 1].depth, true);
+                }
                 continue;
+            }
             // Count leading tabs; fall back to space-based detection
             const tabMatch = line.match(/^\t*/);
             const leadingTabs = tabMatch ? tabMatch[0].length : 0;
@@ -3309,10 +3490,12 @@ export class HmemStore {
             const absDepth = parentDepth + 1 + relDepth;
             if (absDepth > maxAbsDepth)
                 continue; // silently skip beyond max depth
-            // Body line detection: "> " prefix marks body text for the preceding node
-            const isBodyLine = text.startsWith("> ") || text === ">";
+            // Body line detection: "> " prefix (legacy) OR blank-line-activated body mode
+            const isLegacyBody = text.startsWith("> ") || text === ">";
+            const isBlankLineBody = bodyModeAtDepth.get(absDepth) === true;
+            const isBodyLine = isLegacyBody || isBlankLineBody;
             if (isBodyLine) {
-                const bodyText = text.replace(/^> ?/, "");
+                const bodyText = isLegacyBody ? text.replace(/^> ?/, "") : text;
                 const lastNode = nodes.length > 0 ? nodes[nodes.length - 1] : null;
                 if (lastNode && lastNode.depth === absDepth) {
                     if (lastNode.content === lastNode.title) {
@@ -3324,6 +3507,8 @@ export class HmemStore {
                 }
                 continue;
             }
+            // New node resets body mode for this depth
+            bodyModeAtDepth.delete(absDepth);
             const myParentId = relDepth === 0
                 ? parentId
                 : (lastIdAtRelDepth.get(relDepth - 1) ?? parentId);