sessionmem 1.6.0 → 1.8.0

package/dist/adapters/global/claudeCode.js

@@ -1,7 +1,7 @@
 import { join } from "path";
 import { homedir } from "os";
 import { GenericMCPAdapter } from "../generic.js";
-import { IDEInstaller, SESSIONMEM_HOOK_COMMAND, SESSIONMEM_SESSION_END_HOOK_COMMAND, SESSIONMEM_POST_TOOL_HOOK_COMMAND, SESSIONMEM_POST_TOOL_MATCHER, } from "../ide/installer.js";
+import { IDEInstaller, SESSIONMEM_HOOK_COMMAND, SESSIONMEM_SESSION_END_HOOK_COMMAND, SESSIONMEM_POST_TOOL_HOOK_COMMAND, SESSIONMEM_POST_TOOL_MATCHER, SESSIONMEM_PROMPT_HOOK_COMMAND, } from "../ide/installer.js";
 export class ClaudeCodeAdapter extends GenericMCPAdapter {
     name = "Claude Code";
     // Capabilities inherited from GenericMCPAdapter (tools only) so the
@@ -33,6 +33,7 @@ export class ClaudeCodeAdapter extends GenericMCPAdapter {
                 path: this.settingsPath(),
                 entries: [
                     { event: "SessionStart", command: SESSIONMEM_HOOK_COMMAND },
+                    { event: "UserPromptSubmit", command: SESSIONMEM_PROMPT_HOOK_COMMAND },
                     { event: "SessionEnd", command: SESSIONMEM_SESSION_END_HOOK_COMMAND },
                     { event: "PostToolUse", command: SESSIONMEM_POST_TOOL_HOOK_COMMAND, matcher: SESSIONMEM_POST_TOOL_MATCHER },
                 ],
@@ -63,7 +64,8 @@ export class ClaudeCodeAdapter extends GenericMCPAdapter {
         // MultiEdit) are captured as session events automatically, feeding the
         // SessionEnd auto-summarizer without the agent calling ingestSessionEvents.
         const postToolOk = await IDEInstaller.injectClaudeHook(this.settingsPath(), SESSIONMEM_POST_TOOL_HOOK_COMMAND, "PostToolUse", SESSIONMEM_POST_TOOL_MATCHER);
-        return mcpOk && startHookOk && endHookOk && postToolOk;
+        const promptOk = await IDEInstaller.injectClaudeHook(this.settingsPath(), SESSIONMEM_PROMPT_HOOK_COMMAND, "UserPromptSubmit");
+        return mcpOk && startHookOk && endHookOk && postToolOk && promptOk;
     }
     async uninstall() {
         const configPath = join(homedir(), ".claude.json");
@@ -73,6 +75,7 @@ export class ClaudeCodeAdapter extends GenericMCPAdapter {
         const startOk = await IDEInstaller.removeClaudeHook(this.settingsPath(), SESSIONMEM_HOOK_COMMAND);
         const endOk = await IDEInstaller.removeClaudeHook(this.settingsPath(), SESSIONMEM_SESSION_END_HOOK_COMMAND, "SessionEnd");
         const postToolOk = await IDEInstaller.removeClaudeHook(this.settingsPath(), SESSIONMEM_POST_TOOL_HOOK_COMMAND, "PostToolUse");
-        return mcpOk && startOk && endOk && postToolOk;
+        const promptOk = await IDEInstaller.removeClaudeHook(this.settingsPath(), SESSIONMEM_PROMPT_HOOK_COMMAND, "UserPromptSubmit");
+        return mcpOk && startOk && endOk && postToolOk && promptOk;
     }
 }

package/dist/adapters/ide/cline.js

@@ -2,6 +2,7 @@ import { join } from "path";
 import { homedir } from "os";
 import { existsSync } from "fs";
 import { GenericMCPAdapter } from "../generic.js";
+export const AUTOMATIC_MEMORY_TOOLS = ["searchMemoryIndex", "memoryTimeline", "getMemory", "retrieveMemories", "storeMemory", "batchStoreMemory", "ingestSessionEvents", "stats"];
 import { IDEInstaller } from "./installer.js";
 /**
  * VS Code variants Cline can be installed into, in detection-priority order.
@@ -57,7 +58,7 @@ export class ClineAdapter extends GenericMCPAdapter {
         // Cline's server schema carries `disabled` and `autoApprove` alongside
         // command/args; pass them through so the written block matches what Cline
         // expects to read.
-        return IDEInstaller.injectMcpConfig(this.configPath, "sessionmem", "sessionmem", ["run"], { disabled: false, autoApprove: [] });
+        return IDEInstaller.injectMcpConfig(this.configPath, "sessionmem", "sessionmem", ["run"], { disabled: false, autoApprove: AUTOMATIC_MEMORY_TOOLS });
     }
     installation() {
         return { mcp: { path: this.configPath, command: "sessionmem", args: ["run"] } };

package/dist/adapters/ide/cursor.js

@@ -6,12 +6,12 @@ export class CursorAdapter extends GenericMCPAdapter {
     name = "Cursor";
     // Capabilities inherited from GenericMCPAdapter (tools only).
     /**
-     * Cursor reads project rules from `.cursor/rules/*.mdc`. A home-level rule
-     * file gives every project the sessionmem guidance. The injector seeds
+     * Cursor reads project rules from `.cursor/rules/*.mdc`. Install in this
+     * project; global MCP server instructions cover other projects. The injector seeds
      * `alwaysApply: true` frontmatter on creation so the rule is always active.
      */
     guidanceTargets() {
-        return [join(homedir(), ".cursor", "rules", "sessionmem.mdc")];
+        return [join(process.cwd(), ".cursor", "rules", "sessionmem.mdc")];
     }
     /**
      * Cursor reads MCP servers from `~/.cursor/mcp.json` (global) — NOT from the

package/dist/adapters/ide/installer.js

@@ -31,6 +31,7 @@ export const SESSIONMEM_SESSION_END_HOOK_COMMAND = _isWindows
 export const SESSIONMEM_POST_TOOL_HOOK_COMMAND = _isWindows
     ? "cmd /c sessionmem ingest-hook"
     : "sessionmem ingest-hook";
+export const SESSIONMEM_PROMPT_HOOK_COMMAND = _isWindows ? "cmd /c sessionmem prompt-submit" : "sessionmem prompt-submit";
 /** Tool matcher for the PostToolUse auto-ingest hook. */
 export const SESSIONMEM_POST_TOOL_MATCHER = "Bash|Edit|Write|MultiEdit";
 /** Default Claude Code hook event for the legacy 2-arg hook helpers. */

package/dist/adapters/installedHosts.js

@@ -5,6 +5,9 @@ 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: "codex", executables: ["codex"] },
+    { adapter: "cursor", executables: ["cursor"] },
+    { adapter: "windsurf", executables: ["windsurf"] },
     {
         adapter: "claude-code",
         executables: ["claude"],
@@ -45,7 +48,7 @@ export function resolveInstallAdapters(options) {
         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>.");
+        throw new Error("No supported agent host found. Install a supported host CLI or use sessionmem install --adapter <name>.");
     }
     return { adapters, forced: false };
 }

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,14 @@ const CONFIG_KEYS = {
     retentionDays: { field: "retentionDays", coerce: coerceRetentionDays },
     redactionEnabled: { field: "redactionEnabled", coerce: coerceBool },
     injectionCap: { field: "injectionCap", coerce: coerceInjectionCap },
+    semanticSearch: { field: "semanticSearch", coerce: coerceBool },
+    temporalRetrieval: { field: "temporalRetrieval", coerce: coerceBool },
+    entityLinkBoost: { field: "entityLinkBoost", coerce: coerceBool },
+    retrievalRanking: { field: "retrievalRanking", coerce: raw => {
+            if (!["legacy", "adaptive-bm25", "hub-additive", "adaptive-hub-additive"].includes(raw))
+                throw new Error("Unknown retrieval ranking");
+            return raw;
+        } },
 };
 function resolvePath(options) {
     return options?.configPath ?? configFilePath();

package/dist/cli/commands/doctor.js

@@ -1,8 +1,10 @@
+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";
 import { resolveInstallAdapters } from "../../adapters/installedHosts.js";
-import { checkHooks, readMcpLaunch, probeMcpWiring } from "../../adapters/diagnostics.js";
+import { checkHooks, checkAgentGuidance, 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";
@@ -54,12 +56,33 @@ 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);
+    let autostartHealthy = false;
+    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"];
+        autostartHealthy = registration.registered && invalid.length === 0;
+        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);
+    }
+    let watcherHealthy = false;
+    try {
+        report("Watcher capture", true, inspectWatchCheckpoint(dbPath));
+        watcherHealthy = true;
+    }
+    catch (err) {
+        report("Watcher capture", false, message(err), captureFix);
+    }
     for (const host of TRANSCRIPT_HOSTS) {
         try {
             report(`${host} transcripts`, true, await inspectTranscriptDiscovery(host));
         }
         catch (err) {
-            report(`${host} transcripts`, false, message(err), `Check transcript directory permissions and format; run sessionmem scan --host ${host}`);
+            report(`${host} transcripts`, false, message(err), `Check transcript directory permissions and format; check the watcher logs; imports retry automatically`);
         }
     }
     let db;
@@ -112,8 +135,10 @@ export async function doctorCommand(options, overrides = {}) {
                 report(`${adapter.name} adapter wiring`, false, "Adapter has no installation diagnostics", installFix);
                 continue;
             }
+            let hooksHealthy = false, wiringHealthy = false, guidanceHealthy = false;
             try {
                 report(`${adapter.name} hooks`, true, `${checkHooks(installation)}; sessionmem ${VERSION}`);
+                hooksHealthy = Boolean(installation.hooks);
             }
             catch (err) {
                 report(`${adapter.name} hooks`, false, message(err), `Enable hooks in the host settings if disabled, then run ${installFix}`);
@@ -124,10 +149,28 @@ export async function doctorCommand(options, overrides = {}) {
                     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");
+                wiringHealthy = true;
             }
             catch (err) {
                 report(`${adapter.name} adapter wiring`, false, message(err), `Ensure sessionmem is on PATH, then run ${installFix}`);
             }
+            try {
+                report(`${adapter.name} agent instructions`, true, checkAgentGuidance(adapter));
+                guidanceHealthy = true;
+            }
+            catch (err) {
+                report(`${adapter.name} agent instructions`, false, message(err), installFix);
+            }
+            const native = Boolean(installation.hooks);
+            const transcript = ["Claude Code", "Codex", "Cursor"].includes(adapter.name);
+            const unverifiedHost = ["Antigravity", "QCoder"].includes(adapter.name);
+            const capture = !unverifiedHost && schemaOk && (native ? hooksHealthy || (autostartHealthy && watcherHealthy) : transcript ? autostartHealthy && watcherHealthy : guidanceHealthy && wiringHealthy);
+            report(`${adapter.name} automatic capture`, capture, unverifiedHost ? "Native adapter paths are unverified; automatic capture is not established" : native ? "Hook capture and transcript watcher configured; see hook and watcher checks"
+                : transcript ? "Login watcher imports supported transcripts; a healthy sweep is required"
+                    : "Agent-driven saves only; no background transcript importer for this host", capture ? undefined : unverifiedHost ? "Verify the native host MCP and guidance paths in its current settings, or select a verified host adapter" : transcript ? captureFix : `Enable memory tool calls and load the instructions from ${adapter.guidanceTargets?.().join(", ")}; ${installFix}`);
+            const recall = !unverifiedHost && schemaOk && wiringHealthy && (native ? hooksHealthy : guidanceHealthy);
+            report(`${adapter.name} automatic recall`, recall, unverifiedHost ? "Native host loading is unverified; automatic recall is not established" : native ? "SessionStart and UserPromptSubmit hooks inject context"
+                : "Instruction-driven startup and prompt recall configured; agent execution is not verified by doctor", recall ? undefined : unverifiedHost ? "Configure the MCP server and startup instructions in the native host settings; these adapter paths are unverified" : `Enable memory tools, load the installed instructions and run ${installFix}`);
         }
         if (!adapters.length) {
             report("Hook configuration", false, "No host selected", "sessionmem doctor --adapter <name>");

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";
@@ -80,14 +81,24 @@ export async function installCommand(options, contextOverrides) {
                 console.log(`✓ ${adapter.name}: Agent guidance injected (${target})`);
             }
             catch {
-                console.error(`✗ ${adapter.name}: Agent guidance injection failed (non-fatal): ${target}`);
+                console.error(`✗ ${adapter.name}: Agent guidance injection failed; automatic recall is not configured: ${target}`);
+                failed = true;
             }
         }
         if (adapter.name === "Claude Code") {
-            console.log("✓ Claude Code: SessionStart, SessionEnd, PostToolUse hooks configured (~/.claude/settings.json)");
+            console.log("✓ Claude Code: SessionStart, UserPromptSubmit, 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");
+    console.log("✓ sessionmem ready; restart your editor/agent so it picks up the MCP server");
 }

package/dist/cli/commands/promptSubmit.js

@@ -0,0 +1,58 @@
+import { createCliContext } from "../context.js";
+import { deriveProjectId } from "../projectId.js";
+/** Bounded hook input. Invalid input produces no context and never blocks a prompt. */
+export async function promptSubmitCommand(ctx, supplied) {
+    let context;
+    try {
+        let payload = supplied;
+        if (payload === undefined) {
+            payload = await new Promise(resolve => {
+                let text = "", finished = false;
+                const done = () => {
+                    if (finished)
+                        return;
+                    finished = true;
+                    clearTimeout(timer);
+                    process.stdin.removeListener("data", data);
+                    process.stdin.removeListener("end", done);
+                    process.stdin.removeListener("error", done);
+                    process.stdin.pause();
+                    try {
+                        resolve(JSON.parse(text));
+                    }
+                    catch {
+                        resolve({});
+                    }
+                };
+                const data = (chunk) => { text += chunk; if (text.length > 65536) {
+                    text = "";
+                    done();
+                } };
+                const timer = setTimeout(done, 500);
+                timer.unref();
+                process.stdin.setEncoding("utf8");
+                process.stdin.on("data", data);
+                process.stdin.on("end", done);
+                process.stdin.on("error", done);
+            });
+        }
+        if (!payload || typeof payload !== "object")
+            return;
+        const { prompt, cwd } = payload;
+        if (typeof prompt !== "string" || !prompt.trim())
+            return;
+        context = ctx ?? createCliContext(typeof cwd === "string" ? { projectId: deriveProjectId(cwd) } : {});
+        const result = await context.service.call("retrieveMemories", {
+            projectId: context.projectId, query: prompt.slice(0, 1000), limit: 5, mode: "on-demand", depth: "default",
+        });
+        if (result.ok && result.startupInjection.trim())
+            process.stdout.write(JSON.stringify({
+                hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: result.startupInjection },
+            }));
+    }
+    catch { /* Hook failures do not interrupt the host. Doctor diagnoses the setup. */ }
+    finally {
+        if (!ctx)
+            context?.db.close();
+    }
+}

package/dist/cli/commands/sessionStart.js

@@ -1,3 +1,4 @@
+import { sweepTranscripts } from "../transcriptSweep.js";
 import { createCliContext } from "../context.js";
 /**
  * Generic startup query. When few memories contain these literal tokens the
@@ -25,8 +26,15 @@ const STARTUP_QUERY = "session startup context recent decisions architecture war
  *    starts clean.
  */
 export async function sessionStartCommand(ctx) {
+    let context;
     try {
-        const context = ctx ?? createCliContext();
+        context = ctx ?? createCliContext();
+        if (!ctx) {
+            try {
+                await sweepTranscripts(context, {});
+            }
+            catch { /* Existing recall still works when transcript discovery fails. */ }
+        }
         const result = await context.service.call("retrieveMemories", {
             projectId: context.projectId,
             query: STARTUP_QUERY,
@@ -47,6 +55,10 @@ export async function sessionStartCommand(ctx) {
         }
     }
     catch {
-        // Never block session start — emit nothing on any failure.
+        // Never block session start.
+    }
+    finally {
+        if (!ctx)
+            context?.db.close();
     }
 }

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