sessionmem 1.2.0 → 1.3.0

package/README.md

@@ -1,12 +1,35 @@
 # sessionmem
 
-[![npm version](https://img.shields.io/npm/v/sessionmem.svg)](https://www.npmjs.com/package/sessionmem) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/catfish-1234/sessionmem/blob/main/LICENSE)
+<p align="center">
+  <img src=".github/sessionmem-logo.svg" alt="sessionmem" width="480">
+</p>
 
-**Give your AI coding assistant a memory that lasts beyond one conversation, stored entirely on your own computer.**
+<p align="center">
+  <a href="https://www.npmjs.com/package/sessionmem"><img src="https://img.shields.io/npm/v/sessionmem.svg" alt="npm version"></a>
+  <a href="https://github.com/catfish-1234/sessionmem/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
+</p>
 
-`sessionmem` is a local-first memory layer for AI coding assistants (Claude Code, Cursor, Codex, Cline, Windsurf, Antigravity, QCoder, and any other tool that speaks [MCP](https://modelcontextprotocol.io)). It watches your coding sessions, writes down the important stuff (decisions, warnings, facts about your project), and quietly reminds the assistant about it the next time you start working, so you never have to repeat yourself.
+**85.6% fewer tokens. Every session starts knowing your codebase. Stored entirely on your machine.**
 
-Everything happens on your machine. There is no account to create, no cloud service to trust, and no data that leaves your computer unless you explicitly turn that on.
+```
+New session. Claude starts fresh.
+
+WITHOUT sessionmem:
+  You explain the stack. The JWT bug from last week.
+  The Stripe migration that's halfway done. The billing code to stay away from.
+  Same questions. Different day.
+
+WITH sessionmem:
+  [warning] JWT blacklist must be checked before issuing new tokens. Fixed PR #47.
+  [decision] Stripe migration ~50% done. Do NOT use /lib/billing-v1.
+  [fact] Stack: TypeScript, Next.js, Postgres.
+
+  Claude: "Looks like you're mid-Stripe migration. Where do you want to pick up?"
+```
+
+`sessionmem` is an MCP server that watches your coding sessions and stores what actually mattered -- decisions, warnings, things that would bite you if Claude forgot them. At the start of each new session it injects the relevant bits automatically. Works with Claude Code, Cursor, Cline, Codex, Windsurf, and anything that speaks [MCP](https://modelcontextprotocol.io).
+
+Everything stays on your machine. No account, no cloud, no data leaving your computer unless you explicitly turn that on.
 
 ---
 
@@ -319,7 +342,16 @@ Details: [`docs/cloud-summarization.md`](docs/cloud-summarization.md).
 
 ## Troubleshooting
 
-Run into trouble installing or running `sessionmem`? Start with [`docs/troubleshooting.md`](docs/troubleshooting.md). It covers install failures, adapter-specific issues, and native module (`better-sqlite3`) build problems on different platforms.
+Run into trouble installing or running `sessionmem`? Start with [`docs/troubleshooting.md`](docs/troubleshooting.md). It covers install failures, adapter-specific issues, missing session data, and native module (`better-sqlite3`) build problems on different platforms.
+
+Two quick checks that resolve most reports:
+
+```bash
+sessionmem install   # idempotent — re-registers the MCP server and all three hooks
+sessionmem stats     # memories, sessions, and session_events for the current project
+```
+
+If `stats` shows `sessions: 0` after real work, see [“0 sessions” / no session data recorded](docs/troubleshooting.md#0-sessions--no-session-data-recorded). Memories are keyed to the **repository root**, so every directory inside one repo shares a bucket; outside a repo the working directory itself is the key.
 
 Quick checks:
 

package/dist/cli/commands/dedupe.js

@@ -1,7 +1,7 @@
 import { createCliContext } from "../context.js";
 import { listMemoriesByProject } from "../../core/storage/memoryRepo.js";
 const SIMILARITY_THRESHOLD = 0.85;
-const MAX_TAG_LEN = 200;
+const MAX_PREVIEW_LEN = 200;
 function cosineSimilarity(a, b) {
     if (a.length !== b.length || a.length === 0)
         return 0;
@@ -14,31 +14,82 @@ function cosineSimilarity(a, b) {
     const denom = Math.sqrt(normA) * Math.sqrt(normB);
     return denom === 0 ? 0 : dot / denom;
 }
+/**
+ * Parse and validate the `--threshold` flag. An unparseable or out-of-range
+ * value used to flow through as NaN, and every `sim >= NaN` comparison is
+ * false — so `--threshold banana` reported "no duplicates found" rather than
+ * telling the user their input was rejected.
+ */
+function resolveThreshold(raw) {
+    if (raw === undefined)
+        return SIMILARITY_THRESHOLD;
+    const parsed = Number.parseFloat(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 1) {
+        console.error(`Invalid --threshold "${raw}": expected a number greater than 0 and at most 1.`);
+        process.exit(1);
+    }
+    return parsed;
+}
+/** Parse a stored embedding, returning null when it is absent or malformed. */
+function parseVector(embedding) {
+    if (!embedding)
+        return null;
+    try {
+        const parsed = JSON.parse(embedding);
+        if (!Array.isArray(parsed) || !parsed.every((n) => Number.isFinite(n))) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
 export async function dedupeCommand(options = {}, ctx) {
     const context = ctx ?? createCliContext();
-    const threshold = options.threshold ? parseFloat(options.threshold) : SIMILARITY_THRESHOLD;
+    const threshold = resolveThreshold(options.threshold);
     const dryRun = options.dry !== false;
-    const memories = listMemoriesByProject(context.db, context.projectId);
-    const withEmbeddings = memories.filter((m) => m.embedding && m.embedding_dim);
-    if (withEmbeddings.length < 2) {
+    // Parse each embedding ONCE. The inner loop used to re-parse the same
+    // candidate's JSON for every outer element — O(n²) JSON.parse calls over a
+    // list that only has n distinct vectors.
+    const candidates = [];
+    for (const memory of listMemoriesByProject(context.db, context.projectId)) {
+        const vector = parseVector(memory.embedding);
+        if (!vector || !memory.embedding_dim)
+            continue;
+        candidates.push({
+            id: memory.id,
+            content: memory.content,
+            importance: memory.importance,
+            vector,
+        });
+    }
+    if (candidates.length < 2) {
         process.stdout.write("Not enough memories with embeddings to compare.\n");
         return;
     }
+    // Highest importance first, id as the tie-break. Pairs are emitted in this
+    // order and the first element of a pair is the one kept, so the survivor of
+    // any duplicate cluster is deterministic.
+    //
+    // Without this the order came from `ORDER BY updated_at DESC`, which is not a
+    // total order — memories written in the same clock tick tie, and the winner
+    // varied by platform. The same three memories could collapse to a different
+    // survivor on Windows than on Linux, and `--apply` is a hard delete.
+    candidates.sort((left, right) => right.importance - left.importance || left.id.localeCompare(right.id));
     const pairs = [];
-    for (let i = 0; i < withEmbeddings.length; i++) {
-        const a = withEmbeddings[i];
-        const vecA = JSON.parse(a.embedding);
-        for (let j = i + 1; j < withEmbeddings.length; j++) {
-            const b = withEmbeddings[j];
-            const vecB = JSON.parse(b.embedding);
-            const sim = cosineSimilarity(vecA, vecB);
+    for (let i = 0; i < candidates.length; i++) {
+        const a = candidates[i];
+        for (let j = i + 1; j < candidates.length; j++) {
+            const b = candidates[j];
+            const sim = cosineSimilarity(a.vector, b.vector);
             if (sim >= threshold) {
                 pairs.push({
                     idA: a.id,
                     idB: b.id,
                     similarity: sim,
-                    contentA: a.content.slice(0, MAX_TAG_LEN),
-                    contentB: b.content.slice(0, MAX_TAG_LEN),
+                    contentA: a.content.slice(0, MAX_PREVIEW_LEN),
+                    contentB: b.content.slice(0, MAX_PREVIEW_LEN),
                 });
             }
         }
@@ -47,26 +98,42 @@ export async function dedupeCommand(options = {}, ctx) {
         process.stdout.write(`No near-duplicate memories found (threshold: ${threshold}).\n`);
         return;
     }
+    const byId = new Map(candidates.map((c) => [c.id, c]));
+    const deleted = new Set();
     process.stdout.write(`Found ${pairs.length} near-duplicate pair(s) (threshold: ${threshold}):\n\n`);
     for (const pair of pairs) {
+        // Skip a pair whose partner is already gone. Similarity is not transitive:
+        // in a chain A~B, B~C with A≁C, deleting B for the (A,B) pair left the
+        // (B,C) pair still to process, and that pass could delete C — a memory
+        // whose only duplicate no longer existed. Nothing kept C from being
+        // dropped on the strength of an already-deleted row.
+        if (deleted.has(pair.idA) || deleted.has(pair.idB))
+            continue;
         process.stdout.write(`Similarity: ${(pair.similarity * 100).toFixed(1)}%\n`);
-        process.stdout.write(`  A [${pair.idA}]: ${pair.contentA}${pair.contentA.length >= MAX_TAG_LEN ? "…" : ""}\n`);
-        process.stdout.write(`  B [${pair.idB}]: ${pair.contentB}${pair.contentB.length >= MAX_TAG_LEN ? "…" : ""}\n`);
+        process.stdout.write(`  A [${pair.idA}]: ${pair.contentA}${pair.contentA.length >= MAX_PREVIEW_LEN ? "…" : ""}\n`);
+        process.stdout.write(`  B [${pair.idB}]: ${pair.contentB}${pair.contentB.length >= MAX_PREVIEW_LEN ? "…" : ""}\n`);
         if (!dryRun) {
-            // Keep A (higher importance or first by date), delete B.
-            const memA = withEmbeddings.find((m) => m.id === pair.idA);
-            const memB = withEmbeddings.find((m) => m.id === pair.idB);
+            const memA = byId.get(pair.idA);
+            const memB = byId.get(pair.idB);
+            if (!memA || !memB)
+                continue;
             const keepId = memA.importance >= memB.importance ? pair.idA : pair.idB;
             const dropId = keepId === pair.idA ? pair.idB : pair.idA;
-            await context.service.call("forgetMemory", {
+            const result = await context.service.call("forgetMemory", {
                 projectId: context.projectId,
                 memoryId: dropId,
             });
-            process.stdout.write(`  → Deleted ${dropId} (kept ${keepId})\n`);
+            if (result.ok) {
+                deleted.add(dropId);
+                process.stdout.write(`  → Deleted ${dropId} (kept ${keepId})\n`);
+            }
+            else {
+                process.stdout.write(`  → Failed to delete ${dropId}: ${result.error.message}\n`);
+            }
         }
         process.stdout.write("\n");
     }
-    if (dryRun && pairs.length > 0) {
+    if (dryRun) {
         process.stdout.write(`Run with --apply to delete the lower-importance duplicate in each pair.\n`);
     }
 }

package/dist/cli/commands/ingestHook.js

@@ -5,6 +5,22 @@ const CAPTURED_TOOL_TYPES = new Set(["Bash", "Edit", "Write", "MultiEdit"]);
 // Max payload size stored per hook event (chars). The full hook payload can be
 // large (file diffs); cap it so a single tool use can't bloat session_events.
 const MAX_HOOK_PAYLOAD_CHARS = 4000;
+// Per-field cap applied BEFORE serialization. Truncating the serialized JSON
+// instead would produce a string that is no longer valid JSON, which the
+// `payloadJson` contract rejects (it parses the value) — the event would then be
+// dropped, silently, by the catch-all below. Trim the inputs, not the output.
+const MAX_FIELD_CHARS = 1200;
+// One-line human summary shown in session summaries (summaryShape reads `text`).
+const MAX_TEXT_CHARS = 300;
+/** Emit a hook diagnostic to stderr when SESSIONMEM_DEBUG=1. */
+function debug(message) {
+    if (process.env.SESSIONMEM_DEBUG === "1") {
+        process.stderr.write(`[sessionmem] ingest-hook: ${message}\n`);
+    }
+}
+function truncate(value, max) {
+    return value.length > max ? `${value.slice(0, max)}…` : value;
+}
 async function readStdinJson() {
     if (process.stdin.isTTY)
         return {};
@@ -40,6 +56,65 @@ function resolveSessionId(payload) {
     }
     return process.env.CLAUDE_CODE_SESSION_ID ?? process.env.SESSION_ID ?? `session-${Date.now()}`;
 }
+/**
+ * Shorten every string in a tool input to MAX_FIELD_CHARS, recursively. Keeps
+ * the object's shape (so it still serializes to valid JSON) while bounding the
+ * size contributed by large fields such as a Write tool's `content` or an Edit
+ * tool's replacement text.
+ */
+function shrinkValue(value, depth = 0) {
+    if (typeof value === "string")
+        return truncate(value, MAX_FIELD_CHARS);
+    if (depth >= 4)
+        return undefined;
+    if (Array.isArray(value)) {
+        return value.slice(0, 20).map((item) => shrinkValue(item, depth + 1));
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [key, inner] of Object.entries(value)) {
+            out[key] = shrinkValue(inner, depth + 1);
+        }
+        return out;
+    }
+    // Numbers/booleans/null pass through; functions/undefined/symbols drop out.
+    return value === undefined || typeof value === "function" || typeof value === "symbol"
+        ? undefined
+        : value;
+}
+/**
+ * A short human-readable line describing the tool use. Stored alongside the
+ * structured input as `text`, which the local summarizer prefers over the raw
+ * payload — so session summaries read as prose instead of dumped JSON.
+ */
+function describeToolUse(toolName, input) {
+    const str = (key) => typeof input?.[key] === "string" ? input[key] : "";
+    if (toolName === "Bash") {
+        const command = str("command").replace(/\s+/g, " ").trim();
+        return truncate(command ? `Ran: ${command}` : "Ran a shell command", MAX_TEXT_CHARS);
+    }
+    const filePath = str("file_path") || str("path") || str("notebook_path");
+    const verb = toolName === "Write" ? "Wrote" : "Edited";
+    return truncate(filePath ? `${verb} ${filePath}` : `${verb} a file`, MAX_TEXT_CHARS);
+}
+/**
+ * Serialize the event payload, guaranteeing valid JSON within
+ * MAX_HOOK_PAYLOAD_CHARS. Per-field shrinking handles the common case; if the
+ * result is still over budget (many fields, or one huge key set), drop the
+ * structured input and keep only the human-readable summary rather than
+ * emitting truncated — and therefore unparseable — JSON.
+ */
+function buildPayloadJson(toolName, text, input, cwd) {
+    const full = JSON.stringify({
+        tool: toolName,
+        text,
+        input: shrinkValue(input),
+        cwd,
+    });
+    if (full.length <= MAX_HOOK_PAYLOAD_CHARS)
+        return full;
+    return JSON.stringify({ tool: toolName, text, cwd, truncated: true });
+}
 /**
  * `sessionmem ingest-hook` — PostToolUse hook handler.
  * Reads Claude Code's PostToolUse JSON payload from stdin and stores it as a
@@ -47,34 +122,36 @@ function resolveSessionId(payload) {
  * Also auto-stores git commits as decision memories (git commit detection).
  */
 export async function ingestHookCommand(ctx) {
+    let context;
     try {
         const payload = await readStdinJson();
         const toolName = payload.tool_name ?? "";
-        if (!CAPTURED_TOOL_TYPES.has(toolName))
+        if (!CAPTURED_TOOL_TYPES.has(toolName)) {
+            debug(`skipped: tool "${toolName}" is not captured`);
             return;
-        const context = ctx ?? createCliContext();
+        }
+        context = ctx ?? createCliContext();
         const sessionId = resolveSessionId(payload);
         const projectId = context.projectId;
-        // Trim payload to cap storage per event.
-        const fullPayload = JSON.stringify({
-            tool: toolName,
-            input: payload.tool_input,
-            cwd: payload.cwd,
-        });
-        const trimmedPayload = fullPayload.length > MAX_HOOK_PAYLOAD_CHARS
-            ? fullPayload.slice(0, MAX_HOOK_PAYLOAD_CHARS) + "…"
-            : fullPayload;
-        // Store as a session event (for SessionEnd auto-summarize).
-        await context.service.call("ingestSessionEvents", {
+        const text = describeToolUse(toolName, payload.tool_input);
+        // eventIndex is intentionally omitted: the service assigns the next free
+        // index per session inside an immediate transaction, so parallel tool calls
+        // cannot collide (see nextSessionEventIndex).
+        const result = await context.service.call("ingestSessionEvents", {
             projectId,
             sessionId,
             events: [{
                     id: randomUUID(),
-                    eventIndex: Date.now(), // monotonic within the session
                     eventType: `tool_use:${toolName.toLowerCase()}`,
-                    payloadJson: trimmedPayload,
+                    payloadJson: buildPayloadJson(toolName, text, payload.tool_input, payload.cwd),
                 }],
         });
+        if (!result.ok) {
+            debug(`ingest failed: ${result.error.message}`);
+        }
+        else {
+            debug(`ingested ${result.ingested} event(s) for session ${sessionId} (project ${projectId})`);
+        }
         // Git commit detection: auto-store as a decision memory.
         if (toolName === "Bash") {
             const cmd = typeof payload.tool_input?.command === "string"
@@ -96,9 +173,21 @@ export async function ingestHookCommand(ctx) {
                 }
             }
         }
-        context.db.close();
     }
-    catch {
-        // Never block tool use — swallow all errors silently.
+    catch (err) {
+        // Never block tool use — a hook failure must not surface as a tool error.
+        debug(err instanceof Error ? err.message : String(err));
+    }
+    finally {
+        // Close only a context this command opened; an injected ctx belongs to the
+        // caller (tests reuse it across assertions). Previously the close was
+        // inside the try block, so it was skipped on every error path and leaked
+        // the sqlite handle.
+        if (!ctx && context) {
+            try {
+                context.db.close();
+            }
+            catch { /* already closed */ }
+        }
     }
 }

package/dist/cli/commands/savings.js

@@ -63,7 +63,9 @@ export function savingsCommand(ctx, options) {
         ? [
             "Storage compression:",
             "  No session data ingested yet.",
-            "  Tip: call ingestSessionEvents during sessions to track token usage.",
+            "  Session events are captured automatically by the PostToolUse hook.",
+            "  If this stays empty, run `sessionmem install` to (re)register the hook,",
+            "  then check `sessionmem stats` for the session_events counter.",
         ]
         : [
             "Storage compression:",

package/dist/cli/commands/stats.js

@@ -2,6 +2,7 @@ import { statSync } from "fs";
 import { createCliContext } from "../context.js";
 import { countTokens } from "../../core/injection/tokenBudget.js";
 import { listMemoriesByProject } from "../../core/storage/memoryRepo.js";
+import { countDistinctSessions } from "../../core/storage/tokenSavingsRepo.js";
 import { configFilePath, readPolicyConfig, } from "../../core/config/policyConfig.js";
 export async function statsCommand(ctx, options) {
     const context = ctx ?? createCliContext();
@@ -38,7 +39,13 @@ export async function statsCommand(ctx, options) {
         retentionLine = `Retention: ${retentionDays} days (${eligible} memories eligible for pruning)`;
     }
     const redactionLine = `Redaction: ${redactionEnabled ? "enabled" : "disabled"}`;
+    // Surface the session-event counters. The auto-ingest pipeline is silent by
+    // design (a hook must never fail a tool call), so without these lines a
+    // pipeline that captures nothing looks identical to one that works.
+    const sessions = countDistinctSessions(context.db, context.projectId);
     process.stdout.write(`memories: ${result.totalMemories}\n` +
+        `sessions: ${sessions}\n` +
+        `session_events: ${result.totalSessionEvents}\n` +
         `db_size_bytes: ${sizeBytes}\n` +
         `total_content_tokens: ${totalTokens}\n` +
         `${retentionLine}\n` +

package/dist/cli/index.js

@@ -126,8 +126,6 @@ retention
     .option("--days <n>", "Override the retention window in days")
     .action((options) => retentionPruneCommand(options));
 // config command group — generic get/set over ~/.sessionmem/config.json.
-// config get/set are synchronous and take no CliContext, so the arrow-wrap here
-// only drops commander's trailing Command argument.
 const config = program
     .command("config")
     .description("Read and write sessionmem policy config");
@@ -140,10 +138,6 @@ config
     .description("Persist a config key to ~/.sessionmem/config.json")
     .action((key, value) => configSetCommand(key, value));
 // team command group — turn shared-memory mode on/off and inspect it.
-// enable/status take no CliContext (config-only), so their arrow-wraps just drop
-// commander's trailing Command argument. disable accepts an optional CliContext
-// seam for the --remove-team-memories DB delete; the arrow-wrap forwards only
-// options so production falls through to createCliContext() (NOTE above).
 const team = program
     .command("team")
     .description("Manage shared-path team memory mode");
@@ -161,15 +155,12 @@ team
     .description("Show team mode state and shared-path availability")
     .action(() => teamStatusCommand());
 // re-embed — bulk-update stale embeddings to the current version.
-// reEmbedCommand declares a trailing `ctx?` test seam, so arrow-wrap to drop
-// commander's trailing Command argument (NOTE above).
 program
     .command("re-embed")
     .description("Re-embed all memories with stale embedding versions")
     .action(() => reEmbedCommand());
-// sync — push a local snapshot to the shared path and pull every
-// teammate snapshot back. syncCommand declares a trailing `ctx?` test seam, so
-// arrow-wrap to drop commander's trailing Command argument (NOTE above).
+// sync — push a local snapshot to the shared path and pull every teammate
+// snapshot back.
 program
     .command("sync")
     .description("Push local memories and pull teammate memories via the shared path")

package/dist/cli/projectId.js

@@ -1,4 +1,43 @@
 import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+/** Safety bound on the upward walk in {@link findProjectRoot}. */
+const MAX_PARENT_WALK = 64;
+/**
+ * Walk up from `startDir` to the nearest directory containing `.git`, and
+ * return it. Returns null when there is no repository above `startDir`.
+ *
+ * Memory is keyed by project, and a project is the repository — not whichever
+ * directory a command happened to run in. Hashing the raw cwd meant every
+ * subdirectory got its OWN bucket: the Claude Code hooks fire at the repo root
+ * and write there, then `sessionmem stats` run from `src/` reported an empty
+ * store, because it was reading a different project entirely.
+ *
+ * `.git` is matched as a path entry rather than a directory so linked worktrees
+ * and submodules (where `.git` is a FILE pointing at the real gitdir) anchor
+ * correctly too.
+ */
+export function findProjectRoot(startDir) {
+    let current = resolve(startDir);
+    for (let depth = 0; depth < MAX_PARENT_WALK; depth += 1) {
+        try {
+            // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal
+            if (existsSync(join(current, ".git"))) {
+                return current;
+            }
+        }
+        catch {
+            // Unreadable directory (permissions, race): stop rather than throw — the
+            // caller falls back to the cwd-derived id.
+            return null;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break; // filesystem root
+        current = parent;
+    }
+    return null;
+}
 /**
  * Sanitize a raw token to the filename-safe character set used across
  * sessionmem (mirrors localUsername). Any character outside [A-Za-z0-9._-]
@@ -45,7 +84,13 @@ export function projectIdFromCwd(cwd) {
 /**
  * Resolve the effective project id: the `SESSIONMEM_PROJECT_ID` env override
  * (operator-controlled test/migration seam; also lets a user pin a legacy
- * basename-only id) wins, otherwise derive from `process.cwd()`.
+ * basename-only id) wins, otherwise derive from the enclosing repository root,
+ * falling back to `process.cwd()` when the cwd is not inside a repository.
+ *
+ * Anchoring to the repository keeps every command — hooks firing at the root,
+ * a `sessionmem stats` typed three directories down — on the same memory
+ * bucket. The id is unchanged for anyone already running at the repo root,
+ * since the root IS the cwd in that case.
  */
 export function deriveProjectId() {
     const envProjectId = process.env.SESSIONMEM_PROJECT_ID;
@@ -65,5 +110,6 @@ export function deriveProjectId() {
             return sanitized;
         }
     }
-    return projectIdFromCwd(process.cwd());
+    const cwd = process.cwd();
+    return projectIdFromCwd(findProjectRoot(cwd) ?? cwd);
 }

package/dist/core/api/contracts.js

@@ -65,7 +65,12 @@ export const memorySchema = z.object({
 });
 export const ingestSessionEventSchema = z.object({
     id: z.string().min(1).max(200),
-    eventIndex: z.number().int().nonnegative(),
+    // Optional: callers that already track an ordering key (batch ingestion of a
+    // transcript) supply it; callers that fire one event at a time from separate
+    // processes (the PostToolUse hook) omit it and the service assigns the next
+    // free index per session. See nextSessionEventIndex for why inventing a
+    // wall-clock index silently loses events.
+    eventIndex: z.number().int().nonnegative().optional(),
     eventType: z.string().min(1).max(100),
     payloadJson: z
         .string()

package/dist/core/api/memoryCoreService.js

@@ -8,7 +8,7 @@ import { applyRedaction } from "../summarize/redaction.js";
 import { countAllMemoriesByProject, countMemoriesBySession, countMemoriesOlderThan, deleteMemoriesOlderThan, deleteMemoryById, getMemoryOwnerProjectId, getMemoryRecordById, incrementAccessCounts, insertMemory, listMemoriesByProject, resetAccessCounts, updateMemoryContent, upsertImportedMemory, upsertPulledMemory, upsertSessionSummaryMemory, } from "../storage/memoryRepo.js";
 import { SESSION_WRITE_SOFT_LIMIT, configFilePath, DEEP_MODE_RETRIEVAL_CAP, readPolicyConfig, resolvePolicySettings, } from "../config/policyConfig.js";
 import { insertMemoryFeedbackEvent } from "../storage/memoryFeedbackRepo.js";
-import { countAllSessionEvents, insertSessionEvent } from "../storage/sessionEventsRepo.js";
+import { countAllSessionEvents, insertSessionEvent, nextSessionEventIndex, } from "../storage/sessionEventsRepo.js";
 import { batchStoreMemoryItemSchema, batchStoreMemoryRequestSchema, exportMemoriesRequestSchema, forgetMemoryRequestSchema, getMemoryRequestSchema, handleSessionEndRequestSchema, importMemoriesRequestSchema, pullMemoriesRequestSchema, ingestSessionEventsRequestSchema, LIST_MEMORIES_DEFAULT_LIMIT, listMemoriesRequestSchema, pruneMemoriesRequestSchema, redactExistingRequestSchema, resetAccessCountsRequestSchema, retrieveMemoriesRequestSchema, statsRequestSchema, storeMemoryRequestSchema, summarizeSessionToMemoryRequestSchema, } from "./contracts.js";
 import { DomainError, toErrorEnvelope } from "./errors.js";
 import { assertLocalOnlyPolicy, } from "./localOnlyPolicy.js";
@@ -186,15 +186,25 @@ export function createMemoryCoreService(deps) {
             const redactionEnabled = resolveRedactionEnabled(undefined);
             const ingest = db.transaction(() => {
                 let written = 0;
+                // Events that omit eventIndex are appended after the session's current
+                // maximum. Read it once inside the transaction and increment locally so
+                // a multi-event batch stays contiguous.
+                let nextIndex;
                 for (const event of parsed.events) {
                     const redactedPayload = applyRedaction(event.payloadJson, {
                         redactionEnabled,
                     }).text;
+                    let eventIndex = event.eventIndex;
+                    if (eventIndex === undefined) {
+                        nextIndex ??= nextSessionEventIndex(db, parsed.projectId, parsed.sessionId);
+                        eventIndex = nextIndex;
+                        nextIndex += 1;
+                    }
                     written += insertSessionEvent(db, {
                         id: event.id,
                         project_id: parsed.projectId,
                         session_id: parsed.sessionId,
-                        event_index: event.eventIndex,
+                        event_index: eventIndex,
                         event_type: event.eventType,
                         payload_json: redactedPayload,
                         created_at: event.createdAt,
@@ -202,7 +212,11 @@ export function createMemoryCoreService(deps) {
                 }
                 return written;
             });
-            const ingested = ingest();
+            // `immediate` takes the write lock up front so two concurrent hook
+            // processes cannot both read the same next index and have one insert
+            // silently ignored. busy_timeout (db.ts) makes the loser wait rather
+            // than fail.
+            const ingested = ingest.immediate();
             return {
                 ok: true,
                 ingested,

package/dist/core/retrieve/retrieveMemories.js

@@ -43,7 +43,7 @@ export function retrieveMemories(input) {
     const now = input.now ?? new Date();
     // Use FTS5 pre-filtering to limit cosine similarity computation to ~50 candidates.
     // queryText is guaranteed non-empty by the Zod schema (z.string().min(1)) upstream.
-    const candidates = searchMemoryCandidatesFTS(input.db, input.projectId, queryText);
+    const candidates = searchMemoryCandidatesFTS(input.db, input.projectId, queryText, now);
     const decayedCandidates = decayOldBoosts(candidates, now);
     const dimension = resolveEmbeddingDimension(candidates);
     const queryVector = deterministicEmbed(queryText, dimension).vector;

package/dist/core/storage/memoryRepo.js

@@ -107,7 +107,7 @@ function getStatements(db) {
     FROM memories
     WHERE project_id = ?
       AND (expires_at IS NULL OR expires_at > strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-    ORDER BY updated_at DESC
+    ORDER BY updated_at DESC, id ASC
   `),
         // Lightweight projection for token-savings accounting: only `content` is
         // needed to count tokens, so we deliberately avoid pulling the (potentially

package/dist/core/storage/memorySearchRepo.js

@@ -1,23 +1,36 @@
 import { EMBEDDING_VERSION } from "../embed/embeddingVersion.js";
 const FTS_CANDIDATE_LIMIT = 50;
 const FTS_FALLBACK_THRESHOLD = 5;
+/** Recency window for the fallback candidate scan. */
+const FALLBACK_RECENCY_DAYS = 90;
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+/** Storage timestamp format: ISO-8601 UTC with millisecond precision. */
+function toStorageTimestamp(date) {
+    return date.toISOString();
+}
 const searchStmtCache = new WeakMap();
 function getSearchStatements(db) {
     let stmts = searchStmtCache.get(db);
     if (stmts)
         return stmts;
     stmts = {
+        // `now` and the recency cutoff are bound parameters rather than
+        // strftime('now') so the caller's clock drives both filters. With SQL's own
+        // clock, a caller that passes an explicit `now` (retrieveMemories, and every
+        // test that pins a date) silently got a different window than it asked for,
+        // and fixed-date fixtures aged out of the 90-day band over real calendar
+        // time — turning deterministic tests into time bombs.
         searchCandidates: db.prepare(`
     SELECT
       id, project_id, session_id, source_adapter, kind, content, normalized_content,
       importance, author, origin_project_id, access_count, created_at, updated_at,
       embedding, embedding_dim, embedding_version
     FROM memories
-    WHERE project_id = ?
-      AND (expires_at IS NULL OR expires_at > strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    WHERE project_id = @projectId
+      AND (expires_at IS NULL OR expires_at > @now)
       AND (
         importance >= 8
-        OR updated_at > strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '-90 days')
+        OR updated_at > @recencyCutoff
       )
   `),
         searchCandidatesFTS: db.prepare(`
@@ -28,11 +41,11 @@ function getSearchStatements(db) {
       m.embedding, m.embedding_dim, m.embedding_version
     FROM memories_fts
     JOIN memories m ON m.rowid = memories_fts.rowid
-    WHERE memories_fts MATCH ?
-      AND m.project_id = ?
-      AND (m.expires_at IS NULL OR m.expires_at > strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    WHERE memories_fts MATCH @match
+      AND m.project_id = @projectId
+      AND (m.expires_at IS NULL OR m.expires_at > @now)
     ORDER BY rank
-    LIMIT ?
+    LIMIT @limit
   `),
     };
     searchStmtCache.set(db, stmts);
@@ -74,8 +87,12 @@ function mapRows(rows) {
         };
     });
 }
-export function searchMemoryCandidates(db, projectId) {
-    const rows = getSearchStatements(db).searchCandidates.all(projectId);
+export function searchMemoryCandidates(db, projectId, now = new Date()) {
+    const rows = getSearchStatements(db).searchCandidates.all({
+        projectId,
+        now: toStorageTimestamp(now),
+        recencyCutoff: toStorageTimestamp(new Date(now.getTime() - FALLBACK_RECENCY_DAYS * MS_PER_DAY)),
+    });
     return mapRows(rows);
 }
 /**
@@ -107,23 +124,28 @@ function sanitizeFtsQuery(queryText) {
  * (<8) — exactly the rows the fallback's filter excludes — returning zero
  * candidates for a query that matched only such rows.
  */
-export function searchMemoryCandidatesFTS(db, projectId, queryText) {
+export function searchMemoryCandidatesFTS(db, projectId, queryText, now = new Date()) {
     const sanitized = sanitizeFtsQuery(queryText);
     if (!sanitized) {
-        return searchMemoryCandidates(db, projectId);
+        return searchMemoryCandidates(db, projectId, now);
     }
     let rows;
     try {
-        rows = getSearchStatements(db).searchCandidatesFTS.all(sanitized, projectId, FTS_CANDIDATE_LIMIT);
+        rows = getSearchStatements(db).searchCandidatesFTS.all({
+            match: sanitized,
+            projectId,
+            now: toStorageTimestamp(now),
+            limit: FTS_CANDIDATE_LIMIT,
+        });
     }
     catch {
         // FTS5 MATCH can throw on malformed queries — fall back to full scan
-        return searchMemoryCandidates(db, projectId);
+        return searchMemoryCandidates(db, projectId, now);
     }
     if (rows.length >= FTS_FALLBACK_THRESHOLD) {
         return dedupById(mapRows(rows));
     }
-    const fallback = searchMemoryCandidates(db, projectId);
+    const fallback = searchMemoryCandidates(db, projectId, now);
     if (rows.length === 0) {
         return fallback;
     }

package/dist/core/storage/sessionEventsRepo.js

@@ -22,6 +22,11 @@ function getSessionEventsStatements(db) {
     ORDER BY event_index ASC
   `),
         countAll: db.prepare("SELECT COUNT(*) AS count FROM session_events WHERE project_id = ?"),
+        nextEventIndex: db.prepare(`
+    SELECT COALESCE(MAX(event_index), -1) + 1 AS next
+    FROM session_events
+    WHERE project_id = ? AND session_id = ?
+  `),
     };
     sessionEventsStmtCache.set(db, stmts);
     return stmts;
@@ -34,6 +39,22 @@ function getSessionEventsStatements(db) {
 export function insertSessionEvent(db, input) {
     return getSessionEventsStatements(db).insertEvent.run(input).changes;
 }
+/**
+ * Next free `event_index` for a session (max + 1, or 0 when the session has no
+ * events yet).
+ *
+ * Callers that have no natural ordering key of their own (the PostToolUse hook
+ * fires once per tool use, in separate processes) use this instead of inventing
+ * one. A wall-clock index collides whenever two tool uses land in the same
+ * millisecond — which parallel tool calls routinely do — and the UNIQUE index
+ * on (project_id, session_id, event_index) then makes `INSERT OR IGNORE` drop
+ * the loser silently. Must be called inside the same immediate transaction as
+ * the insert so concurrent writers cannot read the same value.
+ */
+export function nextSessionEventIndex(db, projectId, sessionId) {
+    const row = getSessionEventsStatements(db).nextEventIndex.get(projectId, sessionId);
+    return row.next;
+}
 export function countAllSessionEvents(db, projectId) {
     const row = getSessionEventsStatements(db).countAll.get(projectId);
     return row.count;

package/dist/core/summarize/redaction.js

@@ -9,6 +9,43 @@
 // applyRedaction invocation — a measurable saving in batch/import/pull loops.
 // The regex literals carry no `lastIndex` state because every pattern is used
 // with String.prototype.replace (not stateful .test()/.exec() on a shared regex).
+/**
+ * Key names that mark an assignment's value as a secret. Matched
+ * case-insensitively and allowed to carry bounded affixes on either side, so
+ * `AWS_SECRET_ACCESS_KEY` and `SECRET_TOKEN_VALUE` match as readily as `secret`.
+ */
+const SECRET_KEY_NAMES = [
+    "password",
+    "passwd",
+    "pwd",
+    "secret",
+    "api[_-]?key",
+    "apikey",
+    "access[_-]?token",
+    "refresh[_-]?token",
+    "auth[_-]?token",
+    "client[_-]?secret",
+    "private[_-]?key",
+    "credentials?",
+    "token",
+].join("|");
+/**
+ * `<key><separator><value>` where the key names a secret. Capture groups are
+ * (key, separator, value) so the replacement can keep the key and separator
+ * verbatim and swap only the value.
+ *
+ * Both `:` and `=` are accepted (YAML, JSON, `.env`, query strings, log lines),
+ * and the value may be backslash-escaped-quoted, double-quoted, single-quoted,
+ * or bare. Every quantifier is bounded, so the pattern is ReDoS-safe.
+ *
+ * The escaped-quote branch comes first and the bare branch excludes `\`, which
+ * together keep a JSON payload parseable after redaction. Session events store
+ * JSON, so a secret inside a stringified field arrives as `password=\"a b\"`;
+ * letting the bare branch match the lone backslash replaced it with
+ * `[REDACTED]` and left the rest of the quoted run stranded, producing
+ * unparseable JSON.
+ */
+const SECRET_ASSIGNMENT_PATTERN = new RegExp(String.raw `\b([A-Za-z0-9_.-]{0,40}(?:${SECRET_KEY_NAMES})[A-Za-z0-9_.-]{0,40}\\?"?)(\s*[:=]\s*)(\\"(?:\\.|[^"\\]){0,4096}\\"|"[^"\n]{1,4096}"|'[^'\n]{1,4096}'|[^\s"'\\,;&}]{1,4096})`, "gi");
 const DEFAULT_RULES = createDefaultRules();
 function createDefaultRules() {
     return [
@@ -49,16 +86,39 @@ function createDefaultRules() {
         (input) => input.replace(/\bsk-(?:[a-zA-Z0-9]{1,32}-){0,4}[a-zA-Z0-9]{12,200}\b/g, "[REDACTED_API_KEY]"),
         // Bearer token header value: "Bearer <token>" (case-insensitive), token redacted.
         (input) => input.replace(/\bBearer\s+[A-Za-z0-9._~+/-]{8,}=*/gi, "Bearer [REDACTED_BEARER_TOKEN]"),
-        // Config/connection-string assignments: key=value where key is a known
-        // secret-bearing name. The key is kept and the value redacted. Covers
-        // password/secret plus api_key/apikey/token/access_token/pwd in URL query
-        // strings and config files. The `=` separator may carry surrounding spaces.
-        (input) => input.replace(/\b(password|passwd|pwd|secret|api[_-]?key|access[_-]?token|token)\s*=\s*([^\s"'&;]+)/gi, "$1=[REDACTED]"),
-        // JSON-form secret assignments: "key": "value" for known secret-bearing
-        // keys. Complements the key=value rule above so secrets embedded in JSON
-        // payloads (config files, logged request bodies) are redacted too. The key
-        // is preserved; the quoted value is collapsed.
-        (input) => input.replace(/"(password|secret|api_key|token|access_token|auth_token|client_secret|private_key|pwd|passwd)"\s*:\s*"[^"]{4,}"/gi, '"$1": "[REDACTED]"'),
+        // HTTP Basic auth header: the base64 blob encodes user:password verbatim.
+        (input) => input.replace(/\bBasic\s+[A-Za-z0-9+/]{12,}={0,2}/g, "Basic [REDACTED_BASIC_AUTH]"),
+        // Slack incoming-webhook URLs — the path IS the credential, so the whole
+        // path is collapsed rather than a token-shaped substring of it.
+        (input) => input.replace(/https:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9/_-]{10,200}/g, "https://hooks.slack.com/services/[REDACTED_SLACK_WEBHOOK]"),
+        // Secret-bearing assignments: `<key><sep><value>` for a known secret-ish key
+        // name, covering config files, .env exports, YAML, JSON bodies, log lines
+        // and URL query strings in one rule.
+        //
+        // Three things the narrower predecessors missed, each a real leak:
+        //  - `:` as a separator (YAML, JSON, `Header: value` log lines). Only `=`
+        //    was handled, so `aws_secret_access_key: wJalr…` passed through.
+        //  - Affixed key names. The keyword had to sit on a \b boundary, and `_` is
+        //    a word character, so `AWS_SECRET_ACCESS_KEY` and `SECRET_TOKEN_VALUE`
+        //    never matched. Allow bounded affixes on both sides.
+        //  - Quoted values. The value class excluded quotes, so `password="a b c"`
+        //    matched nothing at all.
+        //
+        // Quoted values keep their delimiters so a redacted JSON payload stays
+        // parseable. All quantifiers are bounded and the alternation is
+        // non-backtracking on failure, so the rule stays ReDoS-safe.
+        (input) => input.replace(SECRET_ASSIGNMENT_PATTERN, (_match, key, separator, value) => {
+            // Preserve the value's quote style so a redacted JSON payload stays
+            // parseable and a redacted YAML line stays well-formed.
+            const quote = value.startsWith('\\"')
+                ? '\\"'
+                : value.startsWith('"')
+                    ? '"'
+                    : value.startsWith("'")
+                        ? "'"
+                        : "";
+            return `${key}${separator}${quote}[REDACTED]${quote}`;
+        }),
     ];
 }
 export function applyRedaction(input, options) {

package/dist/core/summarize/summaryShape.js

@@ -1,3 +1,12 @@
+/** Max distinct lines rendered per section. */
+const MAX_SECTION_LINES = 5;
+/** Max `- [type] text` fact lines in the facts section. */
+const MAX_FACT_LINES = 8;
+/**
+ * Human-readable text for an event. The auto-ingest hook writes a `text` field
+ * carrying a one-line description ("Ran: npm test", "Edited src/foo.ts"); fall
+ * back to the raw payload for events written by other producers.
+ */
 function extractEventText(event) {
     try {
         const parsed = JSON.parse(event.payload_json);
@@ -10,34 +19,55 @@ function extractEventText(event) {
     }
     return event.payload_json.trim();
 }
-function sectionLines(events, fallback) {
-    const lines = events.map(extractEventText).filter((line) => line.length > 0);
-    if (lines.length === 0) {
-        return [fallback];
+/** Distinct, non-empty lines, preserving first-seen order. */
+function distinctLines(events) {
+    const seen = new Set();
+    const lines = [];
+    for (const event of events) {
+        const line = extractEventText(event);
+        if (line.length === 0 || seen.has(line))
+            continue;
+        seen.add(line);
+        lines.push(line);
     }
-    return lines.slice(0, 3);
+    return lines;
 }
+function section(title, lines, fallback) {
+    const body = lines.length > 0 ? lines : [fallback];
+    return [title, ...body.map((line) => `- ${line}`)];
+}
+/**
+ * Render the session's events as a structured summary.
+ *
+ * Sections carry DIFFERENT slices of the session rather than the same lines
+ * repeated under every heading: `actions` is what happened in order, `outcomes`
+ * is where the session ended up, and `decisions` surfaces the events that
+ * recorded a choice (git commits). Repeating one slice under all five headings
+ * produced a summary that cost five times the tokens and carried no extra
+ * signal — and, once stored, was what every later session got injected with.
+ */
 export function buildStructuredSummary(events, options) {
-    const sharedLines = sectionLines(events, "No relevant events captured.");
+    const lines = distinctLines(events);
+    // Ordered narrative of the session, capped from the front.
+    const actions = lines.slice(0, MAX_SECTION_LINES);
+    // Where the session ended up: the tail, which is the most recent state.
+    const outcomes = lines.length > MAX_SECTION_LINES
+        ? lines.slice(-Math.min(MAX_SECTION_LINES, lines.length - MAX_SECTION_LINES))
+        : lines.slice(-1);
+    // Commits are the durable decisions a session leaves behind.
+    const decisions = lines
+        .filter((line) => /\bgit\s+commit\b/i.test(line))
+        .slice(0, MAX_SECTION_LINES);
     const summarySection = [
-        "goals",
-        ...sharedLines.map((line) => `- ${line}`),
-        "",
-        "actions",
-        ...sharedLines.map((line) => `- ${line}`),
-        "",
-        "decisions",
-        ...sharedLines.map((line) => `- ${line}`),
+        ...section("actions", actions, "No relevant events captured."),
         "",
-        "blockers",
-        ...sharedLines.map((line) => `- ${line}`),
+        ...section("decisions", decisions, "No explicit decisions recorded."),
         "",
-        "outcomes",
-        ...sharedLines.map((line) => `- ${line}`),
+        ...section("outcomes", outcomes, "No outcomes captured."),
     ].join("\n");
     const facts = events
-        .map((event) => `- [${event.event_type}] ${extractEventText(event)}`)
-        .slice(0, 5);
+        .slice(0, MAX_FACT_LINES)
+        .map((event) => `- [${event.event_type}] ${extractEventText(event)}`);
     const factSection = ["facts", ...facts].join("\n");
     if (options.factMode === "summary-only") {
         return summarySection;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sessionmem",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "private": false,
   "type": "module",
   "description": "Local-first MCP memory layer for coding agents across Claude Code, Codex, Cursor, Cline, Windsurf, and other MCP-compatible hosts.",
@@ -28,10 +28,11 @@
     "lint": "eslint .",
     "typecheck": "tsc --noEmit",
     "benchmark": "node scripts/benchmark.mjs",
-    "postversion": "node -e \"const v=require('./package.json').version; ['package/package.json','.claude-plugin/plugin.json','server.json'].forEach(f=>{const o=require('./'+f);o.version=v;if(o.packages&&o.packages[0])o.packages[0].version=v;require('fs').writeFileSync('./'+f,JSON.stringify(o,null,2)+'\\n')})\" && npm run build"
+    "version": "node scripts/sync-version.mjs && git add package/package.json .claude-plugin/plugin.json server.json",
+    "postversion": "npm run build"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.105.0",
+    "@anthropic-ai/sdk": "^0.107.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "^12.4.1",
     "commander": "^15.0.0",

package/dist/core/session.js

@@ -1,4 +0,0 @@
-export function onSessionDisconnect(adapterName, error) {
-    const reason = error ? error.message : "unknown cause";
-    console.warn(`[sessionmem] ${adapterName} disconnected mid-session (${reason}). Continuing.`);
-}