@hir4ta/memoria 0.14.0 → 0.14.2

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "memoria",
   "description": "A plugin that provides long-term memory for Claude Code. It automatically saves context lost during auto-compact, offering features for session restoration, recording technical decisions, and learning developer patterns.",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "author": {
     "name": "hir4ta"
   },

package/bin/memoria.js

@@ -5,6 +5,22 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
+// Suppress Node.js SQLite experimental warning (must be before dynamic import)
+const originalEmit = process.emit;
+process.emit = function (name, data, ...args) {
+  if (
+    name === "warning" &&
+    data?.name === "ExperimentalWarning" &&
+    data?.message?.includes("SQLite")
+  ) {
+    return false;
+  }
+  return originalEmit.call(process, name, data, ...args);
+};
+
+// Dynamic import to ensure warning suppression is active
+const { DatabaseSync } = await import("node:sqlite");
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
@@ -45,6 +61,7 @@ function initMemoria() {
   const rulesDir = path.join(memoriaDir, "rules");
   const patternsDir = path.join(memoriaDir, "patterns");
   const tagsPath = path.join(memoriaDir, "tags.json");
+  const dbPath = path.join(memoriaDir, "local.db");
 
   // Check if already initialized
   if (fs.existsSync(memoriaDir)) {
@@ -82,6 +99,22 @@ function initMemoria() {
   );
   fs.writeFileSync(path.join(rulesDir, "dev-rules.json"), rulesTemplate);
 
+  // Initialize SQLite database
+  const schemaPath = path.join(packageDir, "lib", "schema.sql");
+  try {
+    const db = new DatabaseSync(dbPath);
+    db.exec("PRAGMA journal_mode = WAL");
+    if (fs.existsSync(schemaPath)) {
+      const schema = fs.readFileSync(schemaPath, "utf-8");
+      db.exec(schema);
+    }
+    db.close();
+  } catch (error) {
+    console.error(
+      `Warning: Failed to initialize SQLite database: ${error.message}`,
+    );
+  }
+
   console.log(`memoria initialized: ${memoriaDir}`);
   console.log(`
 Created:
@@ -91,6 +124,7 @@ Created:
   ${tagsPath}
   ${rulesDir}/review-guidelines.json
   ${rulesDir}/dev-rules.json
+  ${dbPath}
 
 You can now use memoria with Claude Code in this project.
 `);

package/dist/lib/db.js

@@ -3,7 +3,14 @@ import { execSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import Database from "better-sqlite3";
+var originalEmit = process.emit;
+process.emit = function(name, data, ...args) {
+  if (name === "warning" && typeof data === "object" && data?.name === "ExperimentalWarning" && data?.message?.includes("SQLite")) {
+    return false;
+  }
+  return originalEmit.call(process, name, data, ...args);
+};
+var { DatabaseSync } = await import("node:sqlite");
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
 function getCurrentUser() {
@@ -22,8 +29,8 @@ function getDbPath(memoriaDir) {
 }
 function initDatabase(memoriaDir) {
   const dbPath = getDbPath(memoriaDir);
-  const db = new Database(dbPath);
-  db.pragma("journal_mode = WAL");
+  const db = new DatabaseSync(dbPath);
+  db.exec("PRAGMA journal_mode = WAL");
   const schemaPath = join(__dirname, "schema.sql");
   if (existsSync(schemaPath)) {
     const schema = readFileSync(schemaPath, "utf-8");
@@ -36,30 +43,34 @@ function openDatabase(memoriaDir) {
   if (!existsSync(dbPath)) {
     return null;
   }
-  const db = new Database(dbPath);
-  db.pragma("journal_mode = WAL");
+  const db = new DatabaseSync(dbPath);
+  db.exec("PRAGMA journal_mode = WAL");
   return db;
 }
 function insertInteractions(db, interactions) {
   const insert = db.prepare(`
     INSERT INTO interactions (session_id, owner, role, content, thinking, tool_calls, timestamp, is_compact_summary)
-    VALUES (@session_id, @owner, @role, @content, @thinking, @tool_calls, @timestamp, @is_compact_summary)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
   `);
-  const insertMany = db.transaction((items) => {
-    for (const item of items) {
-      insert.run({
-        session_id: item.session_id,
-        owner: item.owner,
-        role: item.role,
-        content: item.content,
-        thinking: item.thinking || null,
-        tool_calls: item.tool_calls || null,
-        timestamp: item.timestamp,
-        is_compact_summary: item.is_compact_summary || 0
-      });
+  db.exec("BEGIN TRANSACTION");
+  try {
+    for (const item of interactions) {
+      insert.run(
+        item.session_id,
+        item.owner,
+        item.role,
+        item.content,
+        item.thinking || null,
+        item.tool_calls || null,
+        item.timestamp,
+        item.is_compact_summary || 0
+      );
     }
-  });
-  insertMany(interactions);
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  }
 }
 function getInteractions(db, sessionId) {
   const stmt = db.prepare(`
@@ -77,6 +88,42 @@ function getInteractionsByOwner(db, sessionId, owner) {
   `);
   return stmt.all(sessionId, owner);
 }
+function getInteractionsBySessionIds(db, sessionIds) {
+  if (sessionIds.length === 0) {
+    return [];
+  }
+  const placeholders = sessionIds.map(() => "?").join(", ");
+  const stmt = db.prepare(`
+    SELECT * FROM interactions
+    WHERE session_id IN (${placeholders})
+    ORDER BY timestamp ASC, session_id ASC, role ASC
+  `);
+  return stmt.all(...sessionIds);
+}
+function getInteractionsBySessionIdsAndOwner(db, sessionIds, owner) {
+  if (sessionIds.length === 0) {
+    return [];
+  }
+  const placeholders = sessionIds.map(() => "?").join(", ");
+  const stmt = db.prepare(`
+    SELECT * FROM interactions
+    WHERE session_id IN (${placeholders}) AND owner = ?
+    ORDER BY timestamp ASC, session_id ASC, role ASC
+  `);
+  return stmt.all(...sessionIds, owner);
+}
+function hasInteractionsForSessionIds(db, sessionIds, owner) {
+  if (sessionIds.length === 0) {
+    return false;
+  }
+  const placeholders = sessionIds.map(() => "?").join(", ");
+  const stmt = db.prepare(`
+    SELECT COUNT(*) as count FROM interactions
+    WHERE session_id IN (${placeholders}) AND owner = ?
+  `);
+  const result = stmt.get(...sessionIds, owner);
+  return result.count > 0;
+}
 function hasInteractions(db, sessionId, owner) {
   const stmt = db.prepare(`
     SELECT COUNT(*) as count FROM interactions
@@ -88,9 +135,9 @@ function hasInteractions(db, sessionId, owner) {
 function insertPreCompactBackup(db, backup) {
   const stmt = db.prepare(`
     INSERT INTO pre_compact_backups (session_id, owner, interactions)
-    VALUES (@session_id, @owner, @interactions)
+    VALUES (?, ?, ?)
   `);
-  stmt.run(backup);
+  stmt.run(backup.session_id, backup.owner, backup.interactions);
 }
 function getLatestBackup(db, sessionId) {
   const stmt = db.prepare(`
@@ -146,8 +193,11 @@ export {
   getDbStats,
   getInteractions,
   getInteractionsByOwner,
+  getInteractionsBySessionIds,
+  getInteractionsBySessionIdsAndOwner,
   getLatestBackup,
   hasInteractions,
+  hasInteractionsForSessionIds,
   initDatabase,
   insertInteractions,
   insertPreCompactBackup,

package/dist/server.js

@@ -2882,7 +2882,14 @@ import { execSync } from "node:child_process";
 import { existsSync as existsSync2, readFileSync } from "node:fs";
 import { dirname, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
-import Database from "better-sqlite3";
+var originalEmit = process.emit;
+process.emit = function(name, data, ...args) {
+  if (name === "warning" && typeof data === "object" && data?.name === "ExperimentalWarning" && data?.message?.includes("SQLite")) {
+    return false;
+  }
+  return originalEmit.call(process, name, data, ...args);
+};
+var { DatabaseSync } = await import("node:sqlite");
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
 function getCurrentUser() {
@@ -2904,24 +2911,32 @@ function openDatabase(memoriaDir2) {
   if (!existsSync2(dbPath)) {
     return null;
   }
-  const db = new Database(dbPath);
-  db.pragma("journal_mode = WAL");
+  const db = new DatabaseSync(dbPath);
+  db.exec("PRAGMA journal_mode = WAL");
   return db;
 }
-function getInteractions(db, sessionId) {
+function getInteractionsBySessionIdsAndOwner(db, sessionIds, owner) {
+  if (sessionIds.length === 0) {
+    return [];
+  }
+  const placeholders = sessionIds.map(() => "?").join(", ");
   const stmt = db.prepare(`
     SELECT * FROM interactions
-    WHERE session_id = ?
-    ORDER BY timestamp ASC
+    WHERE session_id IN (${placeholders}) AND owner = ?
+    ORDER BY timestamp ASC, session_id ASC, role ASC
   `);
-  return stmt.all(sessionId);
+  return stmt.all(...sessionIds, owner);
 }
-function hasInteractions(db, sessionId, owner) {
+function hasInteractionsForSessionIds(db, sessionIds, owner) {
+  if (sessionIds.length === 0) {
+    return false;
+  }
+  const placeholders = sessionIds.map(() => "?").join(", ");
   const stmt = db.prepare(`
     SELECT COUNT(*) as count FROM interactions
-    WHERE session_id = ? AND owner = ?
+    WHERE session_id IN (${placeholders}) AND owner = ?
   `);
-  const result = stmt.get(sessionId, owner);
+  const result = stmt.get(...sessionIds, owner);
   return result.count > 0;
 }
 
@@ -3546,13 +3561,59 @@ app.get("/api/current-user", async (c) => {
 app.get("/api/sessions/:id/interactions", async (c) => {
   const id = sanitizeId(c.req.param("id"));
   const memoriaDir2 = getMemoriaDir();
+  const sessionLinksDir = path3.join(memoriaDir2, "session-links");
+  const sessionsDir = path3.join(memoriaDir2, "sessions");
   try {
     const currentUser = getCurrentUser();
     const db = openDatabase(memoriaDir2);
     if (!db) {
       return c.json({ interactions: [], count: 0, isOwner: false });
     }
-    const isOwner = hasInteractions(db, id, currentUser);
+    let masterId = id;
+    const myLinkFile = path3.join(sessionLinksDir, `${id}.json`);
+    if (fs4.existsSync(myLinkFile)) {
+      try {
+        const myLinkData = JSON.parse(fs4.readFileSync(myLinkFile, "utf-8"));
+        if (myLinkData.masterSessionId) {
+          masterId = myLinkData.masterSessionId;
+        }
+      } catch {
+      }
+    }
+    const sessionIds = [masterId];
+    if (masterId !== id) {
+      sessionIds.push(id);
+    }
+    if (fs4.existsSync(sessionLinksDir)) {
+      const linkFiles = fs4.readdirSync(sessionLinksDir);
+      for (const linkFile of linkFiles) {
+        if (!linkFile.endsWith(".json")) continue;
+        const linkPath = path3.join(sessionLinksDir, linkFile);
+        try {
+          const linkData = JSON.parse(fs4.readFileSync(linkPath, "utf-8"));
+          if (linkData.masterSessionId === masterId) {
+            const childId = linkFile.replace(".json", "");
+            if (!sessionIds.includes(childId)) {
+              sessionIds.push(childId);
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    const sessionFiles = listDatedJsonFiles(sessionsDir);
+    for (const sessionFile of sessionFiles) {
+      try {
+        const sessionData = JSON.parse(fs4.readFileSync(sessionFile, "utf-8"));
+        if (sessionData.resumedFrom === masterId && sessionData.id !== masterId) {
+          if (!sessionIds.includes(sessionData.id)) {
+            sessionIds.push(sessionData.id);
+          }
+        }
+      } catch {
+      }
+    }
+    const isOwner = hasInteractionsForSessionIds(db, sessionIds, currentUser);
     if (!isOwner) {
       db.close();
       return c.json(
@@ -3560,7 +3621,11 @@ app.get("/api/sessions/:id/interactions", async (c) => {
         403
       );
     }
-    const interactions = getInteractions(db, id);
+    const interactions = getInteractionsBySessionIdsAndOwner(
+      db,
+      sessionIds,
+      currentUser
+    );
     db.close();
     const groupedInteractions = [];
     let currentInteraction = null;

package/hooks/session-end.sh

@@ -38,6 +38,7 @@ fi
 cwd=$(cd "$cwd" 2>/dev/null && pwd || echo "$cwd")
 memoria_dir="${cwd}/.memoria"
 sessions_dir="${memoria_dir}/sessions"
+session_links_dir="${memoria_dir}/session-links"
 db_path="${memoria_dir}/local.db"
 
 # Find session file
@@ -274,4 +275,32 @@ else
     echo "[memoria] Session completed (no transcript): ${session_file}" >&2
 fi
 
+# ============================================
+# Update master session workPeriods.endedAt (if linked)
+# ============================================
+session_link_file="${session_links_dir}/${session_short_id}.json"
+if [ -f "$session_link_file" ]; then
+    master_session_id=$(jq -r '.masterSessionId // empty' "$session_link_file" 2>/dev/null || echo "")
+    if [ -n "$master_session_id" ]; then
+        master_session_path=$(find "$sessions_dir" -name "${master_session_id}.json" -type f 2>/dev/null | head -1)
+        if [ -n "$master_session_path" ] && [ -f "$master_session_path" ]; then
+            end_now=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+            claude_session_id="${session_id}"
+            # Update the workPeriod entry with matching claudeSessionId
+            jq --arg claudeSessionId "$claude_session_id" \
+               --arg endedAt "$end_now" '
+                .workPeriods = [.workPeriods[]? |
+                    if .claudeSessionId == $claudeSessionId and .endedAt == null
+                    then .endedAt = $endedAt
+                    else .
+                    end
+                ] |
+                .updatedAt = $endedAt
+            ' "$master_session_path" > "${master_session_path}.tmp" \
+                && mv "${master_session_path}.tmp" "$master_session_path"
+            echo "[memoria] Master session workPeriods.endedAt updated: ${master_session_path}" >&2
+        fi
+    fi
+fi
+
 exit 0

package/hooks/session-start.sh

@@ -42,6 +42,7 @@ memoria_dir="${cwd}/.memoria"
 sessions_dir="${memoria_dir}/sessions"
 rules_dir="${memoria_dir}/rules"
 patterns_dir="${memoria_dir}/patterns"
+session_links_dir="${memoria_dir}/session-links"
 
 # Check if memoria is initialized
 if [ ! -d "$memoria_dir" ]; then
@@ -92,6 +93,22 @@ if git -C "$cwd" rev-parse --git-dir &> /dev/null 2>&1; then
     fi
 fi
 
+# ============================================
+# Check session-links for master session
+# ============================================
+master_session_id=""
+master_session_path=""
+session_link_file="${session_links_dir}/${file_id}.json"
+
+if [ -f "$session_link_file" ]; then
+    master_session_id=$(jq -r '.masterSessionId // empty' "$session_link_file" 2>/dev/null || echo "")
+    if [ -n "$master_session_id" ]; then
+        # Find master session file
+        master_session_path=$(find "$sessions_dir" -name "${master_session_id}.json" -type f 2>/dev/null | head -1)
+        echo "[memoria] Session linked to master: ${master_session_id}" >&2
+    fi
+fi
+
 # ============================================
 # Find existing session file or create new one
 # ============================================
@@ -194,6 +211,34 @@ else
     echo "[memoria] Session initialized: ${session_path}" >&2
 fi
 
+# ============================================
+# Update master session workPeriods (if linked)
+# ============================================
+if [ -n "$master_session_id" ] && [ -n "$master_session_path" ] && [ -f "$master_session_path" ]; then
+    # Use full session_id for consistency with session-end.sh
+    claude_session_id="${session_id:-$session_short_id}"
+
+    # Check if workPeriod already exists for this claudeSessionId (prevent duplicates on clear/compact)
+    existing_period=$(jq --arg cid "$claude_session_id" '.workPeriods // [] | map(select(.claudeSessionId == $cid and .endedAt == null)) | length' "$master_session_path" 2>/dev/null || echo "0")
+
+    if [ "$existing_period" = "0" ]; then
+        # Add new workPeriod entry to master session
+        jq --arg claudeSessionId "$claude_session_id" \
+           --arg startedAt "$now" '
+            .workPeriods = ((.workPeriods // []) + [{
+                claudeSessionId: $claudeSessionId,
+                startedAt: $startedAt,
+                endedAt: null
+            }]) |
+            .updatedAt = $startedAt
+        ' "$master_session_path" > "${master_session_path}.tmp" \
+            && mv "${master_session_path}.tmp" "$master_session_path"
+        echo "[memoria] Master session workPeriods updated: ${master_session_path}" >&2
+    else
+        echo "[memoria] Master session workPeriod already exists for this Claude session" >&2
+    fi
+fi
+
 # Get relative path for additionalContext
 # Extract year/month from session_path
 session_relative_path="${session_path#$cwd/}"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hir4ta/memoria",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "description": "Long-term memory plugin for Claude Code - automated session saving, recording technical decisions, and web dashboard",
   "keywords": [
     "claude",
@@ -23,8 +23,8 @@
     "dev": "vite",
     "dev:server": "tsx watch dashboard/server/index.ts",
     "build": "vite build && npm run build:server && npm run build:lib",
-    "build:server": "esbuild dashboard/server/index.ts --bundle --platform=node --outfile=dist/server.js --format=esm --external:fsevents --external:better-sqlite3",
-    "build:lib": "esbuild lib/*.ts --bundle --platform=node --outdir=dist/lib --format=esm --external:fsevents --external:better-sqlite3",
+    "build:server": "esbuild dashboard/server/index.ts --bundle --platform=node --outfile=dist/server.js --format=esm --external:fsevents",
+    "build:lib": "esbuild lib/*.ts --bundle --platform=node --outdir=dist/lib --format=esm --external:fsevents",
     "preview": "npm run build && node dist/server.js",
     "lint": "biome check .",
     "format": "biome format . --write",
@@ -41,12 +41,10 @@
     "@radix-ui/react-tooltip": "^1.2.8",
     "@tailwindcss/vite": "^4.0.7",
     "@tanstack/react-query": "^5.90.20",
-    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22",
     "@types/react": "^18",
     "@types/react-dom": "^18",
     "@vitejs/plugin-react": "^4.3.4",
-    "better-sqlite3": "^12.6.2",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "esbuild": "^0.24.2",

package/skills/init/skill.md

@@ -18,6 +18,7 @@ Create the `.memoria` directory structure in the current project.
 4. Create empty rules files:
    - `.memoria/rules/dev-rules.json`
    - `.memoria/rules/review-guidelines.json`
+5. Initialize SQLite database `.memoria/local.db` with the schema
 
 Use this JSON template for the rules files:
 ```json
@@ -29,5 +30,39 @@ Use this JSON template for the rules files:
 }
 ```
 
+For SQLite initialization, run:
+```bash
+sqlite3 .memoria/local.db < /path/to/memoria/lib/schema.sql
+```
+
+Or if schema.sql is not available, create minimal schema:
+```bash
+sqlite3 .memoria/local.db "
+CREATE TABLE IF NOT EXISTS interactions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    owner TEXT NOT NULL,
+    role TEXT NOT NULL,
+    content TEXT NOT NULL,
+    thinking TEXT,
+    tool_calls TEXT,
+    timestamp TEXT NOT NULL,
+    is_compact_summary INTEGER DEFAULT 0,
+    created_at TEXT DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_interactions_session ON interactions(session_id);
+CREATE INDEX IF NOT EXISTS idx_interactions_owner ON interactions(owner);
+
+CREATE TABLE IF NOT EXISTS pre_compact_backups (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    owner TEXT NOT NULL,
+    interactions TEXT NOT NULL,
+    created_at TEXT DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_backups_session ON pre_compact_backups(session_id);
+"
+```
+
 After creation, confirm success and explain that memoria will now track sessions in this project.
 </instructions>

package/skills/resume/skill.md

@@ -55,8 +55,10 @@ Multiple filters can be combined:
 3. Sort by `createdAt` descending (most recent first)
 4. Display filtered session list
 5. If session ID specified, read the JSON file and get details
-6. **Update current session JSON with `resumedFrom` field**
-7. Load session context to resume work
+6. **Create session-link file** (new master session support)
+7. **Update master session JSON with `workPeriods` entry**
+8. **Update current session JSON with `resumedFrom` field** (legacy, for backwards compatibility)
+9. Load session context to resume work
 
 ### File Operations
 
@@ -70,7 +72,16 @@ Read: .memoria/sessions/{year}/{month}/{filename}.json
 # Get interactions from SQLite (private, local only)
 sqlite3 .memoria/local.db "SELECT * FROM interactions WHERE session_id = '{id}' ORDER BY timestamp;"
 
-# Update CURRENT session with resumedFrom
+# Create session-link file (NEW - master session support)
+# This links current Claude session to the master memoria session
+Write: .memoria/session-links/{current_session_short_id}.json
+  → {"masterSessionId": "{resumed_session_id}", "claudeSessionId": "{current_full_session_id}", "linkedAt": "{now}"}
+
+# Update MASTER session with workPeriods entry (NEW)
+Edit: .memoria/sessions/{master_year}/{master_month}/{master_id}.json
+  → Add entry to workPeriods array: {"claudeSessionId": "{current_full_session_id}", "startedAt": "{now}", "endedAt": null}
+
+# Update CURRENT session with resumedFrom (legacy, for backwards compatibility)
 Edit: .memoria/sessions/{current_year}/{current_month}/{current_id}.json
   → Add "resumedFrom": "{resumed_session_id}"
 
@@ -198,19 +209,65 @@ If you're resuming a session created by another team member, interactions won't
 - SQLite contains interactions (local, private)
 - Always update the CURRENT session's JSON with `resumedFrom` to track session chains.
 
-## Session Chain Tracking
+## Session Chain Tracking (Master Session Support)
+
+When resuming session `abc123` (master) in a new Claude session `xyz789`:
+
+### Step 1: Create session-link file
+
+```bash
+# Create .memoria/session-links/ directory if not exists
+mkdir -p .memoria/session-links/
+
+# Write session-link file
+Write: .memoria/session-links/xyz78901.json
+```
+
+```json
+{
+  "masterSessionId": "abc12345",
+  "claudeSessionId": "xyz78901-38e9-464d-9b7c-a9cdca203b5e",
+  "linkedAt": "2026-01-27T09:10:00Z"
+}
+```
+
+### Step 2: Update master session workPeriods
+
+```bash
+Edit: .memoria/sessions/{year}/{month}/abc12345.json
+```
+
+Add to `workPeriods` array:
+```json
+{
+  "workPeriods": [
+    {"claudeSessionId": "abc12345-...", "startedAt": "...", "endedAt": "..."},
+    {"claudeSessionId": "xyz78901-...", "startedAt": "2026-01-27T09:10:00Z", "endedAt": null}
+  ]
+}
+```
+
+### Step 3: Update current session (legacy, backwards compatibility)
+
+```bash
+Edit: .memoria/sessions/{year}/{month}/xyz78901.json
+```
+
+```json
+{
+  "id": "xyz78901",
+  "resumedFrom": "abc12345",
+  ...
+}
+```
 
-When resuming session `abc123` in a new session `xyz789`:
+### Result
 
-1. Read current session path from additionalContext
-2. Update current session JSON:
-   ```json
-   {
-     "id": "xyz789",
-     "resumedFrom": "abc123",
-     ...
-   }
-   ```
-3. This creates a chain: `xyz789 ← abc123`
+- **session-link file**: Links Claude session → memoria master session
+- **workPeriods**: Tracks all work periods in the master session
+- **resumedFrom**: Legacy chain tracking (backwards compatible)
 
-The chain allows tracking related sessions over time.
+This design allows:
+1. Multiple Claude sessions to contribute to one logical memoria session
+2. `/memoria:save` to merge all data into the master session
+3. Dashboard to show unified conversation history

package/skills/save/skill.md

@@ -37,16 +37,79 @@ Extract and save all meaningful data from the current session.
 <phases>
 Execute all phases in order. Each phase builds on the previous.
 
-- Phase 0: Interactions - Merge preCompactBackups with current conversation
-- Phase 1: Summary - Extract session metadata
-- Phase 2: Decisions - Save to decisions/
-- Phase 3: Patterns - Save to patterns/
-- Phase 4: Rules - Extract development standards
+- Phase 0: Master Session - Identify master and merge child sessions
+- Phase 1: Interactions - Merge preCompactBackups with current conversation
+- Phase 2: Summary - Extract session metadata (considering ALL interactions)
+- Phase 3: Decisions - Save to decisions/
+- Phase 4: Patterns - Save to patterns/
+- Phase 5: Rules - Extract development standards
 </phases>
 
-### Phase 0: Save Conversation History (interactions)
+### Phase 0: Identify Master Session and Merge Children
 
-Execute this phase first. Interactions are stored in SQLite (`local.db`) for privacy.
+**Purpose:** Support multiple Claude sessions contributing to one logical memoria session.
+
+1. Get current session path from additionalContext (e.g., `.memoria/sessions/2026/01/xyz78901.json`)
+2. Get session ID from the path (e.g., `xyz78901`)
+
+3. **Check for session-link file:**
+   ```bash
+   Read: .memoria/session-links/xyz78901.json
+   ```
+   If exists, extract `masterSessionId`. If not, current session IS the master.
+
+4. **Find master session file:**
+   ```bash
+   Glob: .memoria/sessions/**/{masterSessionId}.json
+   ```
+
+5. **Find all child sessions linked to this master:**
+   ```bash
+   # Read all session-link files
+   Glob: .memoria/session-links/*.json
+
+   # Filter by masterSessionId
+   for each link:
+     if link.masterSessionId == masterSessionId:
+       childSessionIds.push(link file's session ID)
+   ```
+
+6. **Also check legacy `resumedFrom` chains:**
+   ```bash
+   # Find sessions where resumedFrom points to master or any child
+   Glob: .memoria/sessions/**/*.json
+   for each session:
+     if session.resumedFrom == masterSessionId or session.resumedFrom in childSessionIds:
+       childSessionIds.push(session.id)
+   ```
+
+7. **Merge child session data into master:**
+   For each child session JSON:
+   - Merge `workPeriods` (add any missing entries)
+   - Merge `files` (union, deduplicate by path)
+   - Merge `discussions` (append unique items)
+   - Merge `errors` (append unique items)
+   - Merge `metrics.toolUsage` (combine counts)
+   - Update `metrics.userMessages` (will be recalculated from SQLite)
+
+8. **Mark child sessions as merged:**
+   ```bash
+   Edit: .memoria/sessions/{year}/{month}/{childId}.json
+   ```
+   ```json
+   {
+     "status": "merged",
+     "mergedAt": "2026-01-27T12:00:00Z",
+     "masterSessionId": "abc12345"
+   }
+   ```
+
+**Important:** After this phase, all subsequent operations work on the MASTER session.
+
+### Phase 1: Save Conversation History (interactions)
+
+Execute this phase after identifying the master session.
+Interactions are stored in SQLite (`local.db`) for privacy.
 If auto-compact occurred, `pre_compact_backups` table contains earlier conversations.
 
 **Storage Location:**
@@ -61,16 +124,16 @@ Without merge: Only 8 interactions saved (data loss)
 With merge: All 24 interactions saved in SQLite
 ```
 
-1. Get session path from additionalContext (e.g., `.memoria/sessions/2026/01/abc12345.json`)
-2. Get session ID from the path (e.g., `abc12345`)
+1. Use master session ID from Phase 0 (e.g., `abc12345`)
+2. Collect all related session IDs: `[masterSessionId] + childSessionIds`
 
-3. **Check for existing data in SQLite**:
+3. **Check for existing data in SQLite (all related sessions)**:
    ```bash
-   # Check for pre_compact_backups (most complete source)
-   sqlite3 .memoria/local.db "SELECT interactions FROM pre_compact_backups WHERE session_id = 'abc12345' ORDER BY created_at DESC LIMIT 1;"
+   # Check for pre_compact_backups from ALL related sessions
+   sqlite3 .memoria/local.db "SELECT session_id, interactions FROM pre_compact_backups WHERE session_id IN ('abc12345', 'xyz78901') ORDER BY created_at DESC;"
 
-   # Check existing interactions count
-   sqlite3 .memoria/local.db "SELECT COUNT(*) FROM interactions WHERE session_id = 'abc12345';"
+   # Get interactions from ALL related sessions
+   sqlite3 .memoria/local.db "SELECT * FROM interactions WHERE session_id IN ('abc12345', 'xyz78901') ORDER BY timestamp ASC;"
    ```
 
 4. **Determine the most complete source**:
@@ -112,10 +175,10 @@ With merge: All 24 interactions saved in SQLite
 
 **Note:** Interactions are stored in SQLite for privacy. JSON contains only metadata.
 
-### Phase 1: Extract Session Data
+### Phase 2: Extract Session Data
 
-1. Get session path from additionalContext
-2. Read current session file (already updated with interactions in Phase 0)
+1. Use master session from Phase 0
+2. Read master session file (already updated with merged data from Phase 0-1)
 3. **Scan entire conversation** (including long sessions) to extract:
 
 #### Summary
@@ -166,7 +229,7 @@ With merge: All 24 interactions saved in SQLite
 - **handoff**: stoppedReason, notes, nextSteps
 - **references**: URLs and files referenced
 
-### Phase 2: Save to decisions/
+### Phase 3: Save to decisions/
 
 **For each discussion with a clear decision:**
 
@@ -200,7 +263,7 @@ With merge: All 24 interactions saved in SQLite
 - No clear decision was made (just discussion)
 - Similar decision already exists (check by title/topic)
 
-### Phase 3: Save to patterns/
+### Phase 4: Save to patterns/
 
 **For each error that was solved:**
 
@@ -242,7 +305,7 @@ With merge: All 24 interactions saved in SQLite
 - No root cause was identified
 - Error was environment-specific
 
-### Phase 4: Extract Rules
+### Phase 5: Extract Rules
 
 Scan conversation for development standards. These include both explicit user
 instructions and implicit standards from technical discussions.
@@ -362,11 +425,20 @@ Report each phase result:
 ---
 **Session saved.**
 
-**Session ID:** abc12345
+**Master Session ID:** abc12345
 **Path:** .memoria/sessions/2026/01/abc12345.json
 
-**Phase 0 - Interactions:** 15 saved to SQLite (8 from pre_compact_backups + 7 new)
-**Phase 1 - Summary:**
+**Phase 0 - Master Session:**
+  Master: abc12345
+  Children merged: xyz78901, def45678
+  Work periods: 3
+
+**Phase 1 - Interactions:** 42 saved to SQLite
+  - From abc12345: 15 interactions
+  - From xyz78901: 18 interactions
+  - From def45678: 9 interactions
+
+**Phase 2 - Summary:**
 | Field | Value |
 |-------|-------|
 | Title | JWT authentication implementation |
@@ -374,14 +446,14 @@ Report each phase result:
 | Outcome | success |
 | Type | implementation |
 
-**Phase 2 - Decisions (2):**
+**Phase 3 - Decisions (2):**
 - `[jwt-auth-001]` Authentication method selection → decisions/2026/01/
 - `[token-expiry-001]` Token expiry strategy → decisions/2026/01/
 
-**Phase 3 - Patterns (1):**
+**Phase 4 - Patterns (1):**
 - `[error-solution]` secretOrPrivateKey must be asymmetric → patterns/user.json
 
-**Phase 4 - Rules:**
+**Phase 5 - Rules:**
   dev-rules.json:
     + [code-style] Use early return pattern
     ~ [architecture] Avoid circular dependencies (skipped: similar exists)
@@ -392,7 +464,7 @@ Report each phase result:
 
 If no rules are found, report what was scanned:
 ```
-**Phase 4 - Rules:**
+**Phase 5 - Rules:**
   Scanned for: user instructions, technical standards from Codex review, security requirements
   Result: No new rules identified
 ```