sessionmem 1.0.5 → 1.0.6

package/dist/cli/output.js

@@ -1,21 +1,29 @@
 export function formatTable(rows) {
     const ID_WIDTH = 36;
-    const IMP_WIDTH = 10;
+    const IMP_WIDTH = 14;
+    const ACC_WIDTH = 8;
     const DATE_WIDTH = 10;
-    const PREVIEW_WIDTH = 60;
+    const PREVIEW_WIDTH = 50;
     const header = "ID".padEnd(ID_WIDTH) +
         " | " +
         "importance".padEnd(IMP_WIDTH) +
         " | " +
+        "accesses".padEnd(ACC_WIDTH) +
+        " | " +
         "date".padEnd(DATE_WIDTH) +
         " | " +
         "preview";
     const lines = rows.map((row) => {
         const preview = row.content.replace(/\s+/g, " ").slice(0, PREVIEW_WIDTH);
         const date = row.createdAt.slice(0, 10);
+        const imp = row.effectiveImportance !== row.importance
+            ? `${row.importance}(${row.effectiveImportance})`
+            : String(row.importance);
         return (row.id.padEnd(ID_WIDTH) +
             " | " +
-            String(row.importance).padEnd(IMP_WIDTH) +
+            imp.padEnd(IMP_WIDTH) +
+            " | " +
+            String(row.accessCount).padEnd(ACC_WIDTH) +
             " | " +
             date.padEnd(DATE_WIDTH) +
             " | " +

package/dist/core/api/contracts.js

@@ -11,6 +11,9 @@ export const memorySchema = z.object({
     embedding: z.string().nullable(),
     embeddingDim: z.number().int().nullable(),
     embeddingVersion: z.string().nullable(),
+    accessCount: z.number().int().nonnegative(),
+    lastAccessed: z.string().nullable(),
+    effectiveImportance: z.number().int().min(1).max(10),
     createdAt: z.string().min(1),
     updatedAt: z.string().min(1),
 });
@@ -78,12 +81,6 @@ export const retrieveMemoriesRequestSchema = z.object({
     mode: z.enum(["auto", "on-demand"]).default("auto"),
     depth: z.enum(["default", "deep"]).default("default"),
 });
-export const recordMemoryUsedRequestSchema = z.object({
-    projectId: z.string().min(1),
-    memoryId: z.string().min(1),
-    feedbackType: z.enum(["auto_use", "manual"]).default("auto_use"),
-    usedAt: z.string().min(1).optional(),
-});
 export const listMemoriesRequestSchema = z.object({
     projectId: z.string().min(1),
 });
@@ -164,6 +161,13 @@ export const redactExistingResponseSchema = z.object({
     skipped: z.number().int().nonnegative().default(0),
     previews: z.array(z.string()),
 });
+export const resetAccessCountsRequestSchema = z.object({
+    projectId: z.string().min(1),
+});
+export const resetAccessCountsResponseSchema = z.object({
+    ok: z.literal(true),
+    affected: z.number().int().nonnegative(),
+});
 export const operationResultSchema = z.object({
     ok: z.literal(true),
 });
@@ -255,9 +259,29 @@ export const pullMemoriesResponseSchema = z.object({
     skippedCrossProject: z.number().int().nonnegative().default(0),
     warningCodes: z.array(z.string()),
 });
-export const recordMemoryUsedResponseSchema = z.object({
-    ok: z.literal(true),
+export const batchStoreMemoryItemSchema = z.object({
+    memoryId: z.string().min(1),
+    sessionId: z.string().min(1),
+    sourceAdapter: z.string().min(1),
+    kind: z.string().min(1),
+    content: z.string().min(1),
+    importance: z.number().int().min(1).max(10),
+    redactionEnabled: z.boolean().optional(),
+});
+export const batchStoreMemoryRequestSchema = z.object({
+    projectId: z.string().min(1),
+    memories: z.array(batchStoreMemoryItemSchema).min(1),
+});
+export const batchStoreMemoryResultSchema = z.object({
     memoryId: z.string().min(1),
-    previousImportance: z.number().int().min(1).max(10),
-    newImportance: z.number().int().min(1).max(10),
+    ok: z.boolean(),
+    memory: memorySchema.optional(),
+    warningCodes: z.array(z.string()).optional(),
+    error: z.string().optional(),
+});
+export const batchStoreMemoryResponseSchema = z.object({
+    ok: z.literal(true),
+    results: z.array(batchStoreMemoryResultSchema),
+    stored: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
 });

package/dist/core/api/memoryCoreService.js

@@ -2,12 +2,14 @@ import { userInfo } from "node:os";
 import { ZodError } from "zod";
 import { deterministicEmbed } from "../embed/deterministicEmbed.js";
 import { retrieveMemories } from "../retrieve/retrieveMemories.js";
+import { computeEffectiveImportance } from "../retrieve/score.js";
 import { formatStartupInjection } from "../injection/formatStartupInjection.js";
 import { applyRedaction } from "../summarize/redaction.js";
-import { countMemoriesOlderThan, deleteMemoriesOlderThan, insertMemory, listMemoriesByProject, recordUse, updateMemoryContent, upsertSessionSummaryMemory, } from "../storage/memoryRepo.js";
-import { configFilePath, readPolicyConfig, resolvePolicySettings, } from "../config/policyConfig.js";
+import { countMemoriesBySession, countMemoriesOlderThan, deleteMemoriesOlderThan, incrementAccessCounts, insertMemory, listMemoriesByProject, resetAccessCounts, updateMemoryContent, 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 { insertSessionEvent } from "../storage/sessionEventsRepo.js";
-import { exportMemoriesRequestSchema, forgetMemoryRequestSchema, getMemoryRequestSchema, handleSessionEndRequestSchema, importMemoriesRequestSchema, pullMemoriesRequestSchema, ingestSessionEventsRequestSchema, listMemoriesRequestSchema, pruneMemoriesRequestSchema, recordMemoryUsedRequestSchema, redactExistingRequestSchema, retrieveMemoriesRequestSchema, statsRequestSchema, storeMemoryRequestSchema, summarizeSessionToMemoryRequestSchema, } from "./contracts.js";
+import { batchStoreMemoryItemSchema, batchStoreMemoryRequestSchema, exportMemoriesRequestSchema, forgetMemoryRequestSchema, getMemoryRequestSchema, handleSessionEndRequestSchema, importMemoriesRequestSchema, pullMemoriesRequestSchema, ingestSessionEventsRequestSchema, listMemoriesRequestSchema, pruneMemoriesRequestSchema, redactExistingRequestSchema, resetAccessCountsRequestSchema, retrieveMemoriesRequestSchema, statsRequestSchema, storeMemoryRequestSchema, summarizeSessionToMemoryRequestSchema, } from "./contracts.js";
 import { DomainError, toErrorEnvelope } from "./errors.js";
 import { assertLocalOnlyPolicy, } from "./localOnlyPolicy.js";
 import { createSessionLifecycleService } from "./sessionLifecycleService.js";
@@ -48,6 +50,9 @@ function toMemoryDto(record) {
         embeddingVersion: record.embedding_version,
         author: record.author,
         originProjectId: record.origin_project_id,
+        accessCount: record.access_count,
+        lastAccessed: record.last_accessed,
+        effectiveImportance: computeEffectiveImportance(record.importance, record.access_count),
         createdAt: record.created_at,
         updatedAt: record.updated_at,
     };
@@ -67,6 +72,9 @@ function toRetrievedMemoryDto(record) {
         embeddingVersion: record.embedding_version,
         author: record.author,
         originProjectId: record.origin_project_id,
+        accessCount: record.access_count,
+        lastAccessed: null,
+        effectiveImportance: computeEffectiveImportance(record.importance, record.access_count),
         createdAt: record.created_at,
         updatedAt: record.updated_at,
         semantic: record.semantic,
@@ -75,14 +83,14 @@ function toRetrievedMemoryDto(record) {
 }
 function getMemoryById(db, projectId, memoryId) {
     const row = db
-        .prepare(`
-      SELECT
-        id, project_id, session_id, source_adapter, kind, content, normalized_content,
-        importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
-        created_at, updated_at
-      FROM memories
-      WHERE project_id = ? AND id = ?
-      LIMIT 1
+        .prepare(`
+      SELECT
+        id, project_id, session_id, source_adapter, kind, content, normalized_content,
+        importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
+        access_count, last_accessed, created_at, updated_at
+      FROM memories
+      WHERE project_id = ? AND id = ?
+      LIMIT 1
     `)
         .get(projectId, memoryId);
     return row;
@@ -188,6 +196,14 @@ export function createMemoryCoreService(deps) {
                 redactionEnabled: resolveRedactionEnabled(parsed.redactionEnabled),
             });
             const embedding = deterministicEmbed(redaction.text, dimension);
+            // Per-session write soft limit: warn the caller when the session has
+            // already accumulated SESSION_WRITE_SOFT_LIMIT memories so the agent
+            // gets feedback to stop storing excessively. The write still proceeds.
+            const warningCodes = [...redaction.warningCodes];
+            const sessionCount = countMemoriesBySession(db, parsed.sessionId);
+            if (sessionCount >= SESSION_WRITE_SOFT_LIMIT) {
+                warningCodes.push("session_write_limit_warning");
+            }
             insertMemory(db, {
                 id: parsed.memoryId,
                 project_id: parsed.projectId,
@@ -212,45 +228,30 @@ export function createMemoryCoreService(deps) {
             return {
                 ok: true,
                 memory: toMemoryDto(inserted),
-                warningCodes: redaction.warningCodes,
+                warningCodes,
             };
         },
         async retrieveMemories(request) {
             const parsed = parseRequest(retrieveMemoriesRequestSchema, request);
-            const limit = parsed.depth === "deep" ? Math.min(parsed.limit * 2, 100) : parsed.limit;
+            const limit = parsed.depth === "deep" ? Math.min(parsed.limit * 2, DEEP_MODE_RETRIEVAL_CAP) : parsed.limit;
             const ranked = retrieveMemories({
                 db,
                 projectId: parsed.projectId,
                 queryText: parsed.query,
                 limit,
             });
+            if (ranked.length > 0) {
+                incrementAccessCounts(db, parsed.projectId, ranked.map((m) => m.id));
+            }
             return {
                 ok: true,
                 memories: ranked.map(toRetrievedMemoryDto),
                 total: ranked.length,
-                // Render the startup-injection block here so the `author:`
-                // prefix annotation for teammate-authored memories reaches CLI/MCP
-                // callers via the production retrieval path.
                 startupInjection: formatStartupInjection(ranked, {
                     localUsername: localAuthor,
                 }),
             };
         },
-        async recordMemoryUsed(request) {
-            const parsed = parseRequest(recordMemoryUsedRequestSchema, request);
-            const result = recordUse(db, {
-                project_id: parsed.projectId,
-                memory_id: parsed.memoryId,
-                feedback_type: parsed.feedbackType,
-                used_at: parsed.usedAt,
-            });
-            return {
-                ok: true,
-                memoryId: result.memory_id,
-                previousImportance: result.previous_importance,
-                newImportance: result.new_importance,
-            };
-        },
         async listMemories(request) {
             const parsed = parseRequest(listMemoriesRequestSchema, request);
             const memories = listMemoriesByProject(db, parsed.projectId);
@@ -273,12 +274,24 @@ export function createMemoryCoreService(deps) {
         },
         async forgetMemory(request) {
             const parsed = parseRequest(forgetMemoryRequestSchema, request);
+            // Capture the memory's importance before deletion so we can record
+            // it in the feedback table as an analytics signal.
+            const existing = getMemoryById(db, parsed.projectId, parsed.memoryId);
             const result = db
                 .prepare("DELETE FROM memories WHERE project_id = ? AND id = ?")
                 .run(parsed.projectId, parsed.memoryId);
             if (result.changes === 0) {
                 throw new DomainError("NOT_FOUND", `Memory not found: ${parsed.memoryId}`);
             }
+            // Record the explicit user deletion as feedback. The FK on
+            // memory_feedback no longer cascades (migration 006), so this row
+            // survives the memory deletion and serves as an analytics signal.
+            insertMemoryFeedbackEvent(db, {
+                memory_id: parsed.memoryId,
+                feedback_type: "manual_delete",
+                previous_importance: existing?.importance ?? 0,
+                new_importance: 0,
+            });
             return {
                 ok: true,
             };
@@ -293,32 +306,32 @@ export function createMemoryCoreService(deps) {
         },
         async importMemories(request) {
             const parsed = parseRequest(importMemoriesRequestSchema, request);
-            const stmt = db.prepare(`
-        INSERT INTO memories (
-          id, project_id, session_id, source_adapter, kind, content, normalized_content,
-          importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
-          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,
-          COALESCE(@created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-          COALESCE(@updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-        )
-        ON CONFLICT(id) DO UPDATE SET
-          project_id = excluded.project_id,
-          session_id = excluded.session_id,
-          source_adapter = excluded.source_adapter,
-          kind = excluded.kind,
-          content = excluded.content,
-          normalized_content = excluded.normalized_content,
-          importance = excluded.importance,
-          embedding = excluded.embedding,
-          embedding_dim = excluded.embedding_dim,
-          embedding_version = excluded.embedding_version,
-          author = excluded.author,
-          origin_project_id = excluded.origin_project_id,
-          created_at = excluded.created_at,
-          updated_at = excluded.updated_at
+            const stmt = db.prepare(`
+        INSERT INTO memories (
+          id, project_id, session_id, source_adapter, kind, content, normalized_content,
+          importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
+          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,
+          COALESCE(@created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+          COALESCE(@updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+        )
+        ON CONFLICT(id) DO UPDATE SET
+          project_id = excluded.project_id,
+          session_id = excluded.session_id,
+          source_adapter = excluded.source_adapter,
+          kind = excluded.kind,
+          content = excluded.content,
+          normalized_content = excluded.normalized_content,
+          importance = excluded.importance,
+          embedding = excluded.embedding,
+          embedding_dim = excluded.embedding_dim,
+          embedding_version = excluded.embedding_version,
+          author = excluded.author,
+          origin_project_id = excluded.origin_project_id,
+          created_at = excluded.created_at,
+          updated_at = excluded.updated_at
       `);
             // `id` is a globally-unique PRIMARY KEY (not scoped by
             // project_id). The upsert above reassigns `project_id = excluded.project_id`
@@ -393,35 +406,35 @@ export function createMemoryCoreService(deps) {
             //    provenance so pulled rows carry the teammate's identity and
             //    their source project_id.
             //  - cross-project id collisions are skipped, exactly as import.
-            const stmt = db.prepare(`
-        INSERT INTO memories (
-          id, project_id, session_id, source_adapter, kind, content, normalized_content,
-          importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
-          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,
-          COALESCE(@created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
-          COALESCE(@updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-        )
-        ON CONFLICT(id) DO UPDATE SET
-          project_id = excluded.project_id,
-          session_id = excluded.session_id,
-          source_adapter = excluded.source_adapter,
-          kind = excluded.kind,
-          content = excluded.content,
-          normalized_content = excluded.normalized_content,
-          -- Importance-preserving merge. better-sqlite3@12 bundles a
-          -- SQLite that accepts the two-arg scalar MAX() inside DO UPDATE; the
-          -- pull-merge importance-preserve test verifies both directions.
-          importance = MAX(memories.importance, excluded.importance),
-          embedding = excluded.embedding,
-          embedding_dim = excluded.embedding_dim,
-          embedding_version = excluded.embedding_version,
-          author = excluded.author,
-          origin_project_id = excluded.origin_project_id,
-          created_at = excluded.created_at,
-          updated_at = excluded.updated_at
+            const stmt = db.prepare(`
+        INSERT INTO memories (
+          id, project_id, session_id, source_adapter, kind, content, normalized_content,
+          importance, embedding, embedding_dim, embedding_version, author, origin_project_id,
+          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,
+          COALESCE(@created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+          COALESCE(@updated_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+        )
+        ON CONFLICT(id) DO UPDATE SET
+          project_id = excluded.project_id,
+          session_id = excluded.session_id,
+          source_adapter = excluded.source_adapter,
+          kind = excluded.kind,
+          content = excluded.content,
+          normalized_content = excluded.normalized_content,
+          -- Importance-preserving merge. better-sqlite3@12 bundles a
+          -- SQLite that accepts the two-arg scalar MAX() inside DO UPDATE; the
+          -- pull-merge importance-preserve test verifies both directions.
+          importance = MAX(memories.importance, excluded.importance),
+          embedding = excluded.embedding,
+          embedding_dim = excluded.embedding_dim,
+          embedding_version = excluded.embedding_version,
+          author = excluded.author,
+          origin_project_id = excluded.origin_project_id,
+          created_at = excluded.created_at,
+          updated_at = excluded.updated_at
       `);
             // Same cross-project ownership skip as importMemories. A colliding
             // id owned by a different project is skipped, never overwritten/relocated.
@@ -565,6 +578,87 @@ export function createMemoryCoreService(deps) {
                 previews,
             };
         },
+        async batchStoreMemory(request) {
+            const parsed = parseRequest(batchStoreMemoryRequestSchema, request);
+            const results = [];
+            let stored = 0;
+            let failed = 0;
+            // Validate each item individually before entering the transaction so
+            // validation errors are reported per-item without aborting the whole batch.
+            const validatedItems = [];
+            for (let i = 0; i < parsed.memories.length; i++) {
+                const raw = parsed.memories[i];
+                try {
+                    // The array items were already parsed by batchStoreMemoryRequestSchema,
+                    // but we re-validate with the item schema so per-item errors are
+                    // captured individually (e.g. if a caller bypasses the outer schema).
+                    const item = batchStoreMemoryItemSchema.parse(raw);
+                    validatedItems.push({ index: i, item });
+                }
+                catch (err) {
+                    results.push({
+                        memoryId: raw.memoryId ?? `<index-${i}>`,
+                        ok: false,
+                        error: err instanceof ZodError
+                            ? err.issues.map((issue) => issue.message).join("; ")
+                            : String(err),
+                    });
+                    failed += 1;
+                }
+            }
+            // Wrap all valid inserts in a single SQLite transaction for atomicity
+            // and performance (better-sqlite3 transactions avoid per-statement
+            // fsync, making batch inserts significantly faster).
+            if (validatedItems.length > 0) {
+                const runTransaction = db.transaction(() => {
+                    for (const { item } of validatedItems) {
+                        const redaction = applyRedaction(item.content, {
+                            redactionEnabled: resolveRedactionEnabled(item.redactionEnabled),
+                        });
+                        const embedding = deterministicEmbed(redaction.text, dimension);
+                        insertMemory(db, {
+                            id: item.memoryId,
+                            project_id: parsed.projectId,
+                            session_id: item.sessionId,
+                            source_adapter: item.sourceAdapter,
+                            kind: item.kind,
+                            content: redaction.text,
+                            normalized_content: embedding.normalizedText,
+                            importance: item.importance,
+                            embedding: JSON.stringify(embedding.vector),
+                            embedding_dim: embedding.dimension,
+                            embedding_version: embedding.embeddingVersion,
+                            author: localAuthor,
+                            origin_project_id: null,
+                        });
+                        const inserted = getMemoryById(db, parsed.projectId, item.memoryId);
+                        if (!inserted) {
+                            throw new DomainError("INTERNAL", `Memory insert did not persist: ${item.memoryId}`);
+                        }
+                        results.push({
+                            memoryId: item.memoryId,
+                            ok: true,
+                            memory: toMemoryDto(inserted),
+                            warningCodes: redaction.warningCodes,
+                        });
+                        stored += 1;
+                    }
+                });
+                runTransaction();
+            }
+            // Sort results back into original input order: validated items were
+            // processed in order but failed items were pushed first. Re-sort by
+            // the memoryId to maintain a predictable output. Since memoryIds are
+            // unique, use the input array order as the canonical sort key.
+            const inputOrder = new Map(parsed.memories.map((m, i) => [m.memoryId, i]));
+            results.sort((a, b) => (inputOrder.get(a.memoryId) ?? 0) - (inputOrder.get(b.memoryId) ?? 0));
+            return {
+                ok: true,
+                results,
+                stored,
+                failed,
+            };
+        },
         async stats(request) {
             const parsed = parseRequest(statsRequestSchema, request);
             const memoryCount = db
@@ -579,6 +673,14 @@ export function createMemoryCoreService(deps) {
                 totalSessionEvents: sessionEventCount.count,
             };
         },
+        async resetAccessCounts(request) {
+            const parsed = parseRequest(resetAccessCountsRequestSchema, request);
+            const affected = resetAccessCounts(db, parsed.projectId);
+            return {
+                ok: true,
+                affected,
+            };
+        },
     };
     async function call(method, request) {
         try {

package/dist/core/api/sessionLifecycleService.js

@@ -185,8 +185,18 @@ export function createSessionLifecycleService(deps) {
                     memoryId,
                 };
             }
-            catch {
-                // fall back to local summarizer
+            catch (cloudError) {
+                const failureRecordId = createFailureId();
+                insertSummarizationFailure(deps.db, {
+                    id: failureRecordId,
+                    project_id: request.projectId,
+                    session_id: request.sessionId,
+                    source_adapter: request.sourceAdapter,
+                    reason: "cloud_failed",
+                    attempt_count: CLOUD_RETRY_CONFIG.retries + 1,
+                    last_error_json: toErrorJson(cloudError),
+                });
+                // fall through to local summarizer
             }
             try {
                 const fallbackResult = await summarizeLocal(baseInput);

package/dist/core/config/policyConfig.js

@@ -2,6 +2,19 @@ import { z } from "zod";
 import { homedir } from "os";
 import { join, dirname } from "path";
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
+/** Lower bound of the 1-10 importance scale. */
+export const MIN_IMPORTANCE = 1;
+/** Upper bound of the 1-10 importance scale. */
+export const MAX_IMPORTANCE = 10;
+/** Importance threshold at or above which a warning is considered critical. */
+export const CRITICAL_WARNING_IMPORTANCE_THRESHOLD = 9;
+/** Maximum number of memories returned by a "deep" retrieval. */
+export const DEEP_MODE_RETRIEVAL_CAP = 100;
+/**
+ * Default model for cloud summarization via the Anthropic API.
+ * Consumed by {@link import("../summarize/cloudSummarizer.js").summarizeWithCloud}.
+ */
+export const DEFAULT_SUMMARIZER_MODEL = "claude-sonnet-4-6";
 /**
  * Built-in policy defaults. Used whenever the config file is missing, malformed,
  * or fails validation, and as the lowest-precedence source in
@@ -116,6 +129,13 @@ export function resolvePolicySettings(input) {
         redactionEnabled: resolve("redactionEnabled"),
     };
 }
+/**
+ * Per-session write soft limit. When a session has stored at least this many
+ * memories, subsequent storeMemory calls still succeed but the response
+ * includes a "session_write_limit_warning" warningCode, giving the agent
+ * feedback to stop storing excessive memories in a single session.
+ */
+export const SESSION_WRITE_SOFT_LIMIT = 50;
 /**
  * Resolve the `team` config as a single object unit using precedence
  * override > config.json > default (RESEARCH Pitfall 5). Unlike

package/dist/core/injection/formatStartupInjection.js

@@ -1,3 +1,4 @@
+import { CRITICAL_WARNING_IMPORTANCE_THRESHOLD } from "../config/policyConfig.js";
 import { countTokens, trimLowestPriorityContent } from "./tokenBudget.js";
 const DEFAULT_TOKEN_CAP = 450;
 const HEADER = "Relevant prior context";
@@ -7,7 +8,7 @@ function kindRank(kind) {
     return KIND_RANK.get(kind) ?? KIND_ORDER.length;
 }
 function isCriticalWarning(memory) {
-    return memory.kind === "warning" && memory.importance >= 9;
+    return memory.kind === "warning" && memory.importance >= CRITICAL_WARNING_IMPORTANCE_THRESHOLD;
 }
 function sortMemories(memories) {
     return [...memories].sort((left, right) => {

package/dist/core/injection/tokenBudget.js

@@ -5,6 +5,14 @@ const DEFAULT_TRIM_RATIO = 0.75;
 export function countTokens(text) {
     return encoding.encode(text).length;
 }
+export function capTokens(text, cap) {
+    const tokens = encoding.encode(text);
+    if (tokens.length <= cap) {
+        return text;
+    }
+    const trimmed = encoding.decode(tokens.slice(0, cap)).trimEnd();
+    return `${trimmed} ...`;
+}
 export function trimLowestPriorityContent(included, options = {}) {
     const minContentTokens = options.minContentTokens ?? DEFAULT_MIN_CONTENT_TOKENS;
     const trimRatio = options.trimRatio ?? DEFAULT_TRIM_RATIO;

package/dist/core/retrieve/importance.js

@@ -1,6 +1,7 @@
+import { MIN_IMPORTANCE, MAX_IMPORTANCE } from "../config/policyConfig.js";
 export function normalizeImportance(score1to10) {
-    if (!Number.isFinite(score1to10) || score1to10 < 1 || score1to10 > 10) {
-        throw new Error("importance must be between 1 and 10");
+    if (!Number.isFinite(score1to10) || score1to10 < MIN_IMPORTANCE || score1to10 > MAX_IMPORTANCE) {
+        throw new Error(`importance must be between ${MIN_IMPORTANCE} and ${MAX_IMPORTANCE}`);
     }
-    return (score1to10 - 1) / 9;
+    return (score1to10 - MIN_IMPORTANCE) / (MAX_IMPORTANCE - MIN_IMPORTANCE);
 }

package/dist/core/retrieve/recencyBands.js

@@ -5,14 +5,7 @@ function toDate(value) {
 export function getRecencyBandScore(updatedAt, now = new Date()) {
     const updatedDate = toDate(updatedAt);
     const ageDays = Math.max(0, (now.getTime() - updatedDate.getTime()) / DAY_IN_MS);
-    if (ageDays <= 1) {
-        return 1.0;
-    }
-    if (ageDays <= 7) {
-        return 0.75;
-    }
-    if (ageDays <= 30) {
-        return 0.5;
-    }
-    return 0.25;
+    const HALF_LIFE_DAYS = 14;
+    const lambda = Math.LN2 / HALF_LIFE_DAYS;
+    return Math.max(0.05, Math.exp(-lambda * ageDays));
 }

package/dist/core/retrieve/retrieveMemories.js

@@ -1,6 +1,7 @@
 import { deterministicEmbed } from "../embed/deterministicEmbed.js";
+import { decayOldBoosts } from "./decay.js";
 import { scoreMemoryCandidate, } from "./score.js";
-import { searchMemoryCandidates, } from "../storage/memorySearchRepo.js";
+import { searchMemoryCandidates, searchMemoryCandidatesFTS, } from "../storage/memorySearchRepo.js";
 const DEFAULT_EMBEDDING_DIMENSION = 32;
 function resolveEmbeddingDimension(candidates) {
     for (const candidate of candidates) {
@@ -40,16 +41,27 @@ export function retrieveMemories(input) {
     }
     const topK = input.topK ?? input.limit ?? 20;
     const now = input.now ?? new Date();
-    const candidates = searchMemoryCandidates(input.db, input.projectId);
+    // Use FTS5 pre-filtering when a semantic query is present to limit
+    // cosine similarity computation to ~50 candidates instead of all.
+    const candidates = queryText
+        ? searchMemoryCandidatesFTS(input.db, input.projectId, queryText)
+        : searchMemoryCandidates(input.db, input.projectId);
+    const decayedCandidates = decayOldBoosts(candidates, now);
     const dimension = resolveEmbeddingDimension(candidates);
     const queryVector = deterministicEmbed(queryText, dimension).vector;
-    const ranked = candidates
+    const ranked = decayedCandidates
         .map((candidate) => {
-        const semantic = cosineSimilarity(queryVector, candidate.embedding);
+        // When embedding is null (version mismatch or missing), use a neutral
+        // score of 0.5 so the memory is neither penalized nor boosted.
+        const semantic = candidate.embedding === null
+            ? 0.5
+            : cosineSimilarity(queryVector, candidate.embedding);
         const score = scoreMemoryCandidate({
             semantic,
             updated_at: candidate.updated_at,
             importance: candidate.importance,
+            access_count: candidate.access_count,
+            decayedImportance: candidate.decayedImportance,
         }, now);
         return {
             id: candidate.id,
@@ -62,6 +74,7 @@ export function retrieveMemories(input) {
             importance: candidate.importance,
             author: candidate.author,
             origin_project_id: candidate.origin_project_id,
+            access_count: candidate.access_count,
             created_at: candidate.created_at,
             updated_at: candidate.updated_at,
             embedding_dim: candidate.embedding_dim,