sessionmem 1.3.0 → 1.5.0

package/dist/cli/commands/import.js

@@ -14,7 +14,7 @@ export async function importCommand(pathArg, options, ctx) {
     // Read and parse the JSON file
     let parsed;
     try {
-        const raw = readFileSync(inPath, "utf8");
+        const raw = new TextDecoder("utf-8", { fatal: true }).decode(readFileSync(inPath));
         parsed = JSON.parse(raw);
     }
     catch (err) {
@@ -27,61 +27,32 @@ export async function importCommand(pathArg, options, ctx) {
         console.error("Import file must be a JSON array of memory records.");
         process.exit(1);
     }
-    const records = parsed;
-    let toImport = records;
-    let skippedCount = 0;
-    if (!options.merge) {
-        // By default, skip existing IDs (pre-filter). `id` is a
-        // globally-unique PRIMARY KEY (not scoped by project), so the duplicate
-        // check must consider every project's ids -- otherwise a record whose id
-        // collides with another project's memory would not be pre-filtered here
-        // and could fall through to the service's ON CONFLICT(id) upsert.
-        const existingIds = listAllMemoryIds(context.db);
-        const filtered = records.filter((r) => {
-            const id = typeof r.id === "string" ? r.id : undefined;
-            return id === undefined || !existingIds.has(id);
-        });
-        skippedCount = records.length - filtered.length;
-        toImport = filtered;
-    }
-    if (toImport.length === 0 && skippedCount > 0) {
-        console.log(`Imported 0, skipped ${skippedCount} duplicates.`);
-        return;
-    }
-    // Map to the expected shape, then validate each record before sending to the service
-    const mapped = toImport.map((r) => ({
-        id: r.id,
-        projectId: r.projectId ?? context.projectId,
-        sessionId: r.sessionId,
-        sourceAdapter: r.sourceAdapter,
-        kind: r.kind,
-        content: r.content,
-        importance: r.importance,
-        createdAt: r.createdAt,
-        updatedAt: r.updatedAt,
-    }));
-    // Validate each record but skip-and-warn on individual invalid
-    // records (consistent with the duplicate-skip UX) instead of aborting the
-    // entire import on the first invalid record, which would discard earlier
-    // valid records with no partial import.
+    const existingIds = options.merge ? undefined : listAllMemoryIds(context.db);
     const validMemories = [];
+    let skippedCount = 0;
     let invalidCount = 0;
-    for (let i = 0; i < mapped.length; i++) {
-        const check = importMemoryRecordSchema.safeParse(mapped[i]);
+    for (const [index, record] of parsed.entries()) {
+        const isRecord = record !== null && typeof record === "object" && !Array.isArray(record);
+        if (isRecord && typeof record.id === "string" && existingIds?.has(record.id)) {
+            skippedCount += 1;
+            continue;
+        }
+        // Validate unknown values before accessing fields. Keep the source index in
+        // diagnostics even when earlier records were duplicates, and preserve the
+        // optional provenance fields carried by exports.
+        const check = importMemoryRecordSchema.safeParse(isRecord ? { ...record, projectId: record.projectId ?? context.projectId } : record);
         if (!check.success) {
-            console.error(`Record at index ${i} is invalid, skipping: ${check.error.message}`);
+            console.error(`Record at index ${index} is invalid, skipping: ${check.error.message}`);
             invalidCount += 1;
             continue;
         }
-        // Use the parsed/transformed record so `kind` is narrowed to the
-        // canonical enum (memoryKindSchema maps legacy values like `architecture`).
         validMemories.push(check.data);
     }
     if (validMemories.length === 0) {
         if (invalidCount > 0) {
             console.log(`Imported 0, skipped ${invalidCount} invalid record(s).`);
         }
-        else if (skippedCount > 0) {
+        else {
             console.log(`Imported 0, skipped ${skippedCount} duplicates.`);
         }
         return;

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 } 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 { createCliContext, resolveDbPath } from "../context.js";
 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,10 +34,12 @@ 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 (~/.sessionmem/memories.db): ${err instanceof Error ? err.message : String(err)}`);
-        console.error("Hint: ensure ~/.sessionmem directory is writable and run `sessionmem install` again.");
+        console.error(`✗ DB init failed (${resolveDbPath(contextOverrides?.dbPath)}): ${err instanceof Error ? err.message : String(err)}`);
+        console.error("Hint: ensure the database parent directory is writable and run `sessionmem install` again.");
         process.exit(1);
     }
     console.log(`✓ DB initialized (${dbPath})`);
@@ -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/list.js

@@ -10,4 +10,7 @@ export async function listCommand(ctx) {
         process.exit(1);
     }
     console.log(formatTable(result.memories));
+    if (result.total > result.memories.length) {
+        console.error(`Showing ${result.memories.length} of ${result.total} memories. Use \`sessionmem export\` for the full project.`);
+    }
 }

package/dist/cli/commands/run.js

@@ -1,19 +1,15 @@
 import { AdapterFactory } from "../../adapters/factory.js";
 import { mkdirSync, writeFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+import { join, dirname } from "path";
 import { deriveProjectId } from "../projectId.js";
-import { expandTilde } from "../context.js";
+import { resolveDbPath } from "../context.js";
 export async function runMcpServer() {
     const adapter = AdapterFactory.detectAdapter();
-    // Startup diagnostics: written to ~/.sessionmem/logs/mcp.log
-    const logDir = join(homedir(), ".sessionmem", "logs");
+    // Keep diagnostics beside the selected database so an override never
+    // creates the default home directory just to write a log.
+    const dbPath = resolveDbPath();
+    const logDir = join(dirname(dbPath), "logs");
     const logPath = join(logDir, "mcp.log");
-    // Derive db path for diagnostics (mirrors context.ts defaultDbPath)
-    const envDbPath = process.env.SESSIONMEM_DB_PATH;
-    const dbPath = envDbPath && envDbPath.trim() !== ""
-        ? expandTilde(envDbPath)
-        : join(homedir(), ".sessionmem", "memories.db");
     // Derive project ID for diagnostics. Shares the exact derivation the server
     // uses (createCliContext → deriveProjectId) so the logged id never diverges
     // from the bucket the server actually serves.
@@ -21,8 +17,10 @@ export async function runMcpServer() {
     const adapterName = adapter.name;
     const logMessage = `[${new Date().toISOString()}] Started sessionmem | adapter=${adapterName} db=${dbPath} project=${projectId}\n`;
     try {
-        mkdirSync(logDir, { recursive: true });
-        writeFileSync(logPath, logMessage, { flag: "a" });
+        if (dbPath !== ":memory:") {
+            mkdirSync(logDir, { recursive: true });
+            writeFileSync(logPath, logMessage, { flag: "a" });
+        }
     }
     catch {
         // best-effort logging; ignore failures

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

@@ -1,20 +1,25 @@
 import { createCliContext } from "../context.js";
 import { formatTable } from "../output.js";
-const DEFAULT_LIMIT = 20;
+const DEFAULT_LIMIT = 10;
 function coerceLimit(value) {
     if (value === undefined)
         return DEFAULT_LIMIT;
-    const parsed = Number.parseInt(String(value), 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_LIMIT;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 100) {
+        throw new Error(`Invalid --limit "${value}": expected an integer from 1 to 100.`);
+    }
+    return parsed;
 }
 export async function searchCommand(query, options = {}, ctx) {
+    const limit = coerceLimit(options.limit);
     const context = ctx ?? createCliContext();
     const result = await context.service.call("retrieveMemories", {
         projectId: context.projectId,
         query,
-        limit: coerceLimit(options.limit),
+        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"}.`);
 }

package/dist/cli/commands/ui.js

@@ -0,0 +1,67 @@
+import BetterSqlite3 from "better-sqlite3";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { createMemoryCoreService } from "../../core/api/memoryCoreService.js";
+import { deriveProjectId } from "../projectId.js";
+import { resolveDbPath } from "../context.js";
+import { inspectMigrations } from "../../core/schema/runMigrations.js";
+import { parseUiPort, startUiServer } from "../../ui/server.js";
+/** Open the OS browser without a shell or an additional runtime dependency. */
+export function openBrowser(url) {
+    const command = process.platform === "win32" ? "rundll32.exe" : process.platform === "darwin" ? "open" : "xdg-open";
+    const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
+    const child = spawn(command, args, { stdio: "ignore", detached: true, windowsHide: true });
+    const failed = () => console.error("Could not open a browser. Open the printed URL manually.");
+    child.once("error", failed);
+    child.once("exit", code => { if (code)
+        failed(); });
+    child.unref();
+}
+export async function uiCommand(options = {}) {
+    const port = parseUiPort(options.port);
+    // Unlike the normal CLI context, a viewer must not create, migrate or write the store.
+    let db;
+    try {
+        db = new BetterSqlite3(resolveDbPath(), { readonly: true, fileMustExist: true });
+    }
+    catch {
+        throw new Error("Cannot open the memory store. Run sessionmem ping first, or check SESSIONMEM_DB_PATH.");
+    }
+    try {
+        db.pragma("query_only = ON");
+        db.pragma("busy_timeout = 5000");
+        const migrations = inspectMigrations(db);
+        if (migrations.unknown.length) {
+            throw new Error("The memory store uses an unrecognized schema. Use the sessionmem version that created it.");
+        }
+        if (migrations.pending.length) {
+            throw new Error("The memory store needs an upgrade. Run sessionmem ping first to apply pending migrations.");
+        }
+        const viewer = await startUiServer({ db, service: createMemoryCoreService({ db }), projectId: deriveProjectId() }, port);
+        let stopping = false;
+        const stop = () => {
+            if (stopping)
+                return;
+            stopping = true;
+            void viewer.close().catch(error => {
+                console.error(error instanceof Error ? error.message : String(error));
+                process.exitCode = 1;
+            });
+        };
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+        try {
+            const closed = once(viewer.server, "close");
+            console.log(`sessionmem viewer: ${viewer.url}\nRead-only. Press Ctrl-C to stop.`);
+            openBrowser(viewer.url);
+            await closed;
+        }
+        finally {
+            process.removeListener("SIGINT", stop);
+            process.removeListener("SIGTERM", stop);
+        }
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/cli/commands/uninstall.js

@@ -1,6 +1,7 @@
 import { existsSync, rmSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+import { resolveDbPath } from "../context.js";
 import { AdapterFactory } from "../../adapters/factory.js";
 import { removeClaudeMdBlock } from "../../adapters/claudeMdInjector.js";
 /**
@@ -51,7 +52,7 @@ export async function uninstallCommand(options = {}) {
         }
     }
     // Resolve dbPath: use injected override (for tests) or the default location
-    const dbPath = options.dbPath ?? join(homedir(), ".sessionmem", "memories.db");
+    const dbPath = resolveDbPath(options.dbPath);
     if (options.purge) {
         // --purge: delete only memories.db, not logs or the ~/.sessionmem directory
         if (existsSync(dbPath)) {

package/dist/cli/commands/watch.js

@@ -0,0 +1,48 @@
+import { setTimeout } from "node:timers/promises";
+import { createCliContext } from "../context.js";
+import { printSweepSummary, sweepTranscripts } from "../transcriptSweep.js";
+export async function watchCommand(options = {}, ctx) {
+    const interval = Number(options.interval ?? 5);
+    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 controller = new AbortController();
+    const stop = () => controller.abort();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    let firstSweep = true;
+    try {
+        do {
+            try {
+                const summary = await sweepTranscripts(context, options);
+                if (firstSweep || options.once || summary.sessionsImported || summary.errors) {
+                    printSweepSummary("watch", summary);
+                }
+                firstSweep = false;
+                if (options.once && summary.errors)
+                    process.exitCode = 1;
+            }
+            catch (error) {
+                if (options.once)
+                    throw error;
+                console.error(`[sessionmem] watch: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (options.once || controller.signal.aborted)
+                break;
+            try {
+                await setTimeout(interval * 1000, undefined, { signal: controller.signal });
+            }
+            catch (error) {
+                if (!controller.signal.aborted)
+                    throw error;
+            }
+        } while (!controller.signal.aborted);
+    }
+    finally {
+        process.removeListener("SIGINT", stop);
+        process.removeListener("SIGTERM", stop);
+        if (!ctx)
+            context.db.close();
+    }
+}

package/dist/cli/context.js

@@ -42,19 +42,21 @@ export function expandTilde(p) {
     }
     return p;
 }
-function defaultDbPath(dir) {
+export function resolveDbPath(override) {
+    if (override !== undefined)
+        return expandTilde(override);
     // Env override seam (see deriveProjectId). Defaults to ~/.sessionmem/memories.db.
     const envDbPath = process.env.SESSIONMEM_DB_PATH;
     if (envDbPath && envDbPath.trim() !== "")
         return expandTilde(envDbPath);
-    // `dir` is the fixed ~/.sessionmem dir computed above, not user input.
     // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal
-    return join(dir, "memories.db");
+    return join(homedir(), ".sessionmem", "memories.db");
 }
 export function createCliContext(overrides = {}) {
-    const dir = join(homedir(), ".sessionmem");
-    mkdirSync(dir, { recursive: true });
-    const dbPath = overrides.dbPath ?? defaultDbPath(dir);
+    const dbPath = resolveDbPath(overrides.dbPath);
+    if (!overrides.db && dbPath !== ":memory:") {
+        mkdirSync(dirname(dbPath), { recursive: true });
+    }
     const here = dirname(fileURLToPath(import.meta.url));
     const migrationsDir = overrides.migrationsDir ?? join(here, "..", "core", "schema", "migrations");
     const username = overrides.username ?? localUsername();