sessionmem 1.5.0 → 1.7.0

package/CHANGELOG.md

@@ -5,6 +5,43 @@ 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
+
+- Multi-host transcript imports: `sessionmem scan` and `sessionmem watch` now
+  sweep Claude Code, Codex CLI, and Cursor histories by default, with a
+  separate parser per host and an explicit unsupported-format error when a
+  claimed host's records cannot be parsed. `--host` selects one host.
+  ([#52], [#53])
+- Codex CLI support: dated rollout discovery, project and session identity from
+  session metadata, resume-file grouping with cross-file deduplication,
+  sub-agent session separation, native tool-call events, and filtering of
+  encrypted agent payloads and injected machine blocks. ([#52])
+- Cursor support: chat history read from Cursor's SQLite storage through
+  private snapshot copies opened read-only, covering both composer index
+  layouts, with per-composer checkpoints and live-update handling. ([#53])
+- `sessionmem doctor` now checks transcript discovery for each supported
+  host. ([#52], [#53])
+
 ## [1.5.0] - 2026-10-18
 
 ### Added
@@ -102,6 +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
@@ -112,6 +153,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [#49]: https://github.com/catfish-1234/sessionmem/pull/49
 [#50]: https://github.com/catfish-1234/sessionmem/pull/50
 [#51]: https://github.com/catfish-1234/sessionmem/pull/51
+[#52]: https://github.com/catfish-1234/sessionmem/pull/52
+[#53]: https://github.com/catfish-1234/sessionmem/pull/53
 [1.4.0]: https://github.com/catfish-1234/sessionmem/compare/a73f503123b1d33c35407ce66403f281ba3451ac...679b8954f0b49f197985c40da47f181c00060cd9
 [#22]: https://github.com/catfish-1234/sessionmem/pull/22
 [#23]: https://github.com/catfish-1234/sessionmem/pull/23

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, 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. |
@@ -223,8 +244,8 @@ See [`docs/architecture.md`](docs/architecture.md) for the technical overview.
 | `sessionmem forget <id> [--force]` | Delete a memory by ID. |
 | `sessionmem export [path]` | Export all current-project memories to JSON (default `~/.sessionmem/export-YYYY-MM-DD.json`). |
 | `sessionmem import <path> [--merge]` | Import up to 1000 valid records from UTF-8 JSON into the current project. Existing IDs are preserved, including with `--merge`; invalid records are skipped with warnings. |
-| `sessionmem scan [--transcripts-dir <path>]` | Import existing Claude Code JSONL transcripts into local session memories. Reports files found, sessions imported, memories created, skipped files, and errors. |
-| `sessionmem watch [--once] [--interval <seconds>] [--transcripts-dir <path>]` | Capture new or updated Claude Code transcripts. Polls every 5 seconds by default; `--once` runs a single sweep. |
+| `sessionmem scan [--host <host>] [--transcripts-dir <path>]` | Import existing Claude Code, Codex CLI, and Cursor transcripts into local session memories. Reports files found, sessions imported, memories created, skips, and errors. |
+| `sessionmem watch [--once] [--interval <seconds>] [--host <host>] [--transcripts-dir <path>]` | Capture new or updated Claude Code, Codex CLI, and Cursor transcripts. Polls every 5 seconds by default; `--once` runs a single sweep. |
 | `sessionmem stats` | Show memory statistics for the current project. |
 | `sessionmem savings [--json]` | Show token savings from compression and injection, with percentage. |
 | `sessionmem redact-scan [--apply]` | Scan stored memories for secrets; `--apply` redacts in place. |
@@ -297,96 +318,140 @@ 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 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
 sessionmem watch --once
 sessionmem watch --interval 10
+sessionmem scan --host cursor
 ```
 
-Both commands recursively read `~/.claude/projects/**/*.jsonl`. Use
-`--transcripts-dir "/path/to/projects"` to select another transcript tree. They
-work fully offline without API keys and always use the local summarizer, even
-if cloud summarization is enabled elsewhere.
-
-Transcript user/assistant text and supported tool uses (Bash, Edit, Write,
-MultiEdit) pass through the existing event-ingestion, redaction, and session-summary
-pipeline. Each session gets one summary memory, including short sessions with
-only one event. Updated sessions refresh that summary. Project buckets come from
-each transcript's `cwd`, using its repository root when available; the directory
-where you run scan/watch does not select the project. `SESSIONMEM_PROJECT_ID`
-can explicitly pin all imports to one bucket. Transcripts without a working
-directory or capturable events are skipped; nested subagent files get separate
-session summaries.
+Both commands sweep all detected transcript histories by default:
+
+- Claude Code: `~/.claude/projects/**/*.jsonl`.
+- Codex CLI: `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl`.
+- Cursor: `User/globalStorage/state.vscdb` under
+  `~/Library/Application Support/Cursor` on macOS, `~/.config/Cursor` on Linux,
+  or `%APPDATA%/Cursor` on Windows.
+
+Missing history directories are allowed. Use `--transcripts-dir "/path/to/history"`
+to select another transcript tree; each JSONL file's host is detected from its records.
+For Cursor, the override accepts its `User` directory or a `state.vscdb` path.
+Use `--host cursor`, `--host codex`, or `--host claude-code` to select one host,
+including when using an override. A Cursor User directory or `.vscdb` file is
+also detected without `--host`. Files that do not match a supported format, or
+the selected host, produce an explicit `unsupported format` error.
+
+Both commands work offline without API keys and always use the local summarizer,
+even if cloud summarization is enabled elsewhere. `sessionmem doctor` checks
+transcript discovery for all three hosts, parses JSONL samples, and validates
+Cursor's composer indexes and message rows when history is present.
+
+Transcript user/assistant text, supported Claude tool uses (Bash, Edit, Write,
+MultiEdit), and Codex function calls pass through the existing event-ingestion,
+redaction, and session-summary pipeline. Codex tool events retain the native tool
+name and `call_id`. Encrypted `agent_message` payloads and obvious injected machine
+blocks, including plugin catalogues and environment context, are excluded. Each
+session gets one summary memory, including short sessions with only one event.
+Updated sessions refresh that summary. Project buckets come from
+each Claude transcript's `cwd`, Codex `session_meta.payload.cwd`, or Cursor's
+workspace path, using the repository root when available; the directory where you run scan/watch does not
+select the project. `SESSIONMEM_PROJECT_ID` can explicitly pin all imports to one
+bucket. Transcripts without capturable events are skipped. Claude transcripts
+without a working directory are also skipped; Codex session metadata must contain
+an ID and working directory. Nested subagent files get separate session summaries.
+Summary memories record `sourceAdapter` as `claude-code`, `codex`, or `cursor`
+according to the transcript host. Cursor session IDs come from `composerId`.
+
+Cursor stores messages in `cursorDiskKV` bubble rows in its global SQLite
+database. The importer supports workspace `composer.composerData` indexes
+(Cursor 2.6 and earlier) and the central `composer.composerHeaders` index
+(Cursor 3.0 and later). It captures up to 4,000 characters of user/assistant text
+per bubble and excludes tool-only bubbles and internal tool/code fields. Missing
+tables, index keys, or required conversation data produce an explicit
+`unsupported format for cursor` error.
+
+Cursor databases are never written. Each sweep copies the database and its WAL
+to a private temporary directory, checking for concurrent changes during the
+copy. SQLite opens the copy read-only, using immutable mode when URI support is
+available and there is no WAL to replay. Cursor's live database is never opened by SQLite. Busy
+copies are reported and retried. Each sweep reads a fresh snapshot; per-composer
+checkpoints skip unchanged messages, and streamed bubble updates refresh the
+existing event without duplicating it.
+
+Codex resumes create new rollout files. Files with the same session ID are grouped,
+and replayed events are deduplicated across files, sweeps, and restarts. A Codex
+sub-agent keeps its own `session_meta.payload.id`, even when `parent_thread_id`
+points to a parent session.
 
 Re-running either command does not duplicate memories or transcript events.
-File checkpoints live in the selected memory database, and unchanged files are
-skipped across restarts. Stable event IDs also make interrupted imports safe to
+File and composer checkpoints live in the selected memory database, and unchanged
+files or composers are skipped across restarts. For Cursor, `files found` counts
+global databases, and `skipped` counts unchanged or empty composers.
+Stable event IDs also make interrupted imports safe to
 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 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.
 
 ---
 
@@ -511,9 +576,11 @@ sessionmem doctor
 sessionmem doctor --adapter claude-code  # explicit host override
 ```
 
-`doctor` reports a separate PASS or FAIL for the memory store, schema, 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,
+`doctor` reports a separate PASS or FAIL for the memory store, schema, transcript
+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
@@ -521,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}`);
+}