sessionmem 1.6.0 → 1.8.0

package/dist/cli/commands/watch.js

@@ -1,3 +1,5 @@
+import { openWatchLog } from "../watchLog.js";
+import { saveWatchCheckpoint } from "../watchCheckpoint.js";
 import { setTimeout } from "node:timers/promises";
 import { createCliContext } from "../context.js";
 import { printSweepSummary, sweepTranscripts } from "../transcriptSweep.js";
@@ -6,16 +8,20 @@ export async function watchCommand(options = {}, ctx) {
     if (!Number.isFinite(interval) || interval <= 0 || interval > 86400) {
         throw new Error("--interval must be a number greater than 0 and at most 86400 seconds");
     }
-    const context = ctx ?? createCliContext();
+    const closeLog = openWatchLog(options.logFile);
+    let context;
     const controller = new AbortController();
     const stop = () => controller.abort();
     process.once("SIGINT", stop);
     process.once("SIGTERM", stop);
     let firstSweep = true;
     try {
+        console.log(`sessionmem watch starting (pid ${process.pid}, interval ${interval}s)`);
+        context = ctx ?? createCliContext({ dbPath: options.dbPath });
         do {
             try {
                 const summary = await sweepTranscripts(context, options);
+                saveWatchCheckpoint(context, summary, interval);
                 if (firstSweep || options.once || summary.sessionsImported || summary.errors) {
                     printSweepSummary("watch", summary);
                 }
@@ -39,10 +45,16 @@ export async function watchCommand(options = {}, ctx) {
             }
         } while (!controller.signal.aborted);
     }
+    catch (error) {
+        console.error(`[sessionmem] watch failed: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+        throw error;
+    }
     finally {
         process.removeListener("SIGINT", stop);
         process.removeListener("SIGTERM", stop);
         if (!ctx)
-            context.db.close();
+            context?.db.close();
+        console.log("sessionmem watch stopped");
+        closeLog();
     }
 }

package/dist/cli/index.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
+import { autostartCommand } from "./commands/autostart.js";
 import { Command } from "commander";
 import { createRequire } from "node:module";
 import { runMcpServer } from "./commands/run.js";
+import { promptSubmitCommand } from "./commands/promptSubmit.js";
 import { sessionStartCommand } from "./commands/sessionStart.js";
 import { sessionEndCommand } from "./commands/sessionEnd.js";
 import { installCommand } from "./commands/install.js";
@@ -50,6 +52,7 @@ program
     .command("session-start")
     .description("Print prior memory context for the current project as Claude Code SessionStart hook output (invoked automatically by the hook installed during `sessionmem install`)")
     .action(() => sessionStartCommand());
+program.command("prompt-submit").description("Inject relevant context for a UserPromptSubmit hook").action(() => promptSubmitCommand());
 program
     .command("session-end")
     .description("Run the session-end pipeline (auto-summarize ingested session events + light retention prune) for the current project (invoked automatically by the SessionEnd hook installed during `sessionmem install`)")
@@ -69,22 +72,28 @@ program
     .description("Poll Claude Code, Codex, and Cursor transcripts and capture sessions offline")
     .option("--transcripts-dir <path>", "Override transcript roots (Cursor: User directory or state.vscdb)")
     .option("--host <host>", "Select a transcript host: claude-code, codex, or cursor")
+    .option("--db-path <path>", "Database file for headless capture")
+    .option("--log-file <path>", "Append timestamped stdout, stderr and startup failures to a file")
     .option("--once", "Run one sweep and exit")
     .option("--interval <seconds>", "Seconds between sweeps", "5")
     .action((options) => watchCommand(options));
 program
     .command("install")
-    .description("Install sessionmem into every detected agent host")
+    .description("Install integrations and enable login transcript capture")
     .option("--adapter <name>", "Force a host adapter instead of auto-detecting (claude-code, cursor, windsurf, cline, codex, antigravity, qcoder, generic)")
     .action((options) => installCommand(options));
+program
+    .command("autostart <action>")
+    .description("Control login capture: enable, disable, or status")
+    .action((action) => autostartCommand(action));
 program
     .command("doctor")
-    .description("Check storage, transcript discovery, hooks, MCP wiring, and recall offline")
+    .description("Check login capture, storage, transcripts, hooks, MCP wiring, and recall offline")
     .option("--adapter <name>", "Check a specific host instead of installed-host detection")
     .action(async (options) => { await doctorCommand(options); });
 program
     .command("uninstall")
-    .description("Remove sessionmem from the current MCP host")
+    .description("Stop login capture and remove sessionmem from the current MCP host")
     .option("--purge", "Also delete the local memories database")
     .option("--adapter <name>", "Force a host adapter instead of auto-detecting (claude-code, cursor, windsurf, cline, codex, antigravity, qcoder, generic)")
     .action((options) => uninstallCommand(options));

package/dist/cli/projectId.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { existsSync } from "node:fs";
+import { existsSync, realpathSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 /** Safety bound on the upward walk in {@link findProjectRoot}. */
 const MAX_PARENT_WALK = 64;
@@ -110,5 +110,20 @@ export function deriveProjectId(cwd = process.cwd()) {
             return sanitized;
         }
     }
-    return projectIdFromCwd(findProjectRoot(cwd) ?? cwd);
+    const canonical = canonicalDir(cwd);
+    return projectIdFromCwd(findProjectRoot(canonical) ?? canonical);
+}
+/**
+ * Resolve symlinks so the same directory hashes to one id however it is
+ * spelled. process.cwd() is already symlink-resolved, but a hook payload cwd is
+ * not (on macOS /var/... vs /private/var/...). Falls back to the input when the
+ * path does not exist.
+ */
+function canonicalDir(dir) {
+    try {
+        return realpathSync(dir);
+    }
+    catch {
+        return dir;
+    }
 }

package/dist/cli/watchCheckpoint.js

@@ -0,0 +1,35 @@
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+export const watchCheckpointPath = (dbPath) => join(dirname(resolve(dbPath)), `${basename(dbPath)}.watch-checkpoint.json`);
+export function saveWatchCheckpoint(context, summary, intervalSeconds) {
+    if (context.dbPath === ":memory:")
+        return;
+    const path = watchCheckpointPath(context.dbPath);
+    const checkpoint = {
+        dbPath: resolve(context.dbPath), completedAt: new Date().toISOString(), intervalSeconds,
+        checkpointCount: context.db.prepare("SELECT count(*) AS n FROM transcript_checkpoints").get().n,
+        summary,
+    };
+    const temp = `${path}.${process.pid}.tmp`;
+    writeFileSync(temp, JSON.stringify(checkpoint), { mode: 0o600 });
+    renameSync(temp, path);
+}
+export function inspectWatchCheckpoint(dbPath, now = Date.now()) {
+    const checkpoint = JSON.parse(readFileSync(watchCheckpointPath(dbPath), "utf8"));
+    const age = now - Date.parse(checkpoint.completedAt);
+    if (checkpoint.dbPath !== resolve(dbPath))
+        throw new Error("Watcher checkpoint belongs to a different database");
+    if (!Number.isFinite(checkpoint.intervalSeconds) || checkpoint.intervalSeconds <= 0 || checkpoint.intervalSeconds > 86400)
+        throw new Error("Invalid watcher checkpoint interval");
+    if (!Number.isFinite(age) || age < -60000 || age > Math.max(120000, checkpoint.intervalSeconds * 3000))
+        throw new Error(`Watcher checkpoint is stale or invalid (${checkpoint.completedAt})`);
+    if (!checkpoint.summary || Object.values(checkpoint.summary).length !== 5 || Object.values(checkpoint.summary).some(value => !Number.isInteger(value) || value < 0))
+        throw new Error("Invalid watcher sweep counters");
+    if (checkpoint.summary.errors !== 0)
+        throw new Error(`Last watcher sweep had ${checkpoint.summary.errors} capture error(s)`);
+    if (!Number.isInteger(checkpoint.checkpointCount) || checkpoint.checkpointCount < 0)
+        throw new Error("Invalid transcript checkpoint count");
+    if (checkpoint.summary.filesFound > 0 && checkpoint.checkpointCount === 0)
+        throw new Error("Transcripts found but none checkpointed yet");
+    return `Sweep completed ${Math.max(0, Math.round(age / 1000))}s ago; ${checkpoint.checkpointCount} transcript checkpoint(s); ${checkpoint.summary.filesFound} source file(s)`;
+}

package/dist/cli/watchLog.js

@@ -0,0 +1,23 @@
+import { mkdirSync, openSync, closeSync, writeSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+/** Redirect both streams before opening storage so headless startup failures land
+ * in the same log as per-file capture failures. Never reads stdin or uses a TTY. */
+export function openWatchLog(path) {
+    if (!path)
+        return () => { };
+    const absolute = resolve(path);
+    mkdirSync(dirname(absolute), { recursive: true });
+    const fd = openSync(absolute, "a", 0o600);
+    const stdout = process.stdout.write;
+    const stderr = process.stderr.write;
+    const write = ((chunk, encodingOrCallback, callback) => {
+        const value = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString();
+        writeSync(fd, `${new Date().toISOString()} ${value}`);
+        const done = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+        done?.();
+        return true;
+    });
+    process.stdout.write = write;
+    process.stderr.write = write;
+    return () => { process.stdout.write = stdout; process.stderr.write = stderr; closeSync(fd); };
+}

package/dist/core/api/contracts.js

@@ -179,6 +179,25 @@ export const getMemoryRequestSchema = z.object({
     projectId: z.string().min(1),
     memoryId: z.string().min(1).max(200),
 });
+export const searchMemoryIndexRequestSchema = retrieveMemoriesRequestSchema
+    .pick({ projectId: true, query: true, includeHistory: true, tags: true })
+    .extend({ limit: z.number().int().min(1).max(50).default(10) });
+export const memoryTimelineRequestSchema = z.object({
+    projectId: z.string().min(1),
+    memoryId: z.string().min(1).max(200).optional(),
+    fromDate: z.iso.datetime().optional(),
+    toDate: z.iso.datetime().optional(),
+    includeHistory: z.boolean().default(true),
+    limit: z.number().int().min(1).max(50).default(10),
+}).refine(value => value.memoryId !== undefined
+    ? value.fromDate === undefined && value.toDate === undefined
+    : value.fromDate !== undefined && value.toDate !== undefined && Date.parse(value.fromDate) <= Date.parse(value.toDate), { message: "Provide memoryId alone, or fromDate and toDate in chronological order" });
+export const memoryIndexItemSchema = z.object({
+    id: z.string(), summary: z.string().max(160), kind: z.string(), date: z.string(), score: z.number().nullable(),
+});
+export const memoryIndexResponseSchema = z.object({
+    ok: z.literal(true), memories: z.array(memoryIndexItemSchema), hasMore: z.boolean(),
+});
 export const forgetMemoryRequestSchema = z.object({
     projectId: z.string().min(1),
     memoryId: z.string().min(1).max(200),

package/dist/core/api/memoryCoreService.js

@@ -1,6 +1,11 @@
 import { userInfo } from "node:os";
 import { ZodError } from "zod";
 import { deterministicEmbed } from "../embed/deterministicEmbed.js";
+import { loadLocalSemanticEmbedder } from "../embed/localSemanticEmbedder.js";
+import { indexSemanticMemories, searchSemanticMemories } from "../storage/semanticSearchRepo.js";
+import { detectTemporalIntent } from "../retrieve/temporalIntent.js";
+import { memoryIndexItem } from "../retrieve/memoryIndex.js";
+import { memoryTimeline } from "../storage/timelineRepo.js";
 import { retrieveMemories } from "../retrieve/retrieveMemories.js";
 import { computeEffectiveImportance } from "../retrieve/score.js";
 import { formatStartupInjection } from "../injection/formatStartupInjection.js";
@@ -9,7 +14,7 @@ import { countAllMemoriesByProject, countMemoriesBySession, countMemoriesOlderTh
 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, 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 { batchStoreMemoryItemSchema, batchStoreMemoryRequestSchema, exportMemoriesRequestSchema, forgetMemoryRequestSchema, getMemoryRequestSchema, handleSessionEndRequestSchema, importMemoriesRequestSchema, pullMemoriesRequestSchema, ingestSessionEventsRequestSchema, LIST_MEMORIES_DEFAULT_LIMIT, listMemoriesRequestSchema, pruneMemoriesRequestSchema, redactExistingRequestSchema, resetAccessCountsRequestSchema, retrieveMemoriesRequestSchema, searchMemoryIndexRequestSchema, memoryTimelineRequestSchema, statsRequestSchema, storeMemoryRequestSchema, summarizeSessionToMemoryRequestSchema, } from "./contracts.js";
 import { DomainError, toErrorEnvelope } from "./errors.js";
 import { assertLocalOnlyPolicy, } from "./localOnlyPolicy.js";
 import { createSessionLifecycleService } from "./sessionLifecycleService.js";
@@ -150,6 +155,21 @@ export function createMemoryCoreService(deps) {
     // Resolve the local author identity once per service instance.
     const localAuthor = resolveServiceUsername(deps.username);
     const policyConfigPath = deps.policyConfigPath ?? configFilePath();
+    let semanticWarningShown = false;
+    async function semanticEmbedder() {
+        if (!readPolicyConfig(policyConfigPath).semanticSearch)
+            return null;
+        const embedder = deps.semanticEmbedder === undefined ? await loadLocalSemanticEmbedder() : deps.semanticEmbedder;
+        if (!embedder)
+            semanticWarning();
+        return embedder;
+    }
+    function semanticWarning() {
+        if (!semanticWarningShown) {
+            console.error("Local semantic retrieval unavailable; using BM25.");
+            semanticWarningShown = true;
+        }
+    }
     /**
      * Resolve the effective redactionEnabled flag using precedence
      * override (explicit per-request value) > config.json > default,
@@ -172,6 +192,48 @@ export function createMemoryCoreService(deps) {
         now: deps.now,
         deleteOldMemories: deps.deleteOldMemories,
     });
+    async function rankMemories(parsed, limit) {
+        const now = deps.now?.() ?? new Date();
+        const config = readPolicyConfig(policyConfigPath);
+        const intent = config.temporalRetrieval ? detectTemporalIntent(parsed.query, now) : { kind: "none" };
+        const includeHistory = parsed.includeHistory ?? intent.kind === "past";
+        let semanticCandidates;
+        try {
+            const embedder = await semanticEmbedder();
+            if (embedder)
+                semanticCandidates = await searchSemanticMemories(db, parsed.projectId, parsed.query, now, includeHistory, embedder);
+        }
+        catch {
+            semanticWarning();
+        }
+        const rankedAll = retrieveMemories({
+            db,
+            projectId: parsed.projectId,
+            queryText: parsed.query,
+            includeHistory,
+            temporalRetrieval: config.temporalRetrieval,
+            // Measured mode-specific default: coverage helps BM25, but regresses
+            // MiniLM recall. An explicit override always wins, including false.
+            entityLinkBoost: config.entityLinkBoost ?? (!semanticCandidates?.length && (!config.retrievalRanking || config.retrievalRanking === "legacy")),
+            ranking: config.retrievalRanking,
+            limit,
+            now,
+            semanticCandidates,
+        });
+        // Optional tag filter: keep a memory only when its stored tags contain ALL
+        // requested tags. The semantic candidate projection omits tags, so re-read
+        // each row's tags by id (this is an explicit, infrequent filter path).
+        const ranked = parsed.tags && parsed.tags.length > 0
+            ? rankedAll.filter((m) => {
+                const rec = getMemoryRecordById(db, parsed.projectId, m.id);
+                const recTags = rec?.tags
+                    ? JSON.parse(rec.tags)
+                    : [];
+                return parsed.tags.every((t) => recTags.includes(t));
+            })
+            : rankedAll;
+        return ranked.slice(0, limit);
+    }
     const methods = {
         async ingestSessionEvents(request) {
             const parsed = parseRequest(ingestSessionEventsRequestSchema, request);
@@ -299,6 +361,15 @@ export function createMemoryCoreService(deps) {
             if (!inserted) {
                 throw new DomainError("INTERNAL", "Memory insert did not persist");
             }
+            // Optional indexing never turns a successful durable capture into a failure.
+            try {
+                const embedder = await semanticEmbedder();
+                if (embedder)
+                    await indexSemanticMemories(db, parsed.projectId, embedder, parsed.memoryId);
+            }
+            catch {
+                semanticWarning();
+            }
             return {
                 ok: true,
                 // Single-record write echo-back: return the FULL stored body (uncapped),
@@ -314,26 +385,7 @@ export function createMemoryCoreService(deps) {
         async retrieveMemories(request) {
             const parsed = parseRequest(retrieveMemoriesRequestSchema, request);
             const limit = parsed.depth === "deep" ? Math.min(parsed.limit * 2, DEEP_MODE_RETRIEVAL_CAP) : parsed.limit;
-            const rankedAll = retrieveMemories({
-                db,
-                projectId: parsed.projectId,
-                queryText: parsed.query,
-                includeHistory: parsed.includeHistory,
-                limit,
-                now: deps.now?.(),
-            });
-            // Optional tag filter: keep a memory only when its stored tags contain ALL
-            // requested tags. The semantic candidate projection omits tags, so re-read
-            // each row's tags by id (this is an explicit, infrequent filter path).
-            const ranked = parsed.tags && parsed.tags.length > 0
-                ? rankedAll.filter((m) => {
-                    const rec = getMemoryRecordById(db, parsed.projectId, m.id);
-                    const recTags = rec?.tags
-                        ? JSON.parse(rec.tags)
-                        : [];
-                    return parsed.tags.every((t) => recTags.includes(t));
-                })
-                : rankedAll;
+            const ranked = await rankMemories(parsed, limit);
             if (ranked.length > 0 && parsed.mode !== "on-demand") {
                 // Only boost access counts for startup injection (mode='auto'), not for
                 // explicit on-demand retrieval, so a mid-session lookup does not inflate
@@ -353,6 +405,17 @@ export function createMemoryCoreService(deps) {
                 }),
             };
         },
+        async searchMemoryIndex(request) {
+            const parsed = parseRequest(searchMemoryIndexRequestSchema, request);
+            const ranked = await rankMemories(parsed, parsed.limit + 1);
+            return { ok: true, memories: ranked.slice(0, parsed.limit).map(row => memoryIndexItem(row, row.score.total)),
+                hasMore: ranked.length > parsed.limit };
+        },
+        async memoryTimeline(request) {
+            const parsed = parseRequest(memoryTimelineRequestSchema, request);
+            const { rows, hasMore } = memoryTimeline(db, parsed, deps.now?.() ?? new Date());
+            return { ok: true, memories: rows.map(row => memoryIndexItem(row)), hasMore };
+        },
         async listMemories(request) {
             const parsed = parseRequest(listMemoriesRequestSchema, request);
             const all = listMemoriesByProject(db, parsed.projectId);

package/dist/core/config/policyConfig.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { RETRIEVAL_RANKINGS } from "../retrieve/signalFusion.js";
 import { homedir } from "os";
 import { join, dirname } from "path";
 import { mkdirSync, readFileSync, writeFileSync, renameSync } from "fs";
@@ -53,6 +54,10 @@ const policyConfigShape = {
     // built-in DEFAULT_INJECTION_CAP used by formatStartupInjection and the
     // `savings` analytics. Omitted by default so existing configs keep the default.
     injectionCap: z.number().int().min(100).max(10000).optional(),
+    semanticSearch: z.boolean().optional(),
+    temporalRetrieval: z.boolean().optional(),
+    entityLinkBoost: z.boolean().optional(),
+    retrievalRanking: z.enum(RETRIEVAL_RANKINGS).optional(),
     team: teamConfigShape.default({ enabled: false }),
 };
 /**
@@ -107,11 +112,19 @@ export function readPolicyConfig(filePath) {
     const rd = s.retentionDays.safeParse(obj.retentionDays);
     const re = s.redactionEnabled.safeParse(obj.redactionEnabled);
     const ic = s.injectionCap.safeParse(obj.injectionCap);
+    const ss = s.semanticSearch.safeParse(obj.semanticSearch);
+    const tr = s.temporalRetrieval.safeParse(obj.temporalRetrieval);
+    const el = s.entityLinkBoost.safeParse(obj.entityLinkBoost);
+    const rr = s.retrievalRanking.safeParse(obj.retrievalRanking);
     const tm = s.team.safeParse(obj.team);
     return {
         retentionDays: rd.success ? rd.data : DEFAULT_POLICY_CONFIG.retentionDays,
         redactionEnabled: re.success ? re.data : DEFAULT_POLICY_CONFIG.redactionEnabled,
         injectionCap: ic.success ? ic.data : undefined,
+        semanticSearch: ss.success ? ss.data : undefined,
+        temporalRetrieval: tr.success ? tr.data : undefined,
+        entityLinkBoost: el.success ? el.data : undefined,
+        retrievalRanking: rr.success ? rr.data : undefined,
         team: tm.success ? tm.data : { ...DEFAULT_POLICY_CONFIG.team },
     };
 }

package/dist/core/embed/localSemanticEmbedder.js

@@ -0,0 +1,62 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+const MODEL_SHA = "6fd5d72fe4589f189f8ebc006442dbb529bb7ce38f8082112682524616046452";
+const TOKENIZER_SHA = "be50c3628f2bf5bb5e3a7f17b1f74611b2561a3a27eeab05e5aa30f411572037";
+export const LOCAL_SEMANTIC_MODEL = `minilm-l6-v2:${MODEL_SHA}:${TOKENIZER_SHA}:mean256-v1`;
+let loaded;
+/** Only local package files are opened. No download or remote provider path. */
+export function loadLocalSemanticEmbedder() {
+    return loaded ??= load().catch(() => null);
+}
+async function load() {
+    const require = createRequire(import.meta.url);
+    const model = require.resolve("@xcidos/genesis-memory-model/onnx/model.onnx");
+    const tokenizerPath = require.resolve("@xcidos/genesis-memory-model/tokenizer.json");
+    for (const [file, expected] of [[model, MODEL_SHA], [tokenizerPath, TOKENIZER_SHA]]) {
+        if (createHash("sha256").update(readFileSync(file)).digest("hex") !== expected) {
+            throw new Error("Local semantic model checksum mismatch");
+        }
+    }
+    // ORT 1.30 can initialize a native HTTP telemetry uploader on POSIX.
+    // Its full opt-out must be set before the native environment is created;
+    // JavaScript network guards cannot intercept native library sockets.
+    process.env.ORT_DISABLE_TELEMETRY = "1";
+    const ort = await import("onnxruntime-node");
+    const { Tokenizer } = await import("@huggingface/tokenizers");
+    const tokenizer = new Tokenizer(JSON.parse(readFileSync(tokenizerPath, "utf8")), {});
+    const session = await ort.InferenceSession.create(model, {
+        executionProviders: ["cpu"], intraOpNumThreads: 1, interOpNumThreads: 1,
+        logSeverityLevel: 3,
+    });
+    return {
+        id: LOCAL_SEMANTIC_MODEL, dimension: 384,
+        async embed(text) {
+            let ids = tokenizer.encode(text).ids;
+            if (ids.length > 256)
+                ids = [...ids.slice(0, 255), 102]; // retain BERT's SEP
+            const input = new ort.Tensor("int64", BigInt64Array.from(ids, BigInt), [1, ids.length]);
+            const ones = new ort.Tensor("int64", new BigInt64Array(ids.length).fill(1n), [1, ids.length]);
+            const zeros = new ort.Tensor("int64", new BigInt64Array(ids.length), [1, ids.length]);
+            let output;
+            try {
+                output = await session.run({ input_ids: input, attention_mask: ones, token_type_ids: zeros });
+                const hidden = output.last_hidden_state.data;
+                const vector = new Array(384).fill(0);
+                for (let token = 0; token < ids.length; token++) {
+                    for (let dim = 0; dim < 384; dim++)
+                        vector[dim] += hidden[token * 384 + dim] / ids.length;
+                }
+                const norm = Math.hypot(...vector);
+                return vector.map(v => v / (norm || 1));
+            }
+            finally {
+                input.dispose();
+                ones.dispose();
+                zeros.dispose();
+                for (const tensor of Object.values(output ?? {}))
+                    tensor.dispose();
+            }
+        },
+    };
+}

package/dist/core/retrieve/memoryIndex.js

@@ -0,0 +1,6 @@
+/** Extractive preview only. No generated summary or extra inference. */
+export function memoryIndexItem(memory, score = null) {
+    const text = memory.content.replace(/\s+/g, " ").trim();
+    return { id: memory.id, summary: text.length > 160 ? `${text.slice(0, 157)}...` : text,
+        kind: memory.kind, date: memory.created_at, score: score === null ? null : Math.round(score * 10000) / 10000 };
+}

package/dist/core/retrieve/retrieveMemories.js

@@ -1,8 +1,12 @@
 import { entityOverlap } from "../storage/knowledgeRepo.js";
+import { linkedEntityScores } from "../storage/entityLinkRepo.js";
+import { memoryTemporalMetadata } from "../storage/temporalRepo.js";
+import { adaptiveLexicalScore, additiveRelevance, SEMANTIC_GATE } from "./signalFusion.js";
+import { detectTemporalIntent, temporalRelevance } from "./temporalIntent.js";
 import { deterministicEmbed } from "../embed/deterministicEmbed.js";
 import { decayOldBoosts } from "./decay.js";
 import { scoreMemoryCandidate, } from "./score.js";
-import { searchMemoryCandidatesFTS, } from "../storage/memorySearchRepo.js";
+import { searchMemoryCandidatesFTS, searchMemoryCandidatesByIds, } from "../storage/memorySearchRepo.js";
 const DEFAULT_EMBEDDING_DIMENSION = 32;
 // Small, fixed contribution inside the existing relevance component. Keep the
 // public score shape/outer recency and importance weights unchanged.
@@ -45,17 +49,42 @@ export function retrieveMemories(input) {
     }
     const topK = input.topK ?? input.limit ?? 20;
     const now = input.now ?? new Date();
+    const ranking = input.ranking ?? "legacy";
+    const additive = ranking === "hub-additive" || ranking === "adaptive-hub-additive";
+    const adaptive = ranking === "adaptive-bm25" || ranking === "adaptive-hub-additive";
+    const intent = input.temporalRetrieval ? detectTemporalIntent(queryText, now) : { kind: "none" };
+    const includeHistory = input.includeHistory ?? intent.kind === "past";
     // FTS5 retrieves up to 50 BM25 matches; sparse matches retain the existing
     // recency/importance fallback. The public request schema validates queryText.
-    const candidates = searchMemoryCandidatesFTS(input.db, input.projectId, queryText, now, input.includeHistory);
+    const lexicalCandidates = searchMemoryCandidatesFTS(input.db, input.projectId, queryText, now, includeHistory);
+    const candidates = [...lexicalCandidates];
+    const ids = new Set(candidates.map(c => c.id));
+    const linked = input.entityLinkBoost || additive
+        ? linkedEntityScores(input.db, input.projectId, queryText, now, includeHistory, additive)
+        : new Map();
+    for (const candidate of searchMemoryCandidatesByIds(input.db, input.projectId, [...linked.keys()].slice(0, 50), now, includeHistory)) {
+        if (!ids.has(candidate.id)) {
+            candidates.push(candidate);
+            ids.add(candidate.id);
+        }
+    }
+    for (const { candidate } of input.semanticCandidates ?? []) {
+        if (!ids.has(candidate.id)) {
+            candidates.push(candidate);
+            ids.add(candidate.id);
+        }
+    }
+    const dense = new Map(input.semanticCandidates?.map(c => [c.candidate.id, c.similarity]));
     const decayedCandidates = decayOldBoosts(candidates, now);
     const dimension = resolveEmbeddingDimension(candidates);
     const queryVector = deterministicEmbed(queryText, dimension).vector;
     const overlap = entityOverlap(input.db, input.projectId, queryText, now);
+    const temporal = intent.kind !== "none" ? memoryTemporalMetadata(input.db, input.projectId, candidates.map(c => c.id)) : new Map();
     // FTS5 returns negative BM25 ranks; storage converts them to positive scores.
     // Normalize within this query so BM25 fits the existing relevance weight.
     const maxLexicalScore = candidates.reduce((max, candidate) => Math.max(max, candidate.lexical_score), 0);
     const ranked = decayedCandidates
+        .filter(candidate => !additive || !input.semanticCandidates?.length || (dense.get(candidate.id) ?? 0) >= SEMANTIC_GATE)
         .map((candidate) => {
         // When embedding is null (version mismatch or missing), use a neutral
         // score of 0.5 so the memory is neither penalized nor boosted. A non-null
@@ -68,18 +97,37 @@ export function retrieveMemories(input) {
             : cosineSimilarity(queryVector, candidate.embedding);
         // Hash cosine is useful for identical text, but adds noise to lexical
         // matches. Keep it as a diagnostic and as the no-match fallback only.
-        const baseRelevance = maxLexicalScore > 0
-            ? candidate.lexical_score / maxLexicalScore
+        const lexicalRelevance = maxLexicalScore > 0
+            ? adaptive ? adaptiveLexicalScore(candidate.lexical_score, queryText) : candidate.lexical_score / maxLexicalScore
             : semantic;
-        const relevance = overlap.size > 0
-            ? (1 - ENTITY_RELEVANCE_WEIGHT) * baseRelevance + ENTITY_RELEVANCE_WEIGHT * (overlap.get(candidate.id) ?? 0)
-            : baseRelevance;
+        // The local dense variant was weaker alone. Preserve lexical dominance
+        // while admitting candidates absent from FTS, using a fixed 2:1 blend.
+        const baseRelevance = input.semanticCandidates?.length
+            ? maxLexicalScore > 0
+                ? (2 * lexicalRelevance + Math.max(0, dense.get(candidate.id) ?? 0)) / 3
+                : Math.max(0, dense.get(candidate.id) ?? 0)
+            : lexicalRelevance;
+        const fused = additive ? additiveRelevance({
+            lexical: maxLexicalScore > 0 ? lexicalRelevance : undefined,
+            dense: input.semanticCandidates?.length ? Math.max(0, dense.get(candidate.id) ?? 0) : undefined,
+            entity: linked.size > 0 ? linked.get(candidate.id) ?? 0 : undefined,
+        }) : null;
+        const entityRelevance = additive && fused !== null ? fused : linked.size > 0
+            ? 0.8 * baseRelevance + 0.2 * (linked.get(candidate.id) ?? 0)
+            : overlap.size > 0
+                ? (1 - ENTITY_RELEVANCE_WEIGHT) * baseRelevance + ENTITY_RELEVANCE_WEIGHT * (overlap.get(candidate.id) ?? 0)
+                : baseRelevance;
+        const metadata = temporal.get(candidate.id);
+        const relevance = metadata
+            ? 0.9 * entityRelevance + 0.1 * temporalRelevance(intent, metadata.timestamp, metadata.supersededFraction, now)
+            : entityRelevance;
         const score = scoreMemoryCandidate({
             semantic: relevance,
-            updated_at: candidate.updated_at,
+            // Historical lookup should not lose evidence merely because it is old.
+            updated_at: intent.kind === "past" ? now.toISOString() : candidate.updated_at,
             importance: candidate.importance,
             access_count: candidate.access_count,
-            decayedImportance: candidate.decayedImportance,
+            decayedImportance: intent.kind === "past" ? candidate.importance : candidate.decayedImportance,
         }, now);
         return {
             id: candidate.id,

package/dist/core/retrieve/signalFusion.js

@@ -0,0 +1,21 @@
+import { lexicalQueryTerms } from "../storage/memorySearchRepo.js";
+export const RETRIEVAL_RANKINGS = ["legacy", "adaptive-bm25", "hub-additive", "adaptive-hub-additive"];
+/** Fixed hypotheses from the requested public-source audit, independently implemented. */
+export function adaptiveLexicalScore(raw, query) {
+    if (raw <= 0 || !Number.isFinite(raw))
+        return 0;
+    const count = lexicalQueryTerms(query).length;
+    const bands = [[3, 5, 0.7], [6, 7, 0.6], [9, 9, 0.5], [15, 10, 0.5], [Infinity, 12, 0.5]];
+    const [, midpoint, steepness] = bands.find(([ceiling]) => count <= ceiling);
+    return 1 / (1 + Math.exp(steepness * (midpoint - raw)));
+}
+export const SEMANTIC_GATE = 0.2;
+export function additiveRelevance(signals) {
+    if (signals.dense !== undefined && signals.dense < SEMANTIC_GATE)
+        return null;
+    const capacity = Number(signals.lexical !== undefined) + Number(signals.dense !== undefined) + 0.5 * Number(signals.entity !== undefined);
+    if (!capacity)
+        return 0;
+    const sum = (signals.lexical ?? 0) + (signals.dense ?? 0) + (signals.entity ?? 0);
+    return Math.max(0, Math.min(1, sum / capacity));
+}