sessionmem 1.1.2 → 1.3.0

package/dist/core/storage/memoryRepo.js

@@ -6,10 +6,12 @@ const UPSERT_INSERT_HEAD = `
   INSERT INTO memories (
     id, project_id, session_id, source_adapter, kind, content, normalized_content,
     importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
+    tags, expires_at,
     created_at, updated_at
   ) VALUES (
     @id, @project_id, @session_id, @source_adapter, @kind, @content, @normalized_content,
     @importance, @embedding, @embedding_dim, @embedding_version, @author, @origin_project_id,
+    @tags, @expires_at,
     COALESCE(@created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
     COALESCE(@updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
   )
@@ -26,6 +28,8 @@ const UPSERT_INSERT_TAIL = `
     embedding_version = excluded.embedding_version,
     author = excluded.author,
     origin_project_id = excluded.origin_project_id,
+    tags = excluded.tags,
+    expires_at = excluded.expires_at,
     created_at = excluded.created_at,
     updated_at = excluded.updated_at
 `;
@@ -39,10 +43,12 @@ function getStatements(db) {
     INSERT INTO memories (
       id, project_id, session_id, source_adapter, kind, content, normalized_content,
       importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
+      tags, expires_at,
       created_at, updated_at
     ) VALUES (
       @id, @project_id, @session_id, @source_adapter, @kind, @content, @normalized_content,
       @importance, @embedding, @embedding_dim, @embedding_version, @author, @origin_project_id,
+      @tags, @expires_at,
       COALESCE(@created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
       COALESCE(@updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
     )
@@ -51,10 +57,12 @@ function getStatements(db) {
     INSERT INTO memories (
       id, project_id, session_id, source_adapter, kind, content, normalized_content,
       importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
+      tags, expires_at,
       created_at, updated_at
     ) VALUES (
       @id, @project_id, @session_id, @source_adapter, 'summary', @content, @normalized_content,
       @importance, @embedding, @embedding_dim, @embedding_version, @author, @origin_project_id,
+      @tags, @expires_at,
       COALESCE(@created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
       COALESCE(@updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
     )
@@ -70,6 +78,8 @@ function getStatements(db) {
       embedding_version = excluded.embedding_version,
       author = excluded.author,
       origin_project_id = excluded.origin_project_id,
+      tags = excluded.tags,
+      expires_at = excluded.expires_at,
       updated_at = COALESCE(excluded.updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
     ON CONFLICT(id)
     DO UPDATE SET
@@ -84,16 +94,20 @@ function getStatements(db) {
       embedding_version = excluded.embedding_version,
       author = excluded.author,
       origin_project_id = excluded.origin_project_id,
+      tags = excluded.tags,
+      expires_at = excluded.expires_at,
       updated_at = COALESCE(excluded.updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
   `),
         listByProject: db.prepare(`
     SELECT
       id, project_id, session_id, source_adapter, kind, content, normalized_content,
       importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
+      tags, expires_at,
       access_count, last_accessed, created_at, updated_at
     FROM memories
     WHERE project_id = ?
-    ORDER BY updated_at DESC
+      AND (expires_at IS NULL OR expires_at > strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    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
@@ -110,6 +124,7 @@ function getStatements(db) {
       SELECT
         id, project_id, session_id, source_adapter, kind, content, normalized_content,
         importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
+        tags, expires_at,
         access_count, last_accessed, created_at, updated_at
       FROM memories
       WHERE project_id = ? AND id = ?
@@ -194,6 +209,8 @@ function toParams(input) {
         embedding_version: input.embedding_version ?? null,
         author: input.author ?? "",
         origin_project_id: input.origin_project_id ?? null,
+        tags: input.tags ?? null,
+        expires_at: input.expires_at ?? null,
         created_at: input.created_at ?? null,
         updated_at: input.updated_at ?? null,
     };

package/dist/core/storage/memorySearchRepo.js

@@ -1,22 +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 = ?
+    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(`
@@ -27,10 +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 = ?
+    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);
@@ -72,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);
 }
 /**
@@ -105,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.1.2",
+  "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.`);
-}