context-mode 0.9.21 → 1.0.0

package/build/db-base.d.ts

@@ -0,0 +1,84 @@
+/**
+ * db-base — Reusable SQLite infrastructure for context-mode packages.
+ *
+ * Provides lazy-loading of better-sqlite3, WAL pragma setup, prepared
+ * statement caching interface, and DB file cleanup helpers. Both
+ * ContentStore and SessionDB build on top of these primitives.
+ */
+import type DatabaseConstructor from "better-sqlite3";
+import type { Database as DatabaseInstance } from "better-sqlite3";
+/**
+ * Explicit interface for cached prepared statements that accept varying
+ * parameter counts. better-sqlite3's generic `Statement` collapses under
+ * `ReturnType` to a single-param signature, so we define our own.
+ */
+export interface PreparedStatement {
+    run(...params: unknown[]): {
+        changes: number;
+        lastInsertRowid: number | bigint;
+    };
+    get(...params: unknown[]): unknown;
+    all(...params: unknown[]): unknown[];
+    iterate(...params: unknown[]): IterableIterator<unknown>;
+}
+/**
+ * Lazy-load better-sqlite3. Only resolves the native module on first call.
+ * This allows the MCP server to start instantly even when the native addon
+ * is not yet installed (marketplace first-run scenario).
+ */
+export declare function loadDatabase(): typeof DatabaseConstructor;
+/**
+ * Apply WAL mode and NORMAL synchronous pragma to a database instance.
+ * Should be called immediately after opening a new database connection.
+ *
+ * WAL mode provides:
+ * - Concurrent readers while a write is in progress
+ * - Dramatically faster writes (no full-page sync on each commit)
+ * NORMAL synchronous is safe under WAL and avoids an extra fsync per
+ * transaction.
+ */
+export declare function applyWALPragmas(db: DatabaseInstance): void;
+/**
+ * Delete all three SQLite files for a given db path (main, WAL, SHM).
+ * Silently ignores individual deletion errors so a partial cleanup
+ * does not abort the rest.
+ */
+export declare function deleteDBFiles(dbPath: string): void;
+/**
+ * Safely close a database connection. Swallows errors so callers can
+ * always call this in a finally/cleanup path without try/catch.
+ */
+export declare function closeDB(db: DatabaseInstance): void;
+/**
+ * Return the default per-process DB path for context-mode databases.
+ * Uses the OS temp directory and embeds the current PID so multiple
+ * server instances never share a file.
+ */
+export declare function defaultDBPath(prefix?: string): string;
+/**
+ * SQLiteBase — minimal base class that handles open/close/cleanup lifecycle.
+ *
+ * Subclasses call `super(dbPath)` to open the database with WAL pragmas
+ * applied, then implement `initSchema()` and `prepareStatements()`.
+ *
+ * The `db` getter exposes the raw `DatabaseInstance` to subclasses only.
+ */
+export declare abstract class SQLiteBase {
+    #private;
+    constructor(dbPath: string);
+    /** Called once after WAL pragmas are applied. Subclasses run CREATE TABLE/VIRTUAL TABLE here. */
+    protected abstract initSchema(): void;
+    /** Called once after schema init. Subclasses compile and cache their prepared statements here. */
+    protected abstract prepareStatements(): void;
+    /** Raw database instance — available to subclasses only. */
+    protected get db(): DatabaseInstance;
+    /** The path this database was opened from. */
+    get dbPath(): string;
+    /** Close the database connection without deleting files. */
+    close(): void;
+    /**
+     * Close the connection and delete all associated DB files (main, WAL, SHM).
+     * Call on process exit or at end of session lifecycle.
+     */
+    cleanup(): void;
+}

package/build/db-base.js

@@ -0,0 +1,128 @@
+/**
+ * db-base — Reusable SQLite infrastructure for context-mode packages.
+ *
+ * Provides lazy-loading of better-sqlite3, WAL pragma setup, prepared
+ * statement caching interface, and DB file cleanup helpers. Both
+ * ContentStore and SessionDB build on top of these primitives.
+ */
+import { createRequire } from "node:module";
+import { unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+// ─────────────────────────────────────────────────────────
+// Lazy loader
+// ─────────────────────────────────────────────────────────
+let _Database = null;
+/**
+ * Lazy-load better-sqlite3. Only resolves the native module on first call.
+ * This allows the MCP server to start instantly even when the native addon
+ * is not yet installed (marketplace first-run scenario).
+ */
+export function loadDatabase() {
+    if (!_Database) {
+        const require = createRequire(import.meta.url);
+        _Database = require("better-sqlite3");
+    }
+    return _Database;
+}
+// ─────────────────────────────────────────────────────────
+// WAL setup
+// ─────────────────────────────────────────────────────────
+/**
+ * Apply WAL mode and NORMAL synchronous pragma to a database instance.
+ * Should be called immediately after opening a new database connection.
+ *
+ * WAL mode provides:
+ * - Concurrent readers while a write is in progress
+ * - Dramatically faster writes (no full-page sync on each commit)
+ * NORMAL synchronous is safe under WAL and avoids an extra fsync per
+ * transaction.
+ */
+export function applyWALPragmas(db) {
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
+}
+// ─────────────────────────────────────────────────────────
+// DB file helpers
+// ─────────────────────────────────────────────────────────
+/**
+ * Delete all three SQLite files for a given db path (main, WAL, SHM).
+ * Silently ignores individual deletion errors so a partial cleanup
+ * does not abort the rest.
+ */
+export function deleteDBFiles(dbPath) {
+    for (const suffix of ["", "-wal", "-shm"]) {
+        try {
+            unlinkSync(dbPath + suffix);
+        }
+        catch {
+            // ignore — file may not exist
+        }
+    }
+}
+/**
+ * Safely close a database connection. Swallows errors so callers can
+ * always call this in a finally/cleanup path without try/catch.
+ */
+export function closeDB(db) {
+    try {
+        db.close();
+    }
+    catch {
+        // ignore
+    }
+}
+// ─────────────────────────────────────────────────────────
+// Default path helper
+// ─────────────────────────────────────────────────────────
+/**
+ * Return the default per-process DB path for context-mode databases.
+ * Uses the OS temp directory and embeds the current PID so multiple
+ * server instances never share a file.
+ */
+export function defaultDBPath(prefix = "context-mode") {
+    return join(tmpdir(), `${prefix}-${process.pid}.db`);
+}
+// ─────────────────────────────────────────────────────────
+// Base class
+// ─────────────────────────────────────────────────────────
+/**
+ * SQLiteBase — minimal base class that handles open/close/cleanup lifecycle.
+ *
+ * Subclasses call `super(dbPath)` to open the database with WAL pragmas
+ * applied, then implement `initSchema()` and `prepareStatements()`.
+ *
+ * The `db` getter exposes the raw `DatabaseInstance` to subclasses only.
+ */
+export class SQLiteBase {
+    #dbPath;
+    #db;
+    constructor(dbPath) {
+        const Database = loadDatabase();
+        this.#dbPath = dbPath;
+        this.#db = new Database(dbPath, { timeout: 5000 });
+        applyWALPragmas(this.#db);
+        this.initSchema();
+        this.prepareStatements();
+    }
+    /** Raw database instance — available to subclasses only. */
+    get db() {
+        return this.#db;
+    }
+    /** The path this database was opened from. */
+    get dbPath() {
+        return this.#dbPath;
+    }
+    /** Close the database connection without deleting files. */
+    close() {
+        closeDB(this.#db);
+    }
+    /**
+     * Close the connection and delete all associated DB files (main, WAL, SHM).
+     * Call on process exit or at end of session lifecycle.
+     */
+    cleanup() {
+        closeDB(this.#db);
+        deleteDBFiles(this.#dbPath);
+    }
+}

package/build/executor.d.ts

@@ -1,14 +1,12 @@
 import { type RuntimeMap, type Language } from "./runtime.js";
-export interface ExecResult {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-    timedOut: boolean;
-}
+export type { ExecResult } from "./types.js";
+import type { ExecResult } from "./types.js";
 interface ExecuteOptions {
     language: Language;
     code: string;
     timeout?: number;
+    /** Keep process running after timeout instead of killing it. */
+    background?: boolean;
 }
 interface ExecuteFileOptions extends ExecuteOptions {
     path: string;
@@ -22,7 +20,8 @@ export declare class PolyglotExecutor {
         runtimes?: RuntimeMap;
     });
     get runtimes(): RuntimeMap;
+    /** Kill all backgrounded processes to prevent zombie/port-conflict issues. */
+    cleanupBackgrounded(): void;
     execute(opts: ExecuteOptions): Promise<ExecResult>;
     executeFile(opts: ExecuteFileOptions): Promise<ExecResult>;
 }
-export {};

package/build/executor.js

@@ -1,9 +1,9 @@
-var _a;
 import { spawn, execSync } from "node:child_process";
 import { mkdtempSync, writeFileSync, rmSync, existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { detectRuntimes, buildCommand, } from "./runtime.js";
+import { smartTruncate } from "./truncate.js";
 const isWin = process.platform === "win32";
 /** Kill process tree — on Windows, proc.kill() only kills the shell, not children. */
 function killTree(proc) {
@@ -22,6 +22,8 @@ export class PolyglotExecutor {
     #hardCapBytes;
     #projectRoot;
     #runtimes;
+    /** PIDs of backgrounded processes — killed on cleanup to prevent zombies. */
+    #backgroundedPids = new Set();
     constructor(opts) {
         this.#maxOutputBytes = opts?.maxOutputBytes ?? 102_400;
         this.#hardCapBytes = opts?.hardCapBytes ?? 100 * 1024 * 1024; // 100MB
@@ -31,8 +33,18 @@ export class PolyglotExecutor {
     get runtimes() {
         return { ...this.#runtimes };
     }
+    /** Kill all backgrounded processes to prevent zombie/port-conflict issues. */
+    cleanupBackgrounded() {
+        for (const pid of this.#backgroundedPids) {
+            try {
+                process.kill(pid, "SIGTERM");
+            }
+            catch { /* already dead */ }
+        }
+        this.#backgroundedPids.clear();
+    }
     async execute(opts) {
-        const { language, code, timeout = 30_000 } = opts;
+        const { language, code, timeout = 30_000, background = false } = opts;
         const tmpDir = mkdtempSync(join(tmpdir(), "ctx-mode-"));
         try {
             const filePath = this.#writeScript(tmpDir, code, language);
@@ -45,16 +57,22 @@ export class PolyglotExecutor {
             // and other project-aware tools work naturally. Non-shell languages
             // run in the temp directory where their script file is written.
             const cwd = language === "shell" ? this.#projectRoot : tmpDir;
-            return await this.#spawn(cmd, cwd, timeout);
+            const result = await this.#spawn(cmd, cwd, timeout, background);
+            // Skip tmpDir cleanup if process was backgrounded — it may still need files
+            if (!result.backgrounded) {
+                try {
+                    rmSync(tmpDir, { recursive: true, force: true });
+                }
+                catch { /* ignore */ }
+            }
+            return result;
         }
-        finally {
+        catch (err) {
             try {
                 rmSync(tmpDir, { recursive: true, force: true });
             }
-            catch {
-                // On Windows, bash may still hold file handles when rmSync runs.
-                // Ignore EPERM/EBUSY — the OS will clean up %TEMP% eventually.
-            }
+            catch { /* ignore */ }
+            throw err;
         }
     }
     async executeFile(opts) {
@@ -123,44 +141,7 @@ export class PolyglotExecutor {
         // Run
         return this.#spawn([binPath], cwd, timeout);
     }
-    /**
-     * Smart truncation: keeps head (60%) + tail (40%) of output,
-     * preserving both initial context and final error messages.
-     * Snaps to line boundaries and handles UTF-8 safely.
-     */
-    static #smartTruncate(raw, max) {
-        if (Buffer.byteLength(raw) <= max)
-            return raw;
-        const lines = raw.split("\n");
-        // Budget: 60% head, 40% tail (errors/results are usually at the end)
-        const headBudget = Math.floor(max * 0.6);
-        const tailBudget = max - headBudget;
-        // Collect head lines
-        const headLines = [];
-        let headBytes = 0;
-        for (const line of lines) {
-            const lineBytes = Buffer.byteLength(line) + 1; // +1 for \n
-            if (headBytes + lineBytes > headBudget)
-                break;
-            headLines.push(line);
-            headBytes += lineBytes;
-        }
-        // Collect tail lines (from end)
-        const tailLines = [];
-        let tailBytes = 0;
-        for (let i = lines.length - 1; i >= headLines.length; i--) {
-            const lineBytes = Buffer.byteLength(lines[i]) + 1;
-            if (tailBytes + lineBytes > tailBudget)
-                break;
-            tailLines.unshift(lines[i]);
-            tailBytes += lineBytes;
-        }
-        const skippedLines = lines.length - headLines.length - tailLines.length;
-        const skippedBytes = Buffer.byteLength(raw) - headBytes - tailBytes;
-        const separator = `\n\n... [${skippedLines} lines / ${(skippedBytes / 1024).toFixed(1)}KB truncated — showing first ${headLines.length} + last ${tailLines.length} lines] ...\n\n`;
-        return headLines.join("\n") + separator + tailLines.join("\n");
-    }
-    async #spawn(cmd, cwd, timeout) {
+    async #spawn(cmd, cwd, timeout, background = false) {
         return new Promise((res) => {
             // Only .cmd/.bat shims need shell on Windows; real executables don't.
             // Using shell: true globally causes process-tree kill issues with MSYS2/Git Bash.
@@ -186,9 +167,31 @@ export class PolyglotExecutor {
                 shell: needsShell,
             });
             let timedOut = false;
+            let resolved = false;
             const timer = setTimeout(() => {
                 timedOut = true;
-                killTree(proc);
+                if (background) {
+                    // Background mode: detach process, return partial output, keep running
+                    resolved = true;
+                    if (proc.pid)
+                        this.#backgroundedPids.add(proc.pid);
+                    proc.unref();
+                    proc.stdout.destroy();
+                    proc.stderr.destroy();
+                    const rawStdout = Buffer.concat(stdoutChunks).toString("utf-8");
+                    const rawStderr = Buffer.concat(stderrChunks).toString("utf-8");
+                    const max = this.#maxOutputBytes;
+                    res({
+                        stdout: smartTruncate(rawStdout, max),
+                        stderr: smartTruncate(rawStderr, max),
+                        exitCode: 0,
+                        timedOut: true,
+                        backgrounded: true,
+                    });
+                }
+                else {
+                    killTree(proc);
+                }
             }, timeout);
             // Stream-level byte cap: kill the process once combined stdout+stderr
             // exceeds hardCapBytes. Without this, a command like `yes` or
@@ -220,14 +223,16 @@ export class PolyglotExecutor {
             });
             proc.on("close", (exitCode) => {
                 clearTimeout(timer);
+                if (resolved)
+                    return; // Already resolved by background timeout
                 const rawStdout = Buffer.concat(stdoutChunks).toString("utf-8");
                 let rawStderr = Buffer.concat(stderrChunks).toString("utf-8");
                 if (capExceeded) {
                     rawStderr += `\n[output capped at ${(this.#hardCapBytes / 1024 / 1024).toFixed(0)}MB — process killed]`;
                 }
                 const max = this.#maxOutputBytes;
-                const stdout = _a.#smartTruncate(rawStdout, max);
-                const stderr = _a.#smartTruncate(rawStderr, max);
+                const stdout = smartTruncate(rawStdout, max);
+                const stderr = smartTruncate(rawStderr, max);
                 res({
                     stdout,
                     stderr,
@@ -237,6 +242,8 @@ export class PolyglotExecutor {
             });
             proc.on("error", (err) => {
                 clearTimeout(timer);
+                if (resolved)
+                    return; // Already resolved by background timeout
                 res({
                     stdout: "",
                     stderr: err.message,
@@ -286,6 +293,44 @@ export class PolyglotExecutor {
             // Claude Code's PTY ownership.
             "SSH_AUTH_SOCK",
             "SSH_AGENT_PID",
+            // Virtual environments (direnv, nix devshells, asdf, mise, etc.)
+            "DIRENV_DIR",
+            "DIRENV_FILE",
+            "DIRENV_DIFF",
+            "DIRENV_WATCHES",
+            "DIRENV_LAYOUT_DIR",
+            "NIX_PATH",
+            "NIX_PROFILES",
+            "NIX_SSL_CERT_FILE",
+            "NIX_CC",
+            "NIX_STORE",
+            "NIX_BUILD_CORES",
+            "IN_NIX_SHELL",
+            "LOCALE_ARCHIVE",
+            "LD_LIBRARY_PATH",
+            "DYLD_LIBRARY_PATH",
+            "LIBRARY_PATH",
+            "C_INCLUDE_PATH",
+            "CPLUS_INCLUDE_PATH",
+            "PKG_CONFIG_PATH",
+            "CMAKE_PREFIX_PATH",
+            "GOPATH",
+            "GOROOT",
+            "CARGO_HOME",
+            "RUSTUP_HOME",
+            "ASDF_DIR",
+            "ASDF_DATA_DIR",
+            "MISE_DATA_DIR",
+            "VIRTUAL_ENV",
+            "CONDA_PREFIX",
+            "CONDA_DEFAULT_ENV",
+            "PYTHONPATH",
+            "GEM_HOME",
+            "GEM_PATH",
+            "BUNDLE_PATH",
+            "RBENV_ROOT",
+            "JAVA_HOME",
+            "SDKMAN_DIR",
         ];
         const env = {
             PATH: process.env.PATH ?? (isWin ? "" : "/usr/local/bin:/usr/bin:/bin"),
@@ -302,7 +347,6 @@ export class PolyglotExecutor {
             const winVars = [
                 "SYSTEMROOT", "SystemRoot", "COMSPEC", "PATHEXT",
                 "USERPROFILE", "APPDATA", "LOCALAPPDATA", "TEMP", "TMP",
-                "GOROOT", "GOPATH",
             ];
             for (const key of winVars) {
                 if (process.env[key])
@@ -326,6 +370,23 @@ export class PolyglotExecutor {
                 env[key] = process.env[key];
             }
         }
+        // Ensure SSL_CERT_FILE is set so Python/Ruby HTTPS works in sandbox.
+        // On macOS, it's typically unset (Python uses its own bundle or none),
+        // causing urllib/requests to fail with SSL cert verification errors.
+        if (!env["SSL_CERT_FILE"]) {
+            const certPaths = isWin ? [] : [
+                "/etc/ssl/cert.pem", // macOS, some Linux
+                "/etc/ssl/certs/ca-certificates.crt", // Debian/Ubuntu/Alpine
+                "/etc/pki/tls/certs/ca-bundle.crt", // RHEL/CentOS/Fedora
+                "/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem", // Fedora alt
+            ];
+            for (const p of certPaths) {
+                if (existsSync(p)) {
+                    env["SSL_CERT_FILE"] = p;
+                    break;
+                }
+            }
+        }
         return env;
     }
     #wrapWithFileContent(absolutePath, language, code) {
@@ -358,4 +419,3 @@ export class PolyglotExecutor {
         }
     }
 }
-_a = PolyglotExecutor;

package/build/opencode-plugin.d.ts

@@ -0,0 +1,37 @@
+/**
+ * OpenCode TypeScript plugin entry point for context-mode.
+ *
+ * Provides three hooks:
+ *   - tool.execute.before  — Routing enforcement (deny/modify/passthrough)
+ *   - tool.execute.after   — Session event capture
+ *   - experimental.session.compacting — Compaction snapshot generation
+ *
+ * Loaded by OpenCode via: import("context-mode/plugin").ContextModePlugin(ctx)
+ *
+ * Constraints:
+ *   - No SessionStart hook (OpenCode doesn't support it — #14808, #5409)
+ *   - No context injection (canInjectSessionContext: false)
+ *   - Session cleanup happens at plugin init (no SessionStart)
+ */
+/** OpenCode plugin context passed to the factory function. */
+interface PluginContext {
+    directory: string;
+}
+/** Shape of the input object OpenCode passes to hook functions. */
+interface ToolHookInput {
+    tool_name?: string;
+    tool_input?: Record<string, unknown>;
+    tool_output?: string;
+    is_error?: boolean;
+    sessionID?: string;
+}
+/**
+ * OpenCode plugin factory. Called once when OpenCode loads the plugin.
+ * Returns an object mapping hook event names to async handler functions.
+ */
+export declare const ContextModePlugin: (ctx: PluginContext) => Promise<{
+    "tool.execute.before": (input: ToolHookInput) => Promise<void>;
+    "tool.execute.after": (input: ToolHookInput) => Promise<void>;
+    "experimental.session.compacting": () => Promise<string>;
+}>;
+export {};

package/build/opencode-plugin.js

@@ -0,0 +1,118 @@
+/**
+ * OpenCode TypeScript plugin entry point for context-mode.
+ *
+ * Provides three hooks:
+ *   - tool.execute.before  — Routing enforcement (deny/modify/passthrough)
+ *   - tool.execute.after   — Session event capture
+ *   - experimental.session.compacting — Compaction snapshot generation
+ *
+ * Loaded by OpenCode via: import("context-mode/plugin").ContextModePlugin(ctx)
+ *
+ * Constraints:
+ *   - No SessionStart hook (OpenCode doesn't support it — #14808, #5409)
+ *   - No context injection (canInjectSessionContext: false)
+ *   - Session cleanup happens at plugin init (no SessionStart)
+ */
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { SessionDB } from "./session/db.js";
+import { extractEvents } from "./session/extract.js";
+import { buildResumeSnapshot } from "./session/snapshot.js";
+// ── Helpers ───────────────────────────────────────────────
+function getSessionDir() {
+    const dir = join(homedir(), ".config", "opencode", "context-mode", "sessions");
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function getDBPath(projectDir) {
+    const hash = createHash("sha256")
+        .update(projectDir)
+        .digest("hex")
+        .slice(0, 16);
+    return join(getSessionDir(), `${hash}.db`);
+}
+// ── Plugin Factory ────────────────────────────────────────
+/**
+ * OpenCode plugin factory. Called once when OpenCode loads the plugin.
+ * Returns an object mapping hook event names to async handler functions.
+ */
+export const ContextModePlugin = async (ctx) => {
+    // Resolve build dir from compiled JS location
+    const buildDir = dirname(fileURLToPath(import.meta.url));
+    // Load routing module (ESM .mjs, lives outside build/ in hooks/)
+    const routingPath = resolve(buildDir, "..", "hooks", "core", "routing.mjs");
+    const routing = await import(pathToFileURL(routingPath).href);
+    await routing.initSecurity(buildDir);
+    // Initialize session
+    const projectDir = ctx.directory;
+    const db = new SessionDB({ dbPath: getDBPath(projectDir) });
+    const sessionId = randomUUID();
+    db.ensureSession(sessionId, projectDir);
+    // Clean up old sessions on startup (replaces SessionStart hook)
+    db.cleanupOldSessions(0);
+    return {
+        // ── PreToolUse: Routing enforcement ─────────────────
+        "tool.execute.before": async (input) => {
+            const toolName = input.tool_name ?? "";
+            const toolInput = input.tool_input ?? {};
+            let decision;
+            try {
+                decision = routing.routePreToolUse(toolName, toolInput, projectDir);
+            }
+            catch {
+                return; // Routing failure → allow passthrough
+            }
+            if (!decision)
+                return; // No routing match → passthrough
+            if (decision.action === "deny" || decision.action === "ask") {
+                // Throw to block — OpenCode catches this and denies the tool call
+                throw new Error(decision.reason ?? "Blocked by context-mode");
+            }
+            if (decision.action === "modify" && decision.updatedInput) {
+                // Mutate args in place — OpenCode reads the mutated input
+                Object.assign(toolInput, decision.updatedInput);
+            }
+            // "context" action → no-op (OpenCode doesn't support context injection)
+        },
+        // ── PostToolUse: Session event capture ──────────────
+        "tool.execute.after": async (input) => {
+            try {
+                const hookInput = {
+                    tool_name: input.tool_name ?? "",
+                    tool_input: input.tool_input ?? {},
+                    tool_response: input.tool_output,
+                    tool_output: input.is_error ? { isError: true } : undefined,
+                };
+                const events = extractEvents(hookInput);
+                for (const event of events) {
+                    // Cast: extract.ts SessionEvent lacks data_hash (computed by insertEvent)
+                    db.insertEvent(sessionId, event, "PostToolUse");
+                }
+            }
+            catch {
+                // Silent — session capture must never break the tool call
+            }
+        },
+        // ── PreCompact: Snapshot generation ─────────────────
+        "experimental.session.compacting": async () => {
+            try {
+                const events = db.getEvents(sessionId);
+                if (events.length === 0)
+                    return "";
+                const stats = db.getSessionStats(sessionId);
+                const snapshot = buildResumeSnapshot(events, {
+                    compactCount: (stats?.compact_count ?? 0) + 1,
+                });
+                db.upsertResume(sessionId, snapshot, events.length);
+                db.incrementCompactCount(sessionId);
+                return snapshot;
+            }
+            catch {
+                return "";
+            }
+        },
+    };
+};

package/build/runtime.js

@@ -52,7 +52,7 @@ function getVersion(cmd) {
             timeout: 5000,
         })
             .trim()
-            .split("\n")[0];
+            .split(/\r?\n/)[0];
     }
     catch {
         return "unknown";