context-mode 1.0.17 → 1.0.19

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Claude Code plugins by Mert Koseoğlu",
-    "version": "1.0.17"
+    "version": "1.0.19"
   },
   "plugins": [
     {
       "name": "context-mode",
       "source": "./",
       "description": "Claude Code MCP plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-      "version": "1.0.17",
+      "version": "1.0.19",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "MCP server that saves 98% of your context window with session continuity. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and automatic state restore across compactions.",
   "author": {
     "name": "Mert Koseoğlu",

package/build/db-base.js

@@ -65,6 +65,11 @@ export function deleteDBFiles(dbPath) {
  * always call this in a finally/cleanup path without try/catch.
  */
 export function closeDB(db) {
+    try {
+        // Checkpoint WAL before close to prevent contention on restart (#103)
+        db.pragma("wal_checkpoint(TRUNCATE)");
+    }
+    catch { /* WAL may not be active */ }
     try {
         db.close();
     }

package/build/delegate.d.ts

@@ -0,0 +1,48 @@
+/**
+ * ctx_delegate — Distributed analysis via `claude --print` sub-agents.
+ *
+ * Spawns parallel Claude CLI subprocesses with pre-read file contents
+ * embedded in prompts. Each sub-agent performs single-turn analysis and
+ * returns a compressed summary. Results are indexed into FTS5 for follow-up search.
+ *
+ * Zero dependencies — uses `claude --print` (installed with Claude Code).
+ */
+export interface DelegateTask {
+    /** Human-readable label for this sub-agent's work */
+    name: string;
+    /** What the sub-agent should do — the analysis prompt */
+    prompt: string;
+    /** File paths to pre-read and embed. Directories are read recursively (.ts files). */
+    files?: string[];
+}
+export interface DelegateOptions {
+    tasks: DelegateTask[];
+    /** Model to use for sub-agents. Default: claude-sonnet-4-6 */
+    model?: string;
+    /** Per-task timeout in ms. Default: 90_000 (90s) */
+    timeout?: number;
+    /** Max concurrent sub-agents. Default: CPU count, max: 10 */
+    concurrency?: number;
+}
+export interface DelegateTaskResult {
+    name: string;
+    summary: string;
+    durationMs: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    promptChars: number;
+    fileCount: number;
+    missingPaths: string[];
+    error?: string;
+}
+export interface DelegateResult {
+    results: DelegateTaskResult[];
+    wallTimeMs: number;
+    sequentialTimeMs: number;
+    speedup: number;
+    totalPromptTokens: number;
+    totalSummaryTokens: number;
+    compressionPct: number;
+}
+export declare function delegate(opts: DelegateOptions, projectRoot: string): Promise<DelegateResult>;

package/build/delegate.js

@@ -0,0 +1,265 @@
+/**
+ * ctx_delegate — Distributed analysis via `claude --print` sub-agents.
+ *
+ * Spawns parallel Claude CLI subprocesses with pre-read file contents
+ * embedded in prompts. Each sub-agent performs single-turn analysis and
+ * returns a compressed summary. Results are indexed into FTS5 for follow-up search.
+ *
+ * Zero dependencies — uses `claude --print` (installed with Claude Code).
+ */
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import { cpus } from "node:os";
+import { spawn } from "node:child_process";
+// ── File Reading ───────────────────────────────────────────────────────
+const CODE_EXTENSIONS = new Set([
+    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+    ".py", ".rb", ".go", ".rs", ".java", ".c", ".cpp", ".h",
+    ".php", ".pl", ".r", ".ex", ".exs", ".sh", ".bash", ".zsh",
+    ".css", ".scss", ".html", ".json", ".yaml", ".yml", ".toml",
+    ".md", ".txt", ".sql", ".graphql", ".proto",
+]);
+function isCodeFile(path) {
+    const dot = path.lastIndexOf(".");
+    if (dot === -1)
+        return false;
+    return CODE_EXTENSIONS.has(path.slice(dot).toLowerCase());
+}
+/**
+ * Read a file or directory, returning file contents keyed by relative path.
+ * Directories are read recursively for code files.
+ */
+function readFilesForTask(paths, projectRoot) {
+    const files = new Map();
+    const missingPaths = [];
+    for (const p of paths) {
+        const abs = p.startsWith("/") ? p : join(projectRoot, p);
+        try {
+            const stat = statSync(abs);
+            if (stat.isDirectory()) {
+                // Recursive directory read
+                const entries = readdirSync(abs, { recursive: true });
+                for (const entry of entries) {
+                    const entryAbs = join(abs, entry);
+                    try {
+                        if (!statSync(entryAbs).isFile())
+                            continue;
+                        if (!isCodeFile(entry))
+                            continue;
+                        const rel = relative(projectRoot, entryAbs);
+                        files.set(rel, readFileSync(entryAbs, "utf-8"));
+                    }
+                    catch { /* skip unreadable files */ }
+                }
+            }
+            else if (stat.isFile()) {
+                const rel = relative(projectRoot, abs);
+                files.set(rel, readFileSync(abs, "utf-8"));
+            }
+        }
+        catch {
+            missingPaths.push(p);
+        }
+    }
+    let content = "";
+    let totalChars = 0;
+    for (const [path, text] of files) {
+        content += `\n--- ${path} ---\n${text}\n`;
+        totalChars += text.length;
+    }
+    return { content, fileCount: files.size, totalChars, missingPaths };
+}
+// ── Sub-Agent Runner ───────────────────────────────────────────────────
+async function runSubAgent(task, projectRoot, model, timeout) {
+    // Pre-read files and embed in prompt
+    let fileContent = "";
+    let fileCount = 0;
+    let missingPaths = [];
+    if (task.files && task.files.length > 0) {
+        const read = readFilesForTask(task.files, projectRoot);
+        fileContent = read.content;
+        fileCount = read.fileCount;
+        missingPaths = read.missingPaths;
+        // Fail fast: if files were requested but NONE found, don't spawn sub-agent
+        if (fileCount === 0 && missingPaths.length > 0) {
+            return {
+                name: task.name,
+                summary: `ERROR: No files found. Missing paths: ${missingPaths.join(", ")}`,
+                durationMs: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                cacheReadTokens: 0,
+                promptChars: 0,
+                fileCount: 0,
+                missingPaths,
+                error: "FILES_NOT_FOUND",
+            };
+        }
+    }
+    const fullPrompt = fileContent
+        ? `${task.prompt}\n\n${fileContent}`
+        : task.prompt;
+    // Strip CLAUDECODE env to prevent recursion detection
+    const cleanEnv = { ...process.env };
+    delete cleanEnv.CLAUDECODE;
+    // Propagate depth guard
+    const currentDepth = parseInt(process.env.CTX_DELEGATE_DEPTH ?? "0", 10);
+    cleanEnv.CTX_DELEGATE_DEPTH = String(currentDepth + 1);
+    const startTime = Date.now();
+    // Spawn `claude --print` — single-turn, no tools, inherits OAuth session
+    const args = ["--print", "--model", model, "--max-turns", "1", fullPrompt];
+    return new Promise((resolve) => {
+        const child = spawn("claude", args, {
+            env: cleanEnv,
+            cwd: projectRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => { stdout += chunk.toString(); });
+        child.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
+        // Timeout guard
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            setTimeout(() => { if (!child.killed)
+                child.kill("SIGKILL"); }, 5000);
+        }, timeout);
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            const durationMs = Date.now() - startTime;
+            const summary = stdout.trim();
+            if (code !== 0 && !summary) {
+                resolve({
+                    name: task.name,
+                    summary: `ERROR: claude --print exited with code ${code}. ${stderr.trim().slice(0, 200)}`,
+                    durationMs,
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    cacheReadTokens: 0,
+                    promptChars: fullPrompt.length,
+                    fileCount,
+                    missingPaths,
+                    error: `EXIT_CODE_${code}`,
+                });
+                return;
+            }
+            resolve({
+                name: task.name,
+                summary: summary || "ERROR: Empty response from claude --print",
+                durationMs,
+                inputTokens: 0,
+                outputTokens: 0,
+                cacheReadTokens: 0,
+                promptChars: fullPrompt.length,
+                fileCount,
+                missingPaths,
+                error: summary ? undefined : "EMPTY_RESPONSE",
+            });
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            resolve({
+                name: task.name,
+                summary: `ERROR: Failed to spawn claude CLI: ${err.message}. Is Claude Code installed?`,
+                durationMs: Date.now() - startTime,
+                inputTokens: 0,
+                outputTokens: 0,
+                cacheReadTokens: 0,
+                promptChars: fullPrompt.length,
+                fileCount: 0,
+                missingPaths,
+                error: "SPAWN_FAILED",
+            });
+        });
+    });
+}
+// ── Concurrency Limiter ────────────────────────────────────────────────
+async function runWithConcurrency(tasks, projectRoot, model, timeout, limit) {
+    const results = [];
+    const queue = [...tasks];
+    const running = new Set();
+    while (queue.length > 0 || running.size > 0) {
+        while (running.size < limit && queue.length > 0) {
+            const task = queue.shift();
+            const p = runSubAgent(task, projectRoot, model, timeout).then((r) => {
+                results.push(r);
+                running.delete(p);
+            });
+            running.add(p);
+        }
+        if (running.size > 0)
+            await Promise.race(running);
+    }
+    return results;
+}
+// ── Public API ─────────────────────────────────────────────────────────
+const MAX_CONCURRENCY = 10;
+const MAX_TASKS = 20;
+const MAX_DEPTH = 1;
+const DEFAULT_TIMEOUT = 90_000;
+const DEFAULT_MODEL = "claude-sonnet-4-6";
+export async function delegate(opts, projectRoot) {
+    // Depth guard — prevent infinite delegation loops
+    const depth = parseInt(process.env.CTX_DELEGATE_DEPTH ?? "0", 10);
+    if (depth >= MAX_DEPTH) {
+        return {
+            results: [{
+                    name: "depth-guard",
+                    summary: "ERROR: Delegation depth limit reached. Sub-agents cannot delegate further.",
+                    durationMs: 0,
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    cacheReadTokens: 0,
+                    promptChars: 0,
+                    fileCount: 0,
+                    missingPaths: [],
+                    error: "DEPTH_LIMIT",
+                }],
+            wallTimeMs: 0,
+            sequentialTimeMs: 0,
+            speedup: 0,
+            totalPromptTokens: 0,
+            totalSummaryTokens: 0,
+            compressionPct: 0,
+        };
+    }
+    // Validate tasks
+    const tasks = opts.tasks.slice(0, MAX_TASKS);
+    if (tasks.length === 0) {
+        return {
+            results: [],
+            wallTimeMs: 0,
+            sequentialTimeMs: 0,
+            speedup: 0,
+            totalPromptTokens: 0,
+            totalSummaryTokens: 0,
+            compressionPct: 0,
+        };
+    }
+    const model = opts.model ?? DEFAULT_MODEL;
+    const timeout = Math.min(opts.timeout ?? DEFAULT_TIMEOUT, 300_000);
+    const concurrency = Math.min(opts.concurrency ?? cpus().length, MAX_CONCURRENCY);
+    const wallStart = Date.now();
+    const results = await runWithConcurrency(tasks, projectRoot, model, timeout, concurrency);
+    const wallTimeMs = Date.now() - wallStart;
+    // Reorder results to match input task order
+    const ordered = tasks.map((t) => results.find((r) => r.name === t.name) ?? results[0]);
+    // Compute metrics
+    const sequentialTimeMs = ordered.reduce((s, r) => s + r.durationMs, 0);
+    const totalPromptChars = ordered.reduce((s, r) => s + r.promptChars, 0);
+    const totalSummaryChars = ordered.reduce((s, r) => s + r.summary.length, 0);
+    const totalPromptTokens = Math.ceil(totalPromptChars / 4);
+    const totalSummaryTokens = Math.ceil(totalSummaryChars / 4);
+    const compressionPct = totalPromptTokens > 0
+        ? (1 - totalSummaryTokens / totalPromptTokens) * 100
+        : 0;
+    return {
+        results: ordered,
+        wallTimeMs,
+        sequentialTimeMs,
+        speedup: wallTimeMs > 0 ? sequentialTimeMs / wallTimeMs : 0,
+        totalPromptTokens,
+        totalSummaryTokens,
+        compressionPct,
+    };
+}

package/build/executor.js

@@ -5,7 +5,7 @@ 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. */
+/** Kill process tree — on Windows uses taskkill /T; on Unix kills the process group. */
 function killTree(proc) {
     if (isWin && proc.pid) {
         try {
@@ -13,8 +13,12 @@ function killTree(proc) {
         }
         catch { /* already dead */ }
     }
-    else {
-        proc.kill("SIGKILL");
+    else if (proc.pid) {
+        try {
+            // Kill entire process group (negative PID) to prevent orphaned children
+            process.kill(-proc.pid, "SIGKILL");
+        }
+        catch { /* already dead */ }
     }
 }
 export class PolyglotExecutor {
@@ -37,7 +41,8 @@ export class PolyglotExecutor {
     cleanupBackgrounded() {
         for (const pid of this.#backgroundedPids) {
             try {
-                process.kill(pid, "SIGTERM");
+                // Kill process group on Unix to catch all children
+                process.kill(isWin ? pid : -pid, "SIGTERM");
             }
             catch { /* already dead */ }
         }
@@ -165,6 +170,8 @@ export class PolyglotExecutor {
                 stdio: ["ignore", "pipe", "pipe"],
                 env: this.#buildSafeEnv(cwd),
                 shell: needsShell,
+                // On Unix, create a new process group so killTree can kill all children
+                detached: !isWin,
             });
             let timedOut = false;
             let resolved = false;
@@ -396,28 +403,28 @@ export class PolyglotExecutor {
         switch (language) {
             case "javascript":
             case "typescript":
-                return `const FILE_CONTENT_PATH = ${escaped};\nconst FILE_CONTENT = require("fs").readFileSync(FILE_CONTENT_PATH, "utf-8");\n${code}`;
+                return `const FILE_CONTENT_PATH = ${escaped};\nconst file_path = FILE_CONTENT_PATH;\nconst FILE_CONTENT = require("fs").readFileSync(FILE_CONTENT_PATH, "utf-8");\n${code}`;
             case "python":
-                return `FILE_CONTENT_PATH = ${escaped}\nwith open(FILE_CONTENT_PATH, "r", encoding="utf-8") as _f:\n    FILE_CONTENT = _f.read()\n${code}`;
+                return `FILE_CONTENT_PATH = ${escaped}\nfile_path = FILE_CONTENT_PATH\nwith open(FILE_CONTENT_PATH, "r", encoding="utf-8") as _f:\n    FILE_CONTENT = _f.read()\n${code}`;
             case "shell": {
                 // Single-quote the path to prevent $, backtick, and ! expansion
                 const sq = "'" + absolutePath.replace(/'/g, "'\\''") + "'";
-                return `FILE_CONTENT_PATH=${sq}\nFILE_CONTENT=$(cat ${sq})\n${code}`;
+                return `FILE_CONTENT_PATH=${sq}\nfile_path=${sq}\nFILE_CONTENT=$(cat ${sq})\n${code}`;
             }
             case "ruby":
-                return `FILE_CONTENT_PATH = ${escaped}\nFILE_CONTENT = File.read(FILE_CONTENT_PATH, encoding: "utf-8")\n${code}`;
+                return `FILE_CONTENT_PATH = ${escaped}\nfile_path = FILE_CONTENT_PATH\nFILE_CONTENT = File.read(FILE_CONTENT_PATH, encoding: "utf-8")\n${code}`;
             case "go":
-                return `package main\n\nimport (\n\t"fmt"\n\t"os"\n)\n\nvar FILE_CONTENT_PATH = ${escaped}\n\nfunc main() {\n\tb, _ := os.ReadFile(FILE_CONTENT_PATH)\n\tFILE_CONTENT := string(b)\n\t_ = FILE_CONTENT\n\t_ = fmt.Sprint()\n${code}\n}\n`;
+                return `package main\n\nimport (\n\t"fmt"\n\t"os"\n)\n\nvar FILE_CONTENT_PATH = ${escaped}\nvar file_path = FILE_CONTENT_PATH\n\nfunc main() {\n\tb, _ := os.ReadFile(FILE_CONTENT_PATH)\n\tFILE_CONTENT := string(b)\n\t_ = FILE_CONTENT\n\t_ = fmt.Sprint()\n${code}\n}\n`;
             case "rust":
-                return `use std::fs;\n\nfn main() {\n    let file_content_path = ${escaped};\n    let file_content = fs::read_to_string(file_content_path).unwrap();\n${code}\n}\n`;
+                return `use std::fs;\n\nfn main() {\n    let file_content_path = ${escaped};\n    let file_path = file_content_path;\n    let file_content = fs::read_to_string(file_content_path).unwrap();\n${code}\n}\n`;
             case "php":
-                return `<?php\n$FILE_CONTENT_PATH = ${escaped};\n$FILE_CONTENT = file_get_contents($FILE_CONTENT_PATH);\n${code}`;
+                return `<?php\n$FILE_CONTENT_PATH = ${escaped};\n$file_path = $FILE_CONTENT_PATH;\n$FILE_CONTENT = file_get_contents($FILE_CONTENT_PATH);\n${code}`;
             case "perl":
-                return `my $FILE_CONTENT_PATH = ${escaped};\nopen(my $fh, '<:encoding(UTF-8)', $FILE_CONTENT_PATH) or die "Cannot open: $!";\nmy $FILE_CONTENT = do { local $/; <$fh> };\nclose($fh);\n${code}`;
+                return `my $FILE_CONTENT_PATH = ${escaped};\nmy $file_path = $FILE_CONTENT_PATH;\nopen(my $fh, '<:encoding(UTF-8)', $FILE_CONTENT_PATH) or die "Cannot open: $!";\nmy $FILE_CONTENT = do { local $/; <$fh> };\nclose($fh);\n${code}`;
             case "r":
-                return `FILE_CONTENT_PATH <- ${escaped}\nFILE_CONTENT <- readLines(FILE_CONTENT_PATH, warn=FALSE, encoding="UTF-8")\nFILE_CONTENT <- paste(FILE_CONTENT, collapse="\\n")\n${code}`;
+                return `FILE_CONTENT_PATH <- ${escaped}\nfile_path <- FILE_CONTENT_PATH\nFILE_CONTENT <- readLines(FILE_CONTENT_PATH, warn=FALSE, encoding="UTF-8")\nFILE_CONTENT <- paste(FILE_CONTENT, collapse="\\n")\n${code}`;
             case "elixir":
-                return `file_content_path = ${escaped}\nfile_content = File.read!(file_content_path)\n${code}`;
+                return `file_content_path = ${escaped}\nfile_path = file_content_path\nfile_content = File.read!(file_content_path)\n${code}`;
         }
     }
 }

package/build/lifecycle.d.ts

@@ -0,0 +1,21 @@
+/**
+ * lifecycle — Process lifecycle guard for MCP server.
+ *
+ * Detects parent process death, stdin close, and OS signals to prevent
+ * orphaned MCP server processes consuming 100% CPU (issue #103).
+ *
+ * Cross-platform: macOS, Linux, Windows.
+ */
+export interface LifecycleGuardOptions {
+    /** Interval in ms to check parent liveness. Default: 30_000 */
+    checkIntervalMs?: number;
+    /** Called when parent death or stdin close is detected. */
+    onShutdown: () => void;
+    /** Injectable parent-alive check (for testing). Default: ppid-based check. */
+    isParentAlive?: () => boolean;
+}
+/**
+ * Start the lifecycle guard. Returns a cleanup function.
+ * Skipped automatically when stdin is a TTY (e.g. OpenCode ts-plugin).
+ */
+export declare function startLifecycleGuard(opts: LifecycleGuardOptions): () => void;

package/build/lifecycle.js

@@ -0,0 +1,68 @@
+/**
+ * lifecycle — Process lifecycle guard for MCP server.
+ *
+ * Detects parent process death, stdin close, and OS signals to prevent
+ * orphaned MCP server processes consuming 100% CPU (issue #103).
+ *
+ * Cross-platform: macOS, Linux, Windows.
+ */
+/**
+ * Default parent liveness check.
+ * Compares current ppid against the original — if it changed (reparented to
+ * init/launchd/systemd), parent is dead. This is more reliable than
+ * kill(ppid, 0) which succeeds for PID 1 on all platforms.
+ *
+ * On Windows, ppid becomes 0 when parent exits.
+ */
+const originalPpid = process.ppid;
+function defaultIsParentAlive() {
+    const ppid = process.ppid;
+    if (ppid !== originalPpid)
+        return false;
+    if (ppid === 0 || ppid === 1)
+        return false;
+    return true;
+}
+/**
+ * Start the lifecycle guard. Returns a cleanup function.
+ * Skipped automatically when stdin is a TTY (e.g. OpenCode ts-plugin).
+ */
+export function startLifecycleGuard(opts) {
+    const interval = opts.checkIntervalMs ?? 30_000;
+    const check = opts.isParentAlive ?? defaultIsParentAlive;
+    let stopped = false;
+    const shutdown = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        opts.onShutdown();
+    };
+    // P0: Periodic parent liveness check
+    const timer = setInterval(() => {
+        if (!check())
+            shutdown();
+    }, interval);
+    timer.unref();
+    // P0: Stdin close — parent pipe broken
+    // Must resume stdin to receive close/end events (Node starts paused)
+    const onStdinClose = () => shutdown();
+    process.stdin.resume();
+    process.stdin.on("end", onStdinClose);
+    process.stdin.on("close", onStdinClose);
+    process.stdin.on("error", onStdinClose);
+    // P0: OS signals — terminal close, kill, ctrl+c
+    const signals = ["SIGTERM", "SIGINT"];
+    if (process.platform !== "win32")
+        signals.push("SIGHUP");
+    for (const sig of signals)
+        process.on(sig, shutdown);
+    return () => {
+        stopped = true;
+        clearInterval(timer);
+        process.stdin.removeListener("end", onStdinClose);
+        process.stdin.removeListener("close", onStdinClose);
+        process.stdin.removeListener("error", onStdinClose);
+        for (const sig of signals)
+            process.removeListener(sig, shutdown);
+    };
+}

package/build/server.js

@@ -13,7 +13,8 @@ import { ContentStore, cleanupStaleDBs } from "./store.js";
 import { readBashPolicies, evaluateCommandDenyOnly, extractShellCommands, readToolDenyPatterns, evaluateFilePath, } from "./security.js";
 import { detectRuntimes, getRuntimeSummary, getAvailableLanguages, hasBunRuntime, } from "./runtime.js";
 import { classifyNonZeroExit } from "./exit-classify.js";
-const VERSION = "1.0.17";
+import { startLifecycleGuard } from "./lifecycle.js";
+const VERSION = "1.0.19";
 // Prevent silent server death from unhandled async errors
 process.on("unhandledRejection", (err) => {
     process.stderr.write(`[context-mode] unhandledRejection: ${err}\n`);
@@ -1462,6 +1463,8 @@ async function main() {
     process.on("exit", shutdown);
     process.on("SIGINT", () => { gracefulShutdown(); });
     process.on("SIGTERM", () => { gracefulShutdown(); });
+    // Lifecycle guard: detect parent death + stdin close to prevent orphaned processes (#103)
+    startLifecycleGuard({ onShutdown: () => gracefulShutdown() });
     const transport = new StdioServerTransport();
     await server.connect(transport);
     // Write routing instructions for hookless platforms (e.g. Codex CLI)

package/build/session/db.js

@@ -7,8 +7,6 @@
  */
 import { SQLiteBase, defaultDBPath } from "../db-base.js";
 import { createHash } from "node:crypto";
-import { execSync } from "node:child_process";
-import { cloudPostEvent } from "../sync/cloud-post.js";
 // ─────────────────────────────────────────────────────────
 // Constants
 // ─────────────────────────────────────────────────────────
@@ -190,25 +188,6 @@ export class SessionDB extends SQLiteBase {
             this.stmt(S.updateMetaLastEvent).run(sessionId);
         });
         transaction();
-        // Fire-and-forget: POST event directly to cloud (works in short-lived hook processes)
-        try {
-            const projectDir = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
-            let gitRemote;
-            try {
-                gitRemote = execSync("git remote get-url origin", { cwd: projectDir, timeout: 2000 })
-                    .toString().trim() || undefined;
-            }
-            catch { /* no git remote available */ }
-            cloudPostEvent({
-                type: event.type,
-                category: event.category,
-                priority: event.priority,
-                data: event.data,
-                source_hook: sourceHook,
-                created_at: new Date().toISOString(),
-            }, projectDir, sessionId, gitRemote);
-        }
-        catch { /* cloud sync must never break local event storage */ }
     }
     /**
      * Retrieve events for a session with optional filtering.