sessionmem 1.4.0 → 1.5.0

package/dist/adapters/ide/cursor.js

@@ -21,6 +21,9 @@ export class CursorAdapter extends GenericMCPAdapter {
     get configPath() {
         return join(homedir(), ".cursor", "mcp.json");
     }
+    installation() {
+        return { mcp: { path: this.configPath, command: "sessionmem", args: ["run"] } };
+    }
     async install() {
         return IDEInstaller.injectMcpConfig(this.configPath, "sessionmem", "sessionmem", ["run"]);
     }

package/dist/adapters/ide/installer.js

@@ -35,6 +35,15 @@ export const SESSIONMEM_POST_TOOL_HOOK_COMMAND = _isWindows
 export const SESSIONMEM_POST_TOOL_MATCHER = "Bash|Edit|Write|MultiEdit";
 /** Default Claude Code hook event for the legacy 2-arg hook helpers. */
 const DEFAULT_HOOK_EVENT = "SessionStart";
+/** Recognize our bare/Windows hook forms, including stale command arguments. */
+export function isManagedClaudeHook(value, expected) {
+    if (typeof value !== "string")
+        return false;
+    const normalize = (command) => command.replace(/^cmd \/c /i, "");
+    const base = normalize(expected);
+    const candidate = normalize(value);
+    return candidate === base || candidate.startsWith(`${base} `);
+}
 export class IDEInstaller {
     static parseJsonc(content) {
         // Strip single-line comments (//) that appear outside of string literals.
@@ -201,11 +210,14 @@ export class IDEInstaller {
         const eventEntries = Array.isArray(hooks[eventName])
             ? hooks[eventName]
             : [];
-        // Drop any pre-existing sessionmem entry so re-install stays idempotent and
-        // a stale command form is replaced rather than duplicated. hookEntryHasCommand
-        // only inspects entry.hooks, so it dedupes correctly whether or not the entry
-        // carries a matcher.
-        const filtered = eventEntries.filter((entry) => !this.hookEntryHasCommand(entry, command));
+        // Replace our commands, including stale forms, while preserving user hooks
+        // that share an entry. The fresh entry restores the current matcher/type.
+        const filtered = eventEntries.flatMap((entry) => {
+            if (!entry || !Array.isArray(entry.hooks))
+                return [entry];
+            const remaining = entry.hooks.filter((hook) => !isManagedClaudeHook(hook?.command, command));
+            return remaining.length ? [{ ...entry, hooks: remaining }] : [];
+        });
         filtered.push(matcher !== undefined
             ? { matcher, hooks: [{ type: "command", command }] }
             : { hooks: [{ type: "command", command }] });

package/dist/adapters/ide/windsurf.js

@@ -20,6 +20,9 @@ export class WindsurfAdapter extends GenericMCPAdapter {
     get configPath() {
         return join(homedir(), ".codeium", "windsurf", "mcp_config.json");
     }
+    installation() {
+        return { mcp: { path: this.configPath, command: "sessionmem", args: ["run"] } };
+    }
     async install() {
         return IDEInstaller.injectMcpConfig(this.configPath, "sessionmem", "sessionmem", ["run"]);
     }

package/dist/adapters/installedHosts.js

@@ -0,0 +1,51 @@
+import { accessSync, constants, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+import { AdapterFactory } from "./factory.js";
+// Installed-host detection is deliberately separate from runtime session-env
+// detection. Add a row here when another host has a verified install probe.
+export const INSTALLED_HOSTS = [
+    {
+        adapter: "claude-code",
+        executables: ["claude"],
+        homeExecutables: [".local/bin/claude", ".claude/local/claude"],
+    },
+];
+export function isExecutable(file) {
+    try {
+        if (!statSync(file).isFile())
+            return false;
+        accessSync(file, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function executableCandidates(file) {
+    if (process.platform !== "win32")
+        return [file];
+    const extensions = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";");
+    return [file, ...extensions.filter(Boolean).map((ext) => file + ext.toLowerCase())];
+}
+export function detectInstalledAdapters(table = INSTALLED_HOSTS) {
+    const pathDirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+    return table.filter((host) => {
+        const paths = [
+            ...host.executables.flatMap((name) => pathDirs.map((dir) => join(dir.replace(/^"|"$/g, ""), name))),
+            ...(host.homeExecutables ?? []).map((file) => join(homedir(), file)),
+        ];
+        return paths.some((file) => executableCandidates(file).some(isExecutable));
+    }).map((host) => AdapterFactory.forName(host.adapter));
+}
+/** Explicit flags take precedence over the existing environment override. */
+export function resolveInstallAdapters(options) {
+    const explicit = options?.adapter?.trim() || process.env.SESSIONMEM_ADAPTER?.trim();
+    if (explicit)
+        return { adapters: [AdapterFactory.forName(explicit)], forced: true };
+    const adapters = detectInstalledAdapters();
+    if (adapters.length === 0) {
+        throw new Error("No supported agent host found. Install Claude Code or use sessionmem install --adapter <name>.");
+    }
+    return { adapters, forced: false };
+}

package/dist/cli/commands/doctor.js

@@ -0,0 +1,146 @@
+import BetterSqlite3 from "better-sqlite3";
+import { randomUUID } from "node:crypto";
+import { createRequire } from "node:module";
+import { resolveInstallAdapters } from "../../adapters/installedHosts.js";
+import { checkHooks, readMcpLaunch, probeMcpWiring } from "../../adapters/diagnostics.js";
+import { ADAPTER_NAMES, AdapterFactory } from "../../adapters/factory.js";
+import { createMemoryCoreService } from "../../core/api/memoryCoreService.js";
+import { inspectMigrations } from "../../core/schema/runMigrations.js";
+import { resolveDbPath } from "../context.js";
+const VERSION = createRequire(import.meta.url)("../../../package.json").version;
+/** Exercise real storage, embedding, ranking and injection without retaining data. */
+export async function probeRecall(db) {
+    const id = `sessionmem-doctor-${randomUUID()}`;
+    const content = "Sessionmem doctor canary checks local memory recall.";
+    const service = createMemoryCoreService({ db });
+    // A separate project prevents both ranking collisions and access-count changes
+    // to user memories. Rollback also removes FTS entries and feedback on failure.
+    db.exec("BEGIN IMMEDIATE");
+    try {
+        const stored = await service.call("storeMemory", {
+            projectId: id, sessionId: id, memoryId: id, sourceAdapter: "doctor",
+            kind: "fact", content, importance: 5,
+        });
+        if (!stored.ok)
+            throw new Error(`Canary write failed: ${stored.error.message}`);
+        const recalled = await service.call("retrieveMemories", {
+            projectId: id, query: content, limit: 5, mode: "auto", depth: "default",
+        });
+        if (!recalled.ok)
+            throw new Error(`Canary recall failed: ${recalled.error.message}`);
+        if (!recalled.memories.some((memory) => memory.id === id && memory.content === content)) {
+            throw new Error("Recall did not return the canary memory");
+        }
+    }
+    finally {
+        db.exec("ROLLBACK");
+    }
+}
+export async function doctorCommand(options, overrides = {}) {
+    const results = [];
+    const report = (check, ok, detail, fix) => {
+        results.push({ check, ok, detail, ...(fix ? { fix } : {}) });
+        console.log(`${ok ? "PASS" : "FAIL"} ${check}: ${detail}`);
+        if (fix)
+            console.log(`  Fix: ${fix}`);
+    };
+    const message = (err) => err instanceof Error ? err.message : String(err);
+    let adapters = [];
+    try {
+        adapters = resolveInstallAdapters(options).adapters;
+    }
+    catch (err) {
+        report("Agent hosts", false, message(err), "Install a supported host or select one with sessionmem doctor --adapter <name>");
+    }
+    const dbPath = resolveDbPath(overrides.dbPath);
+    let db;
+    let schemaOk = false;
+    try {
+        try {
+            if (dbPath === ":memory:")
+                throw new Error("No persistent memory store selected (:memory:)");
+            // fileMustExist prevents doctor from hiding a missing store; migrations
+            // are inspected separately and are never applied during diagnosis.
+            db = new BetterSqlite3(dbPath, { fileMustExist: true, timeout: 5000 });
+            const status = db.pragma("quick_check", { simple: true });
+            if (status !== "ok")
+                throw new Error(`SQLite quick_check: ${String(status)}`);
+            db.pragma("foreign_keys = ON");
+            report("Memory store", true, `Exists and opens (${dbPath})`);
+        }
+        catch (err) {
+            db?.close();
+            db = undefined;
+            report("Memory store", false, message(err), "Check the selected database path and directory permissions; initialize a missing store with sessionmem ping");
+        }
+        if (db) {
+            try {
+                const schema = inspectMigrations(db, overrides.migrationsDir);
+                if (schema.unknown.length) {
+                    report("Schema", false, `Unrecognized migrations: ${schema.unknown.join(", ")}`, "Use the sessionmem version that created this database; do not downgrade its schema");
+                }
+                else if (schema.pending.length) {
+                    report("Schema", false, `Pending migrations: ${schema.pending.join(", ")}`, "sessionmem ping");
+                }
+                else {
+                    schemaOk = true;
+                    report("Schema", true, "All bundled migrations are applied");
+                }
+            }
+            catch (err) {
+                report("Schema", false, message(err), "Check the database and bundled schema migrations; sessionmem ping applies pending migrations");
+            }
+        }
+        else {
+            report("Schema", false, "Cannot inspect an unavailable store", "sessionmem ping");
+        }
+        for (const adapter of adapters) {
+            const name = ADAPTER_NAMES.find((name) => AdapterFactory.forName(name).name === adapter.name);
+            const installFix = name ? `sessionmem install --adapter ${name}` : "sessionmem install";
+            const installation = adapter.installation?.();
+            if (!installation) {
+                report(`${adapter.name} hooks`, false, "Adapter has no installation diagnostics", installFix);
+                report(`${adapter.name} adapter wiring`, false, "Adapter has no installation diagnostics", installFix);
+                continue;
+            }
+            try {
+                report(`${adapter.name} hooks`, true, `${checkHooks(installation)}; sessionmem ${VERSION}`);
+            }
+            catch (err) {
+                report(`${adapter.name} hooks`, false, message(err), `Enable hooks in the host settings if disabled, then run ${installFix}`);
+            }
+            try {
+                const launch = readMcpLaunch(installation);
+                if (!schemaOk)
+                    throw new Error("MCP launch probe blocked until the store and schema checks pass");
+                await probeMcpWiring(launch, dbPath, VERSION);
+                report(`${adapter.name} adapter wiring`, true, "Configured MCP command starts, matches this version, and answers stats");
+            }
+            catch (err) {
+                report(`${adapter.name} adapter wiring`, false, message(err), `Ensure sessionmem is on PATH, then run ${installFix}`);
+            }
+        }
+        if (!adapters.length) {
+            report("Hook configuration", false, "No host selected", "sessionmem doctor --adapter <name>");
+            report("Adapter wiring", false, "No host selected", "sessionmem doctor --adapter <name>");
+        }
+        if (db && schemaOk) {
+            try {
+                await probeRecall(db);
+                report("Recall canary", true, "Write and recall succeeded; canary rolled back");
+            }
+            catch (err) {
+                report("Recall canary", false, message(err), "Check database write permissions and errors; run sessionmem doctor again after repair");
+            }
+        }
+        else {
+            report("Recall canary", false, "Blocked until the store and schema checks pass", "sessionmem ping");
+        }
+    }
+    finally {
+        db?.close();
+    }
+    if (results.some((result) => !result.ok))
+        process.exitCode = 1;
+    return results;
+}

package/dist/cli/commands/entities.js

@@ -0,0 +1,27 @@
+import { listProjectKnowledge } from "../../core/storage/knowledgeRepo.js";
+import { createCliContext } from "../context.js";
+export function entitiesCommand(options = {}, ctx) {
+    const context = ctx ?? createCliContext();
+    try {
+        const projectId = options.project ?? context.projectId;
+        const knowledge = listProjectKnowledge(context.db, projectId);
+        if (options.json) {
+            console.log(JSON.stringify({ projectId, ...knowledge }, null, 2));
+            return;
+        }
+        console.log(`Entities for ${projectId}:`);
+        for (const entity of knowledge.entities) {
+            console.log(`  [${entity.kind}] ${entity.name} (memories: ${entity.memoryIds.join(", ")})`);
+        }
+        console.log("Relations:");
+        for (const edge of knowledge.relations) {
+            console.log(`  [${edge.sourceKind}] ${edge.sourceName} --${edge.relation}--> [${edge.targetKind}] ${edge.targetName} (memories: ${edge.memoryIds.join(", ")})`);
+        }
+        if (!knowledge.entities.length)
+            console.log("  No entities captured.");
+    }
+    finally {
+        if (!ctx)
+            context.db.close();
+    }
+}

package/dist/cli/commands/history.js

@@ -0,0 +1,23 @@
+import { listSupersessions } from "../../core/storage/supersessionRepo.js";
+import { createCliContext } from "../context.js";
+export function historyCommand(options = {}, ctx) {
+    const context = ctx ?? createCliContext();
+    try {
+        const projectId = options.project ?? context.projectId;
+        const links = listSupersessions(context.db, projectId);
+        if (options.json) {
+            console.log(JSON.stringify({ projectId, links }, null, 2));
+            return;
+        }
+        console.log(`Supersession links for ${projectId}:`);
+        for (const link of links) {
+            console.log(`  ${link.supersedes} -> ${link.supersededBy} at ${link.supersededAt} (${link.entity} ${link.relation}: ${link.oldValue} -> ${link.newValue}; ${link.reason}; ${link.fullySuperseded ? "superseded" : "partially superseded"})`);
+        }
+        if (!links.length)
+            console.log("  No supersessions captured.");
+    }
+    finally {
+        if (!ctx)
+            context.db.close();
+    }
+}

package/dist/cli/commands/ingestHook.js

@@ -1,26 +1,12 @@
 import { createCliContext } from "../context.js";
 import { randomUUID } from "node:crypto";
-// High-signal tool types that we capture as session events.
-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;
+import { buildToolEvent } from "../../core/capture/toolEvent.js";
 /** 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 {};
@@ -56,65 +42,6 @@ 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
@@ -126,14 +53,14 @@ export async function ingestHookCommand(ctx) {
     try {
         const payload = await readStdinJson();
         const toolName = payload.tool_name ?? "";
-        if (!CAPTURED_TOOL_TYPES.has(toolName)) {
+        const event = buildToolEvent(toolName, payload.tool_input, payload.cwd);
+        if (!event) {
             debug(`skipped: tool "${toolName}" is not captured`);
             return;
         }
         context = ctx ?? createCliContext();
         const sessionId = resolveSessionId(payload);
         const projectId = context.projectId;
-        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).
@@ -142,8 +69,7 @@ export async function ingestHookCommand(ctx) {
             sessionId,
             events: [{
                     id: randomUUID(),
-                    eventType: `tool_use:${toolName.toLowerCase()}`,
-                    payloadJson: buildPayloadJson(toolName, text, payload.tool_input, payload.cwd),
+                    ...event,
                 }],
         });
         if (!result.ok) {

package/dist/cli/commands/install.js

@@ -1,26 +1,9 @@
 import { existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-import { AdapterFactory } from "../../adapters/factory.js";
+import { resolveInstallAdapters } from "../../adapters/installedHosts.js";
 import { injectGuidanceBlock } from "../../adapters/claudeMdInjector.js";
 import { createCliContext, resolveDbPath } from "../context.js";
-/**
- * Resolve the adapter to install into: an explicit `--adapter` flag wins, then
- * the SESSIONMEM_ADAPTER env override, else auto-detection from the host env.
- * Throws (via AdapterFactory.forName) on an unknown explicit name so the CLI
- * surfaces a clear error rather than silently installing the generic adapter.
- */
-function resolveAdapter(options) {
-    const explicit = options?.adapter && options.adapter.trim() !== ""
-        ? options.adapter.trim()
-        : process.env.SESSIONMEM_ADAPTER && process.env.SESSIONMEM_ADAPTER.trim() !== ""
-            ? process.env.SESSIONMEM_ADAPTER.trim()
-            : undefined;
-    if (explicit) {
-        return { adapter: AdapterFactory.forName(explicit), forced: true };
-    }
-    return { adapter: AdapterFactory.detectAdapter(), forced: false };
-}
 import { configFilePath, writePolicyConfig, DEFAULT_POLICY_CONFIG, } from "../../core/config/policyConfig.js";
 export const MANUAL_CONFIG_BLOCK = JSON.stringify({
     mcpServers: {
@@ -37,10 +20,10 @@ export function printManualFallback(adapterName) {
 export async function installCommand(options, contextOverrides) {
     // Resolve the target adapter up front so an invalid `--adapter` fails before
     // any filesystem work (DB init, config write).
-    let adapter;
+    let adapters;
     let forced;
     try {
-        ({ adapter, forced } = resolveAdapter(options));
+        ({ adapters, forced } = resolveInstallAdapters(options));
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));
@@ -51,6 +34,8 @@ export async function installCommand(options, contextOverrides) {
     try {
         const ctx = createCliContext(contextOverrides);
         dbPath = ctx.dbPath;
+        if (!contextOverrides?.db)
+            ctx.db.close();
     }
     catch (err) {
         console.error(`✗ DB init failed (${resolveDbPath(contextOverrides?.dbPath)}): ${err instanceof Error ? err.message : String(err)}`);
@@ -69,47 +54,40 @@ export async function installCommand(options, contextOverrides) {
         writePolicyConfig(configPath, { ...DEFAULT_POLICY_CONFIG });
         console.log(`✓ config.json initialized (${configPath})`);
     }
-    // Step 2: Adapter config — install into the resolved adapter. Print which
-    // adapter was selected and how, so the user can see whether auto-detection
-    // picked the host they expected (and re-run with `--adapter` if not).
-    console.log(forced
-        ? `→ Installing for adapter: ${adapter.name} (forced)`
-        : `→ Detected host: ${adapter.name} (override with --adapter <name>)`);
-    if (!adapter.install) {
-        console.error(`✗ ${adapter.name} config update failed`);
-        printManualFallback(adapter.name);
-        process.exit(1);
-    }
-    const success = await adapter.install();
-    if (!success) {
-        console.error(`✗ ${adapter.name} config update failed`);
-        printManualFallback(adapter.name);
-        process.exit(1);
-    }
-    console.log(`✓ ${adapter.name} config updated`);
-    // Step 3: Guidance injection — non-fatal. Inject the sessionmem instruction
-    // block into the file(s) the detected host actually reads at session start so
-    // the agent automatically knows the MCP exists and how to use it. Adapters
-    // declare their own target(s); when none are declared (e.g. a minimal mock or
-    // an unknown host) fall back to the global Claude Code memory file.
-    const guidanceTargets = adapter.guidanceTargets?.() ?? [join(homedir(), ".claude", "CLAUDE.md")];
-    for (const target of guidanceTargets) {
+    // Try every detected host even when one host's config cannot be updated.
+    let failed = false;
+    for (const adapter of adapters) {
+        console.log(forced
+            ? `→ Installing for adapter: ${adapter.name} (forced)`
+            : `→ Detected host: ${adapter.name} (override with --adapter <name>)`);
         try {
-            const injected = injectGuidanceBlock(target);
-            if (injected) {
-                console.log(`✓ Agent guidance injected (${target})`);
+            if (!adapter.install || !(await adapter.install())) {
+                throw new Error("config update failed");
             }
-            else {
-                console.error(`✗ Agent guidance injection failed (non-fatal): ${target}`);
+            console.log(`✓ ${adapter.name} config updated`);
+        }
+        catch (err) {
+            console.error(`✗ ${adapter.name} config update failed: ${err instanceof Error ? err.message : String(err)}`);
+            printManualFallback(adapter.name);
+            failed = true;
+            continue;
+        }
+        const guidanceTargets = adapter.guidanceTargets?.() ?? [join(homedir(), ".claude", "CLAUDE.md")];
+        for (const target of guidanceTargets) {
+            try {
+                if (!injectGuidanceBlock(target))
+                    throw new Error("injection failed");
+                console.log(`✓ ${adapter.name}: Agent guidance injected (${target})`);
+            }
+            catch {
+                console.error(`✗ ${adapter.name}: Agent guidance injection failed (non-fatal): ${target}`);
             }
         }
-        catch {
-            console.error(`✗ Agent guidance injection failed (non-fatal): ${target}`);
+        if (adapter.name === "Claude Code") {
+            console.log("✓ Claude Code: SessionStart, SessionEnd, PostToolUse hooks configured (~/.claude/settings.json)");
         }
     }
-    // Step 4: Full success checklist
-    if (adapter.name === "Claude Code") {
-        console.log("✓ Auto-injection hook installed (~/.claude/settings.json) — prior memories load automatically at the start of every Claude Code session");
-    }
+    if (failed)
+        process.exit(1);
     console.log("✓ sessionmem ready — restart your editor/agent so it picks up the MCP server");
 }

package/dist/cli/commands/scan.js

@@ -0,0 +1,16 @@
+import { createCliContext } from "../context.js";
+import { printSweepSummary, sweepTranscripts } from "../transcriptSweep.js";
+export async function scanCommand(options = {}, ctx) {
+    const context = ctx ?? createCliContext();
+    try {
+        const summary = await sweepTranscripts(context, options);
+        printSweepSummary("scan", summary);
+        if (summary.errors)
+            process.exitCode = 1;
+        return summary;
+    }
+    finally {
+        if (!ctx)
+            context.db.close();
+    }
+}

package/dist/cli/commands/search.js

@@ -19,6 +19,7 @@ export async function searchCommand(query, options = {}, ctx) {
         limit,
         mode: "auto",
         depth: "default",
+        includeHistory: options.includeHistory,
     });
     if (!result.ok) {
         console.error(result.error.message);

package/dist/cli/commands/team.js

@@ -3,6 +3,7 @@ import { join } from "path";
 import { randomUUID } from "crypto";
 import { configFilePath, readPolicyConfig, writePolicyConfig, } from "../../core/config/policyConfig.js";
 import { createCliContext } from "../context.js";
+import { reconcileProjectSupersessions } from "../../core/storage/supersessionRepo.js";
 function resolvePath(options) {
     return options?.configPath ?? configFilePath();
 }
@@ -89,8 +90,11 @@ export function teamDisableCommand(options, ctx) {
         return;
     }
     const context = ctx ?? createCliContext();
-    const result = context.db
-        .prepare("DELETE FROM memories WHERE project_id = ? AND author != ? AND author != ''")
-        .run(context.projectId, context.username);
+    const result = context.db.transaction(() => {
+        const removed = context.db.prepare("DELETE FROM memories WHERE project_id = ? AND author != ? AND author != ''").run(context.projectId, context.username);
+        if (removed.changes)
+            reconcileProjectSupersessions(context.db, context.projectId);
+        return removed;
+    })();
     console.log(`Team mode disabled. Removed ${result.changes} teammate-authored ${result.changes === 1 ? "memory" : "memories"}.`);
 }