context-mode 1.0.21 → 1.0.23

package/build/openclaw-plugin.js

@@ -0,0 +1,525 @@
+/**
+ * OpenClaw TypeScript plugin entry point for context-mode.
+ *
+ * Exports an object with { id, name, configSchema, register(api) } for
+ * declarative metadata and config validation before code execution.
+ *
+ * register(api) registers:
+ *   - before_tool_call hook   — Routing enforcement (deny/modify/passthrough)
+ *   - after_tool_call hook    — Session event capture
+ *   - command:new hook         — Session initialization and cleanup
+ *   - session_start hook             — Re-key DB session to OpenClaw's session ID
+ *   - before_compaction hook         — Flush events to resume snapshot
+ *   - after_compaction hook          — Increment compact count
+ *   - before_prompt_build (p=10)  — Resume snapshot injection into system context
+ *   - before_prompt_build (p=5)   — Routing instruction injection into system context
+ *   - context-mode engine      — Context engine with compaction management
+ *   - /ctx-stats command       — Auto-reply command for session statistics
+ *   - /ctx-doctor command      — Auto-reply command for diagnostics
+ *   - /ctx-upgrade command     — Auto-reply command for upgrade
+ *
+ * Loaded by OpenClaw via: openclaw.extensions entry in package.json
+ *
+ * OpenClaw plugin paradigm:
+ *   - Plugins export { id, name, configSchema, register(api) } for metadata
+ *   - api.registerHook() for event-driven hooks
+ *   - api.on() for typed lifecycle hooks
+ *   - api.registerContextEngine() for compaction ownership
+ *   - api.registerCommand() for auto-reply slash commands
+ *   - Plugins run in-process with the Gateway (trusted code)
+ */
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { OpenClawSessionDB } from "./adapters/openclaw/session-db.js";
+import { extractEvents, extractUserEvents } from "./session/extract.js";
+import { buildResumeSnapshot } from "./session/snapshot.js";
+import { OpenClawAdapter } from "./adapters/openclaw/index.js";
+import { WorkspaceRouter } from "./openclaw/workspace-router.js";
+/** Plugin config schema for OpenClaw validation. */
+const configSchema = {
+    type: "object",
+    properties: {
+        enabled: {
+            type: "boolean",
+            default: true,
+            description: "Enable or disable the context-mode plugin.",
+        },
+    },
+    additionalProperties: false,
+};
+// ── Helpers ───────────────────────────────────────────────
+function getSessionDir() {
+    const dir = join(homedir(), ".openclaw", "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`);
+}
+// ── Module-level DB singleton ─────────────────────────────
+// Shared across all register() calls (one per agent session).
+// Lazy-initialized on first register() using the first projectDir seen.
+// Uses OpenClawSessionDB for session_key mapping and rename support.
+let _dbSingleton = null;
+function getOrCreateDB(projectDir) {
+    if (!_dbSingleton) {
+        const dbPath = getDBPath(projectDir);
+        _dbSingleton = new OpenClawSessionDB({ dbPath });
+        _dbSingleton.cleanupOldSessions(7);
+    }
+    return _dbSingleton;
+}
+// ── Module-level state for command handlers ───────────────
+// Commands are re-registered on each register() call (OpenClaw's registerCommand
+// is idempotent). These refs give handlers access to the current session's state.
+let _latestDb = null;
+let _latestSessionId = "";
+let _latestPluginRoot = "";
+// ── Plugin Definition (object export) ─────────────────────
+/**
+ * OpenClaw plugin definition. The object form provides declarative metadata
+ * (id, name, configSchema) that OpenClaw can read without executing code.
+ * register() is called once per agent session with a fresh api object.
+ * Each call creates isolated closures (db, sessionId, hooks) — no shared state.
+ */
+export default {
+    id: "context-mode",
+    name: "Context Mode",
+    configSchema,
+    // OpenClaw calls register() synchronously — returning a Promise causes hooks
+    // to be silently ignored. Async init runs eagerly; hooks await it on first use.
+    register(api) {
+        // Resolve build dir from compiled JS location
+        const buildDir = dirname(fileURLToPath(import.meta.url));
+        const projectDir = process.env.OPENCLAW_PROJECT_DIR || process.cwd();
+        const pluginRoot = resolve(buildDir, "..");
+        // Structured logger — wraps api.logger, falls back to no-op.
+        // info/error always emit; debug only when api.logger.debug is present
+        // (i.e. OpenClaw running with --log-level debug or lower).
+        const log = {
+            info: (...args) => api.logger?.info("[context-mode]", ...args),
+            error: (...args) => api.logger?.error("[context-mode]", ...args),
+            debug: (...args) => api.logger?.debug?.("[context-mode]", ...args),
+            warn: (...args) => api.logger?.warn?.("[context-mode]", ...args),
+        };
+        // Get shared DB singleton (lazy-init on first register() call)
+        const db = getOrCreateDB(projectDir);
+        // Start with temp UUID — session_start will assign the real ID + sessionKey
+        let sessionId = randomUUID();
+        log.info("register() called, sessionId:", sessionId.slice(0, 8));
+        let resumeInjected = false;
+        let sessionKey;
+        // Create temp session so after_tool_call events before session_start have a valid row
+        db.ensureSession(sessionId, projectDir);
+        const workspaceRouter = new WorkspaceRouter();
+        // Load routing instructions synchronously for prompt injection
+        let routingInstructions = "";
+        try {
+            const instructionsPath = resolve(buildDir, "..", "configs", "openclaw", "AGENTS.md");
+            if (existsSync(instructionsPath)) {
+                routingInstructions = readFileSync(instructionsPath, "utf-8");
+            }
+        }
+        catch {
+            // best effort
+        }
+        // Async init: load routing module + write AGENTS.md. Hooks await this.
+        const initPromise = (async () => {
+            const routingPath = resolve(buildDir, "..", "hooks", "core", "routing.mjs");
+            const routing = await import(pathToFileURL(routingPath).href);
+            await routing.initSecurity(buildDir);
+            try {
+                new OpenClawAdapter().writeRoutingInstructions(projectDir, pluginRoot);
+            }
+            catch {
+                // best effort — never break plugin init
+            }
+            return { routing };
+        })();
+        // ── 1. tool_call:before — Routing enforcement ──────────
+        // NOTE: api.on() was broken in OpenClaw ≤2026.1.29 (fixed in PR #9761, issue #5513).
+        // api.on() is the correct API for typed lifecycle hooks (session_start, before_tool_call, etc.).
+        // api.registerHook() is for generic/command hooks (command:new, command:reset, command:stop).
+        api.on("before_tool_call", async (event) => {
+            const { routing } = await initPromise;
+            const e = event;
+            const toolName = e.toolName ?? "";
+            const toolInput = e.params ?? {};
+            let decision;
+            try {
+                decision = routing.routePreToolUse(toolName, toolInput, projectDir);
+            }
+            catch {
+                return; // Routing failure → allow passthrough
+            }
+            if (!decision)
+                return; // No routing match → passthrough
+            log.debug("before_tool_call", { tool: toolName, action: decision.action });
+            if (decision.action === "deny" || decision.action === "ask") {
+                return {
+                    block: true,
+                    blockReason: decision.reason ?? "Blocked by context-mode",
+                };
+            }
+            if (decision.action === "modify" && decision.updatedInput) {
+                // In-place mutation — OpenClaw reads the mutated params object.
+                Object.assign(toolInput, decision.updatedInput);
+            }
+            // "context" action → handled by before_prompt_build, not inline
+        });
+        // ── 2. after_tool_call — Session event capture ─────────
+        // Map OpenClaw tool names → Claude Code equivalents so extractEvents
+        // can recognize them. OpenClaw uses lowercase names; CC uses PascalCase.
+        const OPENCLAW_TOOL_MAP = {
+            exec: "Bash",
+            read: "Read",
+            write: "Write",
+            edit: "Edit",
+            apply_patch: "Edit",
+            glob: "Glob",
+            grep: "Grep",
+            search: "Grep",
+        };
+        api.on("after_tool_call", async (event) => {
+            try {
+                const e = event;
+                const rawToolName = e.toolName ?? "";
+                const mappedToolName = OPENCLAW_TOOL_MAP[rawToolName] ?? rawToolName;
+                // Accept both result (v2+) and output (older builds)
+                const rawResult = e.result ?? e.output;
+                const resultStr = typeof rawResult === "string"
+                    ? rawResult
+                    : rawResult != null
+                        ? JSON.stringify(rawResult)
+                        : undefined;
+                // Accept both error (string, v2+) and isError (boolean, older builds)
+                const hasError = Boolean(e.error || e.isError);
+                const hookInput = {
+                    tool_name: mappedToolName,
+                    tool_input: e.params ?? {},
+                    tool_response: resultStr,
+                    tool_output: hasError ? { isError: true } : undefined,
+                };
+                const events = extractEvents(hookInput);
+                // Resolve agent-specific sessionId from workspace paths in params
+                const routedSessionId = workspaceRouter.resolveSessionId(e.params ?? {}) ?? sessionId;
+                if (events.length > 0) {
+                    for (const ev of events) {
+                        db.insertEvent(routedSessionId, ev, "PostToolUse");
+                    }
+                    log.debug("after_tool_call", { tool: rawToolName, mapped: mappedToolName, sessionId: routedSessionId.slice(0, 8), events: events.length, durationMs: e.durationMs });
+                }
+                else if (rawToolName) {
+                    // Fallback: record any unrecognized tool call as a generic event
+                    const data = JSON.stringify({
+                        tool: rawToolName,
+                        params: e.params,
+                        durationMs: e.durationMs,
+                    });
+                    db.insertEvent(routedSessionId, {
+                        type: "tool_call",
+                        category: "openclaw",
+                        data,
+                        priority: 1,
+                        data_hash: createHash("sha256")
+                            .update(data)
+                            .digest("hex")
+                            .slice(0, 16),
+                    }, "PostToolUse");
+                    log.debug("after_tool_call", { tool: rawToolName, mapped: rawToolName, sessionId: routedSessionId.slice(0, 8), events: 1, durationMs: e.durationMs });
+                }
+            }
+            catch {
+                // Silent — session capture must never break the tool call
+            }
+        });
+        // ── 3. command:new — Session initialization ────────────
+        api.registerHook("command:new", async () => {
+            try {
+                log.debug("command:new", { sessionId: sessionId.slice(0, 8) });
+                db.cleanupOldSessions(7);
+            }
+            catch {
+                // best effort
+            }
+        }, {
+            name: "context-mode.session-new",
+            description: "Session initialization — cleans up old sessions on /new command",
+        });
+        // ── 3b. command:reset / command:stop — Session cleanup ────
+        api.registerHook("command:reset", async () => {
+            try {
+                log.debug("command:reset", { sessionId: sessionId.slice(0, 8) });
+                db.cleanupOldSessions(7);
+            }
+            catch {
+                // best effort
+            }
+        }, {
+            name: "context-mode.session-reset",
+            description: "Session cleanup on /reset command",
+        });
+        api.registerHook("command:stop", async () => {
+            try {
+                log.debug("command:stop", { sessionId: sessionId.slice(0, 8), sessionKey });
+                if (sessionKey) {
+                    workspaceRouter.removeSession(sessionKey);
+                }
+                db.cleanupOldSessions(7);
+            }
+            catch {
+                // best effort
+            }
+        }, {
+            name: "context-mode.session-stop",
+            description: "Session cleanup on /stop command",
+        });
+        // ── 4. session_start — Re-key DB session to OpenClaw's session ID ─
+        api.on("session_start", async (event) => {
+            try {
+                const e = event;
+                const sid = e?.sessionId;
+                if (!sid)
+                    return;
+                const key = e?.sessionKey;
+                const resumedFrom = e?.resumedFrom;
+                log.debug("session_start", { sessionId: sid.slice(0, 8), sessionKey: key, resumedFrom });
+                if (key) {
+                    // Per-agent session lookup via sessionKey
+                    const prevId = db.getMostRecentSession(key);
+                    if (prevId && prevId !== sid) {
+                        db.renameSession(prevId, sid);
+                        log.info(`session re-keyed ${prevId.slice(0, 8)}… → ${sid.slice(0, 8)}… (key=${key})`);
+                    }
+                    else if (!prevId) {
+                        db.ensureSessionWithKey(sid, projectDir, key);
+                        log.info(`new session ${sid.slice(0, 8)}… (key=${key})`);
+                    }
+                }
+                else {
+                    // Fallback: no sessionKey → fresh session (Option A)
+                    db.ensureSession(sid, projectDir);
+                    log.info(`session ${sid.slice(0, 8)}… (no sessionKey — fallback)`);
+                }
+                sessionId = sid;
+                _latestSessionId = sessionId;
+                sessionKey = key;
+                if (key) {
+                    workspaceRouter.registerSession(key, sessionId);
+                }
+                resumeInjected = false;
+            }
+            catch {
+                // best effort — never break session start
+            }
+        });
+        // ── 5. before_compaction — Flush events to snapshot before compaction ─
+        // NOTE: OpenClaw compaction hooks were broken until #4967/#3728 fix.
+        // Adapter gracefully degrades — session recovery falls back to DB snapshot
+        // reconstruction when compaction events don't fire.
+        api.on("before_compaction", async () => {
+            try {
+                const sid = sessionId; // snapshot to avoid race with concurrent session_start
+                const allEvents = db.getEvents(sid);
+                log.debug("before_compaction", { sessionId: sid.slice(0, 8), events: allEvents.length });
+                if (allEvents.length === 0)
+                    return;
+                const freshStats = db.getSessionStats(sid);
+                const snapshot = buildResumeSnapshot(allEvents, {
+                    compactCount: (freshStats?.compact_count ?? 0) + 1,
+                });
+                db.upsertResume(sid, snapshot, allEvents.length);
+            }
+            catch {
+                // best effort — never break compaction
+            }
+        });
+        // ── 6. after_compaction — Increment compact count ─────
+        api.on("after_compaction", async () => {
+            try {
+                const sid = sessionId;
+                log.debug("after_compaction", { sessionId: sid.slice(0, 8) });
+                db.incrementCompactCount(sid); // sessionId consistent with before_compaction within same sync cycle
+            }
+            catch {
+                // best effort
+            }
+        });
+        // ── 7. before_model_resolve — User message capture ────────
+        api.on("before_model_resolve", async (event) => {
+            try {
+                const sid = sessionId; // snapshot to avoid race with concurrent session_start
+                const e = event;
+                const messageText = e?.userMessage ?? e?.message ?? e?.content ?? "";
+                log.debug("before_model_resolve", { hasMessage: !!messageText });
+                if (!messageText)
+                    return;
+                const events = extractUserEvents(messageText);
+                for (const ev of events) {
+                    db.insertEvent(sid, ev, "PostToolUse");
+                }
+            }
+            catch {
+                // best effort — never break model resolution
+            }
+        });
+        // ── 8. before_prompt_build — Resume snapshot injection ────
+        api.on("before_prompt_build", () => {
+            try {
+                const sid = sessionId; // snapshot to avoid race with concurrent session_start
+                const resume = db.getResume(sid);
+                log.debug("before_prompt_build[resume]", { sessionId: sid.slice(0, 8), hasResume: !!resume, injected: !resumeInjected });
+                if (resumeInjected)
+                    return undefined;
+                if (!resume)
+                    return undefined;
+                const freshStats = db.getSessionStats(sid);
+                if ((freshStats?.compact_count ?? 0) === 0)
+                    return undefined;
+                resumeInjected = true;
+                return { prependSystemContext: resume.snapshot };
+            }
+            catch {
+                return undefined;
+            }
+        }, { priority: 10 });
+        // ── 8. before_prompt_build — Routing instruction injection ──
+        if (routingInstructions) {
+            api.on("before_prompt_build", () => {
+                log.debug("before_prompt_build[routing]", { hasInstructions: !!routingInstructions });
+                return { appendSystemContext: routingInstructions };
+            }, { priority: 5 });
+        }
+        // ── 9. Context engine — Compaction management ──────────
+        api.registerContextEngine("context-mode", () => ({
+            info: {
+                id: "context-mode",
+                name: "Context Mode",
+                ownsCompaction: true,
+            },
+            async ingest() {
+                return { ingested: true };
+            },
+            async assemble({ messages }) {
+                return { messages, estimatedTokens: 0 };
+            },
+            async compact({ currentTokenCount } = {}) {
+                try {
+                    const sid = sessionId;
+                    const events = db.getEvents(sid);
+                    if (events.length === 0)
+                        return { ok: true, compacted: false };
+                    const stats = db.getSessionStats(sid);
+                    const compactCount = (stats?.compact_count ?? 0) + 1;
+                    const snapshot = buildResumeSnapshot(events, { compactCount });
+                    db.upsertResume(sid, snapshot, events.length);
+                    db.incrementCompactCount(sid);
+                    return {
+                        ok: true,
+                        compacted: true,
+                        result: {
+                            summary: snapshot,
+                            firstKeptEntryId: "", // clear all history before this compaction
+                            tokensBefore: currentTokenCount ?? 0,
+                            tokensAfter: 0,
+                        },
+                    };
+                }
+                catch {
+                    return { ok: false, compacted: false };
+                }
+            },
+        }));
+        // ── 10. Auto-reply commands — ctx slash commands ──────
+        // Update module-level refs so command handlers (registered once) always
+        // read the latest session's db/sessionId/pluginRoot.
+        _latestDb = db;
+        _latestSessionId = sessionId;
+        _latestPluginRoot = pluginRoot;
+        if (api.registerCommand) {
+            api.registerCommand({
+                name: "ctx-stats",
+                description: "Show context-mode session statistics",
+                handler: () => {
+                    const text = buildStatsText(_latestDb, _latestSessionId);
+                    return { text };
+                },
+            });
+            api.registerCommand({
+                name: "ctx-doctor",
+                description: "Run context-mode diagnostics",
+                handler: () => {
+                    const cmd = `node "${_latestPluginRoot}/build/cli.js" doctor`;
+                    return {
+                        text: [
+                            "## ctx-doctor",
+                            "",
+                            "Run this command to diagnose context-mode:",
+                            "",
+                            "```",
+                            cmd,
+                            "```",
+                        ].join("\n"),
+                    };
+                },
+            });
+            api.registerCommand({
+                name: "ctx-upgrade",
+                description: "Upgrade context-mode to the latest version",
+                handler: () => {
+                    const cmd = `node "${_latestPluginRoot}/build/cli.js" upgrade`;
+                    return {
+                        text: [
+                            "## ctx-upgrade",
+                            "",
+                            "Run this command to upgrade context-mode:",
+                            "",
+                            "```",
+                            cmd,
+                            "```",
+                            "",
+                            "Restart your session after upgrade.",
+                        ].join("\n"),
+                    };
+                },
+            });
+        }
+    },
+};
+// ── Stats helper ──────────────────────────────────────────
+function buildStatsText(db, sessionId) {
+    try {
+        const events = db.getEvents(sessionId);
+        const stats = db.getSessionStats(sessionId);
+        const lines = [
+            "## context-mode stats",
+            "",
+            `- Session: \`${sessionId.slice(0, 8)}…\``,
+            `- Events captured: ${events.length}`,
+            `- Compactions: ${stats?.compact_count ?? 0}`,
+        ];
+        // Summarize events by type
+        const byType = {};
+        for (const ev of events) {
+            const key = ev.type ?? "unknown";
+            byType[key] = (byType[key] ?? 0) + 1;
+        }
+        if (Object.keys(byType).length > 0) {
+            lines.push("- Event breakdown:");
+            for (const [type, count] of Object.entries(byType)) {
+                lines.push(`  - ${type}: ${count}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    catch {
+        return "context-mode stats unavailable (session DB error)";
+    }
+}

package/build/server.js

@@ -14,7 +14,9 @@ import { readBashPolicies, evaluateCommandDenyOnly, extractShellCommands, readTo
 import { detectRuntimes, getRuntimeSummary, getAvailableLanguages, hasBunRuntime, } from "./runtime.js";
 import { classifyNonZeroExit } from "./exit-classify.js";
 import { startLifecycleGuard } from "./lifecycle.js";
-const VERSION = "1.0.21";
+import { getWorktreeSuffix } from "./session/db.js";
+const require = createRequire(import.meta.url);
+const VERSION = require("../package.json").version;
 // Prevent silent server death from unhandled async errors
 process.on("unhandledRejection", (err) => {
     process.stderr.write(`[context-mode] unhandledRejection: ${err}\n`);
@@ -730,15 +732,43 @@ let searchWindowStart = Date.now();
 const SEARCH_WINDOW_MS = 60_000;
 const SEARCH_MAX_RESULTS_AFTER = 3; // after 3 calls: 1 result per query
 const SEARCH_BLOCK_AFTER = 8; // after 8 calls: refuse, demand batching
+/**
+ * Defensive coercion: parse stringified JSON arrays.
+ * Works around Claude Code double-serialization bug where array params
+ * are sent as JSON strings (e.g. "[\"a\",\"b\"]" instead of ["a","b"]).
+ * See: https://github.com/anthropics/claude-code/issues/34520
+ */
+function coerceJsonArray(val) {
+    if (typeof val === "string") {
+        try {
+            const parsed = JSON.parse(val);
+            if (Array.isArray(parsed))
+                return parsed;
+        }
+        catch { /* not valid JSON, let zod handle the error */ }
+    }
+    return val;
+}
+/**
+ * Coerce commands array: handles double-serialization AND the case where
+ * the model passes plain command strings instead of {label, command} objects.
+ */
+function coerceCommandsArray(val) {
+    const arr = coerceJsonArray(val);
+    if (Array.isArray(arr)) {
+        return arr.map((item, i) => typeof item === "string" ? { label: `cmd_${i + 1}`, command: item } : item);
+    }
+    return arr;
+}
 server.registerTool("ctx_search", {
     title: "Search Indexed Content",
     description: "Search indexed content. Pass ALL search questions as queries array in ONE call.\n\n" +
         "TIPS: 2-4 specific terms per query. Use 'source' to scope results.",
     inputSchema: z.object({
-        queries: z
+        queries: z.preprocess(coerceJsonArray, z
             .array(z.string())
             .optional()
-            .describe("Array of search queries. Batch ALL questions in one call."),
+            .describe("Array of search queries. Batch ALL questions in one call.")),
         limit: z
             .number()
             .optional()
@@ -1044,7 +1074,7 @@ server.registerTool("ctx_batch_execute", {
         "One batch_execute call replaces 30+ execute calls + 10+ search calls.\n" +
         "Provide all commands to run and all queries to search — everything happens in one round trip.",
     inputSchema: z.object({
-        commands: z
+        commands: z.preprocess(coerceCommandsArray, z
             .array(z.object({
             label: z
                 .string()
@@ -1054,13 +1084,13 @@ server.registerTool("ctx_batch_execute", {
                 .describe("Shell command to execute"),
         }))
             .min(1)
-            .describe("Commands to execute as a batch. Each runs sequentially, output is labeled with the section header."),
-        queries: z
+            .describe("Commands to execute as a batch. Each runs sequentially, output is labeled with the section header.")),
+        queries: z.preprocess(coerceJsonArray, z
             .array(z.string())
             .min(1)
             .describe("Search queries to extract information from indexed output. Use 5-8 comprehensive queries. " +
             "Each returns top 5 matching sections with full content. " +
-            "This is your ONLY chance — put ALL your questions here. No follow-up calls needed."),
+            "This is your ONLY chance — put ALL your questions here. No follow-up calls needed.")),
         timeout: z
             .number()
             .optional()
@@ -1270,7 +1300,8 @@ server.registerTool("ctx_stats", {
     try {
         const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
         const dbHash = createHash("sha256").update(projectDir).digest("hex").slice(0, 16);
-        const sessionDbPath = join(homedir(), ".claude", "context-mode", "sessions", `${dbHash}.db`);
+        const worktreeSuffix = getWorktreeSuffix();
+        const sessionDbPath = join(homedir(), ".claude", "context-mode", "sessions", `${dbHash}${worktreeSuffix}.db`);
         if (existsSync(sessionDbPath)) {
             const require = createRequire(import.meta.url);
             const Database = require("better-sqlite3");
@@ -1467,11 +1498,15 @@ async function main() {
     startLifecycleGuard({ onShutdown: () => gracefulShutdown() });
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    // Write routing instructions for hookless platforms (e.g. Codex CLI)
+    // Write routing instructions for hookless platforms (e.g. Codex CLI, Antigravity)
     try {
         const { detectPlatform, getAdapter } = await import("./adapters/detect.js");
-        const signal = detectPlatform();
+        const clientInfo = server.server.getClientVersion();
+        const signal = detectPlatform(clientInfo ?? undefined);
         const adapter = await getAdapter(signal.platform);
+        if (clientInfo) {
+            console.error(`MCP client: ${clientInfo.name} v${clientInfo.version} → ${signal.platform}`);
+        }
         if (!adapter.capabilities.sessionStart) {
             const pluginRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
             const projectDir = process.env.CLAUDE_PROJECT_DIR ?? process.env.CODEX_HOME ?? process.cwd();

package/build/session/db.d.ts

@@ -7,6 +7,15 @@
  */
 import { SQLiteBase } from "../db-base.js";
 import type { SessionEvent } from "../types.js";
+/**
+ * Returns the worktree suffix to append to session identifiers.
+ * Returns empty string when running in the main working tree.
+ *
+ * Set CONTEXT_MODE_SESSION_SUFFIX to an explicit value to override
+ * (useful in CI environments or when git is unavailable).
+ * Set to empty string to disable isolation entirely.
+ */
+export declare function getWorktreeSuffix(): string;
 /** A stored event row from the session_events table. */
 export interface StoredEvent {
     id: number;