sessionmem 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [1.7.0] - 2026-10-18
+
+### Added
+
+- Automatic transcript capture at login: per-user login services on macOS,
+  Linux, and Windows keep `sessionmem watch` running after install, so new
+  sessions are captured without a manual command. ([#54])
+- Optional local MiniLM retrieval complements FTS5 with learned semantic
+  candidates. Installed model files are verified locally; unavailable inference
+  falls back to BM25. The feature defaults off. See [setup](docs/local-semantic.md).
+  ([#55])
+- Pinned competitor source reviews, local raw-turn LoCoMo comparisons, complete
+  result archives, and per-question retrieval regressions. Measured on LoCoMo:
+  hit rate 63.92% to 66.47%, precision 14.05% to 14.77%, recall 57.45% to
+  59.76%. See [measured comparison](COMPARISON.md). ([#55])
+
 ## [1.6.0] - 2026-10-18
 
 ### Added
@@ -121,7 +139,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   errors and findings fail the job; added scanner dependency updates and
   Dependabot cooldowns. ([#32])
 
+[1.7.0]: https://github.com/catfish-1234/sessionmem/compare/v1.6.0...v1.7.0
 [1.6.0]: https://github.com/catfish-1234/sessionmem/compare/v1.5.0...v1.6.0
+[#54]: https://github.com/catfish-1234/sessionmem/pull/54
+[#55]: https://github.com/catfish-1234/sessionmem/pull/55
 [1.5.0]: https://github.com/catfish-1234/sessionmem/compare/679b8954f0b49f197985c40da47f181c00060cd9...v1.5.0
 [#43]: https://github.com/catfish-1234/sessionmem/pull/43
 [#44]: https://github.com/catfish-1234/sessionmem/pull/44

package/README.md

@@ -29,6 +29,12 @@ WITH sessionmem:
 
 `sessionmem` is an MCP server that stores decisions, warnings, and project context across sessions. Claude Code hooks capture supported tool events and load relevant memories automatically. Other hosts use its MCP tools and installed instructions; session automation depends on the host. It works with Claude Code, Cursor, Cline, Codex, Windsurf, and other [MCP](https://modelcontextprotocol.io) hosts.
 
+Default retrieval uses SQLite FTS5 BM25 and entity overlap. An optional
+[local MiniLM model](docs/local-semantic.md) adds semantic candidates. Weights are
+installed separately; queries make no network calls and fall back to BM25 when
+local inference is unavailable. See [measured comparisons](COMPARISON.md) for
+quality gains, missed questions, and latency costs.
+
 By default, everything stays on your machine. You don't need an account or a cloud service. Data only leaves your computer if you enable sharing or cloud summarization.
 
 ---
@@ -62,12 +68,25 @@ Claude Code on `PATH` or in its standard native install locations. Use
 If no supported host is found, the command says so and exits nonzero before
 creating files. Discovery and configuration work fully offline.
 
-This initializes the database and, for each selected adapter:
+This initializes the database and configures the selected adapters:
 
 - Registers `sessionmem` with your AI tool's MCP host so the host can start it automatically.
 - Creates `~/.sessionmem/config.json` with secret redaction enabled and a 90-day retention window, if the file doesn't already exist.
 - Adds instructions to the selected host's guidance file, such as `~/.claude/CLAUDE.md` for Claude Code or `~/.codex/AGENTS.md` for Codex. You can re-run the command without duplicating those instructions.
 - Installs Claude Code's SessionStart, SessionEnd, and PostToolUse hooks and prints what was configured per host. If a host fails, the remaining hosts are still attempted and the command exits nonzero.
+- Enables and starts one per-user login service for `sessionmem watch`. Re-running install updates that registration in place and restarts capture. Capture continues after closing the terminal and starts again at login.
+
+Login capture uses a LaunchAgent in `~/Library/LaunchAgents` on macOS, a
+`systemd --user` service on Linux, and a Scheduled Task with a user logon trigger
+on Windows. Linux requires systemd and an available user service manager; macOS
+requires a GUI login session. If registration or startup fails, install exits
+nonzero, preserves completed setup, and prints a repair hint. After fixing the
+OS service error, run `sessionmem autostart enable`.
+
+The watcher captures existing and updated Claude Code, Codex CLI, and Cursor
+history offline, without API keys. It starts immediately after install; no
+manual scan or watch process is required. Hosts outside these three can use MCP
+memory tools, but do not have a transcript reader.
 
 ### 3. Restart your AI tool
 
@@ -80,7 +99,8 @@ another format or location, copy its server entry into that host’s MCP config.
 After restarting:
 
 - In Claude Code, the installed PostToolUse, SessionEnd, and SessionStart hooks capture supported tool events, summarize them, and load prior memories automatically.
-- Other MCP hosts use sessionmem's tools and installed instructions. Automatic capture and session lifecycle calls depend on the host or agent. MCP registration alone does not install Claude Code hooks there.
+- Codex and Cursor use the auto-started watcher for transcript capture. Install does not wire lifecycle capture hooks for these hosts. Their MCP tools and installed instructions provide recall and explicit memory operations.
+- Other MCP hosts use sessionmem's tools and installed instructions; automatic transcript capture requires a supported transcript reader.
 
 Check the installation offline:
 
@@ -209,9 +229,10 @@ See [`docs/architecture.md`](docs/architecture.md) for the technical overview.
 
 | Command | What it does |
 |---------|--------------|
-| `sessionmem install [--adapter <name>]` | Detect installed hosts, register sessionmem with each, and write default config; the flag selects one host. |
-| `sessionmem doctor [--adapter <name>]` | Check the store, schema, transcript discovery, hooks, MCP wiring, and canary recall offline; print PASS/FAIL and repair hints. |
-| `sessionmem uninstall [--adapter <name>] [--purge]` | Remove sessionmem from the host. `--purge` also deletes the local database. |
+| `sessionmem install [--adapter <name>]` | Detect installed hosts, configure integrations, write default config, and enable login capture; the flag selects one host. |
+| `sessionmem doctor [--adapter <name>]` | Check the store, schema, auto-start, binary paths, capture freshness, transcript discovery, hooks, MCP wiring, and canary recall offline; print PASS/FAIL and repair hints. |
+| `sessionmem autostart enable\|disable\|status` | Start login capture, stop and unregister it, or inspect its registration and binary paths. |
+| `sessionmem uninstall [--adapter <name>] [--purge]` | Stop and unregister login capture, then remove sessionmem from the selected host. `--purge` also deletes the local database. |
 | `sessionmem run` | Start the MCP server. |
 | `sessionmem ui [--port N]` | Open the local read-only web viewer (default port 3777). |
 | `sessionmem ping` | Check the local version and database reachability. |
@@ -297,7 +318,7 @@ When a fact changes, sessionmem can link its replacement locally. For example,
 
 Detection uses deterministic entity/relation rules, shared purpose words, a small tool-category vocabulary, and explicit negation or replacement phrases. It needs no API or model. Unfamiliar wording can be missed, and ambiguous changes can be misclassified. A memory with independent claims remains searchable while any claim is current; history labels these partial supersessions. See [supersession details](docs/architecture.md#contradiction-and-supersession).
 
-Run a scan to capture Claude Code, Codex CLI, and Cursor sessions from before sessionmem was installed:
+Install starts capture for existing history and new sessions automatically. For a manual import or a foreground diagnostic run:
 
 ```bash
 sessionmem scan
@@ -373,66 +394,64 @@ retry. Partial or malformed JSONL lines are reported and retried on later sweeps
 valid events in the same file can still be captured. A single sweep exits with
 status 1 if it encounters errors. The daemon keeps running and retries errors.
 
-`watch` prints its first sweep and subsequent imports or errors. It runs in the
-foreground until SIGINT or SIGTERM. For a background process:
+`watch` prints its first sweep and subsequent imports or errors. A manual run
+stays in the foreground until SIGINT or SIGTERM. Login capture uses the same
+watcher with an absolute Node executable and absolute sessionmem entry point;
+it does not need a shell, a TTY, or your interactive PATH.
 
-```bash
-nohup sessionmem watch > sessionmem-watch.log 2>&1 &
-```
-
-For macOS launchd, save this as
-`~/Library/LaunchAgents/io.sessionmem.watch.plist`. Replace the executable path
-with the output of `command -v sessionmem`, and adjust PATH for your Node install:
-
-```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key><string>io.sessionmem.watch</string>
-  <key>ProgramArguments</key>
-  <array><string>/opt/homebrew/bin/sessionmem</string><string>watch</string></array>
-  <key>EnvironmentVariables</key>
-  <dict><key>PATH</key><string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin</string></dict>
-  <key>RunAtLoad</key><true/>
-  <key>KeepAlive</key><true/>
-</dict>
-</plist>
-```
+Control login capture explicitly:
 
 ```bash
-launchctl bootstrap "gui/$(id -u)" ~/Library/LaunchAgents/io.sessionmem.watch.plist
-# Stop and unload:
-launchctl bootout "gui/$(id -u)/io.sessionmem.watch"
+sessionmem autostart status
+sessionmem autostart disable
+sessionmem autostart enable
 ```
 
-For a Linux systemd user service, save this as
-`~/.config/systemd/user/sessionmem-watch.service`. Replace the executable path
-and adjust PATH for your Node install:
-
-```ini
-[Unit]
-Description=Capture Claude Code, Codex, and Cursor transcripts with sessionmem
-
-[Service]
-ExecStart=/usr/local/bin/sessionmem watch
-Environment=PATH=/usr/local/bin:/usr/bin:/bin
-Restart=on-failure
-RestartSec=5
-
-[Install]
-WantedBy=default.target
-```
+`enable` updates one registration and starts capture immediately. `disable` stops
+the registered watcher and removes its login registration, preserving memories.
+The next `sessionmem install` enables it again. This control affects the login
+watcher; Claude Code hooks and explicit MCP memory tools remain active.
+
+Registrations:
+
+| OS | Registration |
+| --- | --- |
+| macOS | `~/Library/LaunchAgents/io.sessionmem.watch.plist` |
+| Linux | `~/.config/systemd/user/sessionmem-watch.service` |
+| Windows | Scheduled Task `sessionmem-watch-<user-home-hash>`, for the current user only |
+
+Capture output and failures are appended with timestamps to `logs/watch.log`
+beside the selected database (default `~/.sessionmem/logs/watch.log`). The
+watcher also writes `memories.db.watch-checkpoint.json` beside the default store
+after each completed sweep. Doctor checks this checkpoint's age, capture errors,
+and transcript checkpoint count; unchanged history and an empty history are
+healthy when the watcher continues completing sweeps. A checkpoint older than
+two minutes fails the default 5-second watcher check. For a custom polling
+interval, the limit is the greater of two minutes and three intervals.
+
+`SESSIONMEM_DB_PATH` selected at install or enable is saved as an absolute
+watcher argument. Run enable with that variable again to switch stores. The
+policy config remains `~/.sessionmem/config.json`. After moving sessionmem or
+changing Node versions, run `sessionmem autostart enable` to update the absolute
+paths. For failures before the watcher can open its log, inspect `launchctl
+print gui/<uid>/io.sessionmem.watch`, `journalctl --user -u
+sessionmem-watch.service`, or Windows Task Scheduler's task history.
+
+### Uninstall
 
 ```bash
-systemctl --user daemon-reload
-systemctl --user enable --now sessionmem-watch.service
-journalctl --user -u sessionmem-watch.service -f
-# Stop and disable:
-systemctl --user disable --now sessionmem-watch.service
+sessionmem uninstall --adapter claude-code
+# Also delete the selected memory database:
+sessionmem uninstall --adapter claude-code --purge
 ```
 
-These are optional examples; `sessionmem install` does not register a daemon.
+Uninstall stops capture and removes the login registration before removing MCP
+configuration, Claude hooks, and agent guidance for the selected host. It keeps
+the database, config and logs by default. Use the same `SESSIONMEM_DB_PATH` as
+install when selecting a custom database to purge. If stopping or unregistering
+the watcher fails, uninstall reports the OS error and leaves the database intact.
+For multiple installed hosts, repeat uninstall with each adapter to remove its
+MCP configuration and guidance.
 
 ---
 
@@ -558,9 +577,10 @@ sessionmem doctor --adapter claude-code  # explicit host override
 ```
 
 `doctor` reports a separate PASS or FAIL for the memory store, schema, transcript
-discovery for Claude Code and Codex, hook definitions shipped with the current
-version, configured MCP command, and a
-canary write/recall. It exits nonzero if any check fails and prints fix hints,
+discovery for Claude Code, Codex and Cursor, login auto-start registration,
+registered binary paths, watcher capture checkpoint freshness, hook definitions
+shipped with the current version, configured MCP command, and a canary
+write/recall. It exits nonzero if any check fails and prints fix hints,
 including exact commands for safe repairs. It does not create a missing store or
 apply migrations. Its temporary canary is isolated from your projects and rolled
 back even on failure. The MCP check starts the installed local command and verifies
@@ -568,7 +588,9 @@ its version, tools, and a stats response; it does not require a running agent.
 
 Use `sessionmem ping` to initialize a missing store or apply pending schema
 migrations, or `sessionmem install --adapter claude-code` to refresh Claude Code's
-MCP registration and hooks. Run repairs with the same `SESSIONMEM_DB_PATH` as
+MCP registration and hooks. Use `sessionmem autostart enable` to refresh the
+login service and absolute binary paths; inspect `logs/watch.log` beside the
+database when capture fails. Run repairs with the same `SESSIONMEM_DB_PATH` as
 doctor when using a custom store.
 
 If `stats` shows `sessions: 0` after real work, see [“0 sessions” / no session data recorded](docs/troubleshooting.md#0-sessions--no-session-data-recorded). Memories are keyed to the **repository root**, so every directory inside one repo shares a bucket; outside a repo the working directory itself is the key.

package/dist/cli/autostart/index.js

@@ -0,0 +1,246 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { accessSync, constants, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir, userInfo } from "os";
+import { dirname, isAbsolute, posix, win32 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveDbPath } from "../context.js";
+export const LABEL = "io.sessionmem.watch";
+export const UNIT = "sessionmem-watch.service";
+export const xml = (value) => value.replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&apos;" })[c]);
+const unxml = (value) => value.replace(/&(amp|lt|gt|quot|apos);/g, c => ({ "&amp;": "&", "&lt;": "<", "&gt;": ">", "&quot;": '"', "&apos;": "'" })[c]);
+const systemdQuote = (value) => JSON.stringify(value).replace(/%/g, "%%").replace(/\$/g, () => "$$");
+// All generated Windows arguments are quoted. Double backslashes before quotes
+// and at the closing quote according to CommandLineToArgvW rules.
+export const windowsQuote = (value) => `"${value.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, "$1$1")}"`;
+export function renderPlist(launch, log, home) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>Label</key><string>${LABEL}</string>
+<key>ProgramArguments</key><array>${[launch.command, ...launch.args].map(v => `<string>${xml(v)}</string>`).join("")}</array>
+<key>WorkingDirectory</key><string>${xml(home)}</string>
+<key>RunAtLoad</key><true/><key>KeepAlive</key><true/>
+<key>ThrottleInterval</key><integer>10</integer>
+<key>StandardOutPath</key><string>${xml(log)}</string>
+<key>StandardErrorPath</key><string>${xml(log)}</string>
+</dict></plist>
+`;
+}
+export function renderSystemd(launch, log, home) {
+    return `[Unit]
+Description=Capture agent transcripts with sessionmem
+StartLimitIntervalSec=0
+
+[Service]
+Type=simple
+ExecStart=${[launch.command, ...launch.args].map(systemdQuote).join(" ")}
+WorkingDirectory=${home.replace(/%/g, "%%")}
+Restart=always
+RestartSec=10
+StandardInput=null
+StandardOutput=append:${log.replace(/%/g, "%%")}
+StandardError=append:${log.replace(/%/g, "%%")}
+
+[Install]
+WantedBy=default.target
+`;
+}
+export function renderTask(launch, home, user) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<Task version="1.3" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+<Triggers><LogonTrigger><Enabled>true</Enabled><UserId>${xml(user)}</UserId></LogonTrigger></Triggers>
+<Principals><Principal id="Author"><UserId>${xml(user)}</UserId><LogonType>InteractiveToken</LogonType><RunLevel>LeastPrivilege</RunLevel></Principal></Principals>
+<Settings><MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy><DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries><StopIfGoingOnBatteries>false</StopIfGoingOnBatteries><StartWhenAvailable>true</StartWhenAvailable><ExecutionTimeLimit>PT0S</ExecutionTimeLimit><RestartOnFailure><Interval>PT1M</Interval><Count>255</Count></RestartOnFailure></Settings>
+<Actions Context="Author"><Exec><Command>${xml(launch.command)}</Command><Arguments>${xml(launch.args.map(windowsQuote).join(" "))}</Arguments><WorkingDirectory>${xml(home)}</WorkingDirectory></Exec></Actions>
+</Task>
+`;
+}
+export function decodeCommandOutput(value) {
+    // schtasks XML may use UTF-16 even when stdout is a pipe.
+    return (value[0] === 0xff && value[1] === 0xfe) || value[1] === 0
+        ? value.toString("utf16le").replace(/^\uFEFF/, "") : value.toString("utf8").replace(/^\uFEFF/, "");
+}
+export const runCommand = (command, args) => {
+    const result = spawnSync(command, args, { windowsHide: true, timeout: 15000, stdio: ["ignore", "pipe", "pipe"] });
+    if (result.error)
+        throw new Error(`${command}: ${result.error.message}`);
+    return { status: result.status ?? 1, stdout: decodeCommandOutput(result.stdout), stderr: decodeCommandOutput(result.stderr) };
+};
+function checked(run, command, args) {
+    const result = run(command, args);
+    if (result.status !== 0)
+        throw new Error(`${command} ${args.join(" ")}: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`}`);
+    return result;
+}
+function save(path, content) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content, { mode: 0o600 });
+}
+function strings(value) {
+    return [...value.matchAll(/<string>([\s\S]*?)<\/string>/g)].map(m => unxml(m[1]));
+}
+function launchFromArgs(args) {
+    if (args.length < 3 || args[2] !== "watch")
+        throw new Error("Unrecognized watcher command; run sessionmem autostart enable");
+    return { command: args[0], args: args.slice(1) };
+}
+export function invalidLaunchPaths(launch) {
+    return [launch.command, launch.args[0]].filter((path, index) => {
+        try {
+            if (!path || (!isAbsolute(path) && !win32.isAbsolute(path)) || !statSync(path).isFile())
+                return true;
+            accessSync(path, index === 0 && process.platform !== "win32" ? constants.X_OK : constants.R_OK);
+            return false;
+        }
+        catch {
+            return true;
+        }
+    });
+}
+export function createAutostart(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const home = options.home ?? homedir();
+    const paths = platform === "win32" ? win32 : posix;
+    const selectedDb = options.dbPath ?? resolveDbPath();
+    if (selectedDb === ":memory:")
+        throw new Error("Login capture requires a persistent database");
+    const dbPath = paths.resolve(selectedDb);
+    const data = paths.dirname(dbPath);
+    const log = paths.join(data, "logs", "watch.log");
+    // npm's sessionmem binary is a JS entry point. Pin both it and Node, avoiding
+    // /usr/bin/env, npm shims and interactive shell/version-manager setup at login.
+    const launch = {
+        command: paths.resolve(options.nodePath ?? process.execPath),
+        args: [paths.resolve(options.cliPath ?? fileURLToPath(new URL("../index.js", import.meta.url))), "watch", "--db-path", dbPath, "--log-file", log],
+    };
+    const run = options.run ?? runCommand;
+    const invoke = (command, args) => checked(run, command, args);
+    const prepare = () => {
+        if ([home, launch.command, ...launch.args].some(value => /[\r\n\0]/.test(value)))
+            throw new Error("Login service paths cannot contain line breaks or NUL");
+        const invalid = invalidLaunchPaths(launch);
+        if (invalid.length)
+            throw new Error(`Cannot read or execute installed binary: ${invalid.join(", ")}`);
+        mkdirSync(paths.dirname(log), { recursive: true });
+    };
+    if (platform === "darwin") {
+        const file = paths.join(home, "Library", "LaunchAgents", `${LABEL}.plist`);
+        const domain = `gui/${options.uid ?? userInfo().uid}`;
+        const target = `${domain}/${LABEL}`;
+        const loaded = () => {
+            const result = run("launchctl", ["print", target]);
+            if (result.status === 0)
+                return true;
+            if (/could not find service|no such process/i.test(result.stderr))
+                return false;
+            throw new Error(`launchctl print: ${result.stderr || result.stdout}`);
+        };
+        return {
+            enable() {
+                prepare();
+                if (loaded())
+                    invoke("launchctl", ["bootout", target]);
+                save(file, renderPlist(launch, log, home));
+                invoke("launchctl", ["enable", target]);
+                invoke("launchctl", ["bootstrap", domain, file]);
+            },
+            disable() {
+                if (loaded())
+                    invoke("launchctl", ["bootout", target]);
+                rmSync(file, { force: true });
+            },
+            status() {
+                if (!existsSync(file))
+                    return { registered: false, detail: `No LaunchAgent (${file})` };
+                const content = readFileSync(file, "utf8");
+                const args = strings(content.match(/<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/)?.[1] ?? "");
+                return { registered: loaded(), launch: launchFromArgs(args), detail: file };
+            },
+        };
+    }
+    if (platform === "linux") {
+        const file = paths.join(home, ".config", "systemd", "user", UNIT);
+        return {
+            enable() {
+                prepare();
+                save(file, renderSystemd(launch, log, home));
+                invoke("systemctl", ["--user", "daemon-reload"]);
+                invoke("systemctl", ["--user", "enable", UNIT]);
+                invoke("systemctl", ["--user", "restart", UNIT]);
+            },
+            disable() {
+                if (!existsSync(file))
+                    return;
+                invoke("systemctl", ["--user", "disable", "--now", UNIT]);
+                rmSync(file, { force: true });
+                invoke("systemctl", ["--user", "daemon-reload"]);
+            },
+            status() {
+                if (!existsSync(file))
+                    return { registered: false, detail: `No user service (${file})` };
+                const value = readFileSync(file, "utf8").match(/^ExecStart=(.+)$/m)?.[1] ?? "";
+                const args = [...value.matchAll(/"(?:\\.|[^"\\])*"/g)].map(m => JSON.parse(m[0]).replace(/%%/g, "%").replace(/\$\$/g, "$"));
+                const result = run("systemctl", ["--user", "is-enabled", UNIT]);
+                if (result.status !== 0 && !["disabled", "masked", "not-found"].includes(result.stdout.trim()))
+                    throw new Error(`systemctl --user is-enabled: ${result.stderr || result.stdout}`);
+                return { registered: result.status === 0, launch: launchFromArgs(args), detail: `${file} (${result.stdout.trim()})` };
+            },
+        };
+    }
+    if (platform === "win32") {
+        // Task names are machine-wide; one stable name per user's home avoids
+        // overwriting another user's task on shared Windows machines.
+        const name = `sessionmem-watch-${createHash("sha256").update(home.toLowerCase()).digest("hex").slice(0, 12)}`;
+        const file = paths.join(data, "autostart-task.xml");
+        const query = () => {
+            const result = run("schtasks.exe", ["/Query", "/TN", name, "/XML", "/HRESULT"]);
+            if ((result.status >>> 0) === 0x80070002)
+                return undefined; // ERROR_FILE_NOT_FOUND
+            if (result.status !== 0)
+                throw new Error(`schtasks /Query: ${result.stderr || result.stdout || result.status}`);
+            return result.stdout;
+        };
+        const stop = () => {
+            const result = run("schtasks.exe", ["/End", "/TN", name, "/HRESULT"]);
+            // Numeric HRESULTs avoid matching localized Windows error messages.
+            if (result.status !== 0 && (result.status >>> 0) !== 0x8004130b)
+                throw new Error(`schtasks /End: ${result.stderr || result.stdout || result.status}`);
+        };
+        return {
+            enable() {
+                prepare();
+                const identity = invoke("whoami.exe", ["/USER", "/FO", "CSV", "/NH"]).stdout;
+                const user = identity.match(/"(S-1-[0-9-]+)"/)?.[1];
+                if (!user)
+                    throw new Error("whoami returned no user SID for the logon task");
+                if (query() !== undefined)
+                    stop();
+                save(file, renderTask(launch, home, user));
+                invoke("schtasks.exe", ["/Create", "/TN", name, "/XML", file, "/F"]);
+                invoke("schtasks.exe", ["/Run", "/TN", name]);
+            },
+            disable() {
+                if (query() !== undefined) {
+                    stop();
+                    invoke("schtasks.exe", ["/Delete", "/TN", name, "/F"]);
+                }
+                rmSync(file, { force: true });
+            },
+            status() {
+                const content = query();
+                if (content === undefined)
+                    return { registered: false, detail: `No Scheduled Task (${name})` };
+                const command = unxml(content.match(/<Command>([\s\S]*?)<\/Command>/)?.[1] ?? "");
+                const args = unxml(content.match(/<Arguments>([\s\S]*?)<\/Arguments>/)?.[1] ?? "");
+                // The first argument is an absolute .js path, which cannot contain quotes
+                // on Windows. The remaining arguments are only needed for display.
+                const cli = args.match(/^"([^"]+)"\s+"watch"(?:\s|$)/)?.[1];
+                if (!command || !cli)
+                    throw new Error("Unrecognized Scheduled Task action; run sessionmem autostart enable");
+                return { registered: !/<Enabled>false<\/Enabled>/.test(content), launch: { command, args: [cli, "watch"] }, detail: name };
+            },
+        };
+    }
+    throw new Error(`Login auto-start is unsupported on ${platform}`);
+}

package/dist/cli/commands/autostart.js

@@ -0,0 +1,24 @@
+import { createAutostart, invalidLaunchPaths } from "../autostart/index.js";
+export function autostartCommand(action, service) {
+    if (!["enable", "disable", "status"].includes(action))
+        throw new Error("Use sessionmem autostart enable, disable, or status");
+    const autostart = service ?? createAutostart();
+    if (action === "status") {
+        const status = autostart.status();
+        console.log(`Auto-start ${status.registered ? "enabled" : "disabled"}: ${status.detail}`);
+        if (status.launch) {
+            console.log(`Binary: ${status.launch.command}\nEntry point: ${status.launch.args[0]}`);
+            const invalid = invalidLaunchPaths(status.launch);
+            if (invalid.length) {
+                console.error(`Invalid binary path: ${invalid.join(", ")}. Run sessionmem autostart enable.`);
+                process.exitCode = 1;
+            }
+        }
+        return;
+    }
+    if (action === "enable")
+        autostart.enable();
+    else
+        autostart.disable();
+    console.log(`Auto-start ${action === "enable" ? "enabled and started" : "disabled and stopped"}`);
+}

package/dist/cli/commands/config.js

@@ -42,6 +42,7 @@ const CONFIG_KEYS = {
     retentionDays: { field: "retentionDays", coerce: coerceRetentionDays },
     redactionEnabled: { field: "redactionEnabled", coerce: coerceBool },
     injectionCap: { field: "injectionCap", coerce: coerceInjectionCap },
+    semanticSearch: { field: "semanticSearch", coerce: coerceBool },
 };
 function resolvePath(options) {
     return options?.configPath ?? configFilePath();

package/dist/cli/commands/doctor.js

@@ -1,3 +1,5 @@
+import { createAutostart, invalidLaunchPaths } from "../autostart/index.js";
+import { inspectWatchCheckpoint } from "../watchCheckpoint.js";
 import BetterSqlite3 from "better-sqlite3";
 import { randomUUID } from "node:crypto";
 import { createRequire } from "node:module";
@@ -54,6 +56,23 @@ export async function doctorCommand(options, overrides = {}) {
         report("Agent hosts", false, message(err), "Install a supported host or select one with sessionmem doctor --adapter <name>");
     }
     const dbPath = resolveDbPath(overrides.dbPath);
+    const captureFix = "Run sessionmem autostart enable; inspect logs/watch.log beside the database and OS service logs, then run sessionmem doctor";
+    try {
+        const registration = createAutostart({ dbPath }).status();
+        report("Auto-start registration", registration.registered, registration.detail, registration.registered ? undefined : captureFix);
+        const invalid = registration.launch ? invalidLaunchPaths(registration.launch) : ["No registered binary"];
+        report("Auto-start binary", invalid.length === 0, invalid.length ? invalid.join(", ") : "Registered Node binary and sessionmem entry point are readable", invalid.length ? "Reinstall sessionmem if needed, then run sessionmem autostart enable" : undefined);
+    }
+    catch (err) {
+        report("Auto-start registration", false, message(err), captureFix);
+        report("Auto-start binary", false, "Cannot inspect the registration", captureFix);
+    }
+    try {
+        report("Watcher capture", true, inspectWatchCheckpoint(dbPath));
+    }
+    catch (err) {
+        report("Watcher capture", false, message(err), captureFix);
+    }
     for (const host of TRANSCRIPT_HOSTS) {
         try {
             report(`${host} transcripts`, true, await inspectTranscriptDiscovery(host));

package/dist/cli/commands/install.js

@@ -1,3 +1,4 @@
+import { createAutostart } from "../autostart/index.js";
 import { existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
@@ -87,6 +88,15 @@ export async function installCommand(options, contextOverrides) {
             console.log("✓ Claude Code: SessionStart, SessionEnd, PostToolUse hooks configured (~/.claude/settings.json)");
         }
     }
+    try {
+        createAutostart({ dbPath: dbPath }).enable();
+        console.log("Auto-start enabled and started; capture logs are in logs/watch.log beside the database");
+    }
+    catch (err) {
+        console.error(`Auto-start setup failed: ${err instanceof Error ? err.message : String(err)}`);
+        console.error("Fix the OS login service error, then run sessionmem autostart enable. Run sessionmem doctor to check capture.");
+        failed = true;
+    }
     if (failed)
         process.exit(1);
     console.log("✓ sessionmem ready — restart your editor/agent so it picks up the MCP server");

package/dist/cli/commands/uninstall.js

@@ -1,3 +1,4 @@
+import { createAutostart } from "../autostart/index.js";
 import { existsSync, rmSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
@@ -28,6 +29,9 @@ export async function uninstallCommand(options = {}) {
         console.error(err instanceof Error ? err.message : String(err));
         process.exit(1);
     }
+    // Stop capture before removing integrations or purging an open database.
+    createAutostart({ dbPath: options.dbPath }).disable();
+    console.log("Auto-start removed and watcher stopped");
     if (!adapter.uninstall) {
         console.error(`${adapter.name} does not support automated uninstall. Remove sessionmem from your MCP config manually.`);
         process.exit(1);

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();
     }
 }