context-mode 1.0.162 → 1.0.163

package/build/adapters/copilot-cli/hooks.js

@@ -0,0 +1,64 @@
+/**
+ * adapters/copilot-cli/hooks — GitHub Copilot CLI hook definitions.
+ *
+ * GitHub Copilot CLI's native hook events are the camelCase names
+ * preToolUse / postToolUse / sessionStart / userPromptSubmitted / agentStop /
+ * preCompact. Per the copilot-cli changelog, PascalCase event names are ALSO
+ * accepted and fire — the CLI loads hook configs across VS Code, Claude Code,
+ * and the CLI by accepting PascalCase event names alongside camelCase
+ * (copilot-cli changelog.md:1065; see also :811 and :1081). We register the
+ * camelCase KEYS below because they are the CLI's native names, not because
+ * PascalCase would fail. The CLI dispatch token (the `.mjs` script base, e.g.
+ * `pretooluse`) is independent and stays lowercase via buildHookCommand, so
+ * changing the event casing does not change the dispatcher.
+ */
+export const HOOK_TYPES = {
+    PRE_TOOL_USE: "preToolUse",
+    POST_TOOL_USE: "postToolUse",
+    PRE_COMPACT: "preCompact",
+    SESSION_START: "sessionStart",
+    // Copilot CLI 1.0.60 fires userPromptSubmitted + agentStop (verified against
+    // the @github/copilot binary). Used for user-prompt + session-end capture,
+    // same as the codex/kimi adapters.
+    USER_PROMPT_SUBMIT: "userPromptSubmitted",
+    STOP: "agentStop",
+};
+export const HOOK_SCRIPTS = {
+    [HOOK_TYPES.PRE_TOOL_USE]: "pretooluse.mjs",
+    [HOOK_TYPES.POST_TOOL_USE]: "posttooluse.mjs",
+    [HOOK_TYPES.PRE_COMPACT]: "precompact.mjs",
+    [HOOK_TYPES.SESSION_START]: "sessionstart.mjs",
+    [HOOK_TYPES.USER_PROMPT_SUBMIT]: "userpromptsubmit.mjs",
+    [HOOK_TYPES.STOP]: "stop.mjs",
+};
+export const REQUIRED_HOOKS = [
+    HOOK_TYPES.PRE_TOOL_USE,
+    HOOK_TYPES.SESSION_START,
+];
+export const OPTIONAL_HOOKS = [
+    HOOK_TYPES.POST_TOOL_USE,
+    HOOK_TYPES.PRE_COMPACT,
+    HOOK_TYPES.USER_PROMPT_SUBMIT,
+    HOOK_TYPES.STOP,
+];
+export function isContextModeHook(entry, hookType) {
+    const scriptName = HOOK_SCRIPTS[hookType];
+    if (!scriptName)
+        return false;
+    const cliCommand = buildHookCommand(hookType);
+    if (entry.command?.includes(cliCommand) || entry.command?.includes(scriptName)) {
+        return true;
+    }
+    return (entry.hooks?.some((h) => h.command?.includes(scriptName) || h.command?.includes(cliCommand)) ?? false);
+}
+export function buildHookCommand(hookType, _pluginRoot) {
+    const scriptName = HOOK_SCRIPTS[hookType];
+    if (!scriptName) {
+        throw new Error(`No script defined for hook type: ${hookType}`);
+    }
+    // The CLI dispatch token is the script base (pretooluse, posttooluse, …), NOT
+    // the camelCase host event name — keep them decoupled so the event KEY stays
+    // Copilot's camelCase while the dispatcher token (and the cli.ts hook handler)
+    // remain stable regardless of how the host names its events.
+    return `context-mode hook copilot-cli ${scriptName.replace(/\.mjs$/, "")}`;
+}

package/build/adapters/copilot-cli/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * adapters/copilot-cli — GitHub Copilot CLI adapter.
+ *
+ * Native config:
+ *   - MCP:   $COPILOT_HOME/mcp-config.json or ~/.copilot/mcp-config.json
+ *            under root key `mcpServers`.
+ *   - Hooks: $COPILOT_HOME/hooks/context-mode.json or
+ *            ~/.copilot/hooks/context-mode.json.
+ *
+ * Hooks use Copilot CLI's native camelCase event keys (preToolUse /
+ * postToolUse / sessionStart / userPromptSubmitted / agentStop / preCompact)
+ * with flat `{ type, command }` entries. (The CLI also accepts PascalCase
+ * event names alongside camelCase — copilot-cli changelog.md:1065 — so the
+ * casing is not load-bearing; we use camelCase because it is the CLI's native
+ * naming.) Copilot CLI's command output contract is top-level
+ * (`permissionDecision`, `modifiedArgs`, `additionalContext`), so this adapter
+ * overrides the response formatter from CopilotBaseAdapter.
+ */
+import { CopilotBaseAdapter } from "../copilot-base.js";
+import type { CopilotHookInput, CopilotHookModule } from "../copilot-base.js";
+import type { DiagnosticResult, HookRegistration, PostToolUseResponse, PreCompactResponse, PostToolUseEvent, PreToolUseEvent, PreToolUseResponse, SessionStartResponse } from "../types.js";
+export declare function copilotCliHome(): string;
+export declare function copilotCliMcpConfigPath(): string;
+export declare class CopilotCliAdapter extends CopilotBaseAdapter {
+    constructor();
+    readonly name = "GitHub Copilot CLI";
+    protected readonly hookModule: CopilotHookModule;
+    protected readonly hookSubdir = "copilot-cli";
+    protected extractSessionId(input: CopilotHookInput): string;
+    protected getProjectDir(): string;
+    parsePreToolUseInput(raw: unknown): PreToolUseEvent;
+    parsePostToolUseInput(raw: unknown): PostToolUseEvent;
+    getSettingsPath(_projectDir?: string): string;
+    getConfigDir(_projectDir?: string): string;
+    getSessionDir(): string;
+    getInstructionFiles(): string[];
+    generateHookConfig(pluginRoot: string): HookRegistration;
+    writeSettings(settings: Record<string, unknown>): void;
+    configureAllHooks(pluginRoot: string): string[];
+    readSettings(): Record<string, unknown> | null;
+    formatPreToolUseResponse(response: PreToolUseResponse): unknown;
+    formatPostToolUseResponse(response: PostToolUseResponse): unknown;
+    formatPreCompactResponse(response: PreCompactResponse): unknown;
+    formatSessionStartResponse(response: SessionStartResponse): unknown;
+    validateHooks(pluginRoot: string): DiagnosticResult[];
+    checkPluginRegistration(): DiagnosticResult;
+    getInstalledVersion(): string;
+}

package/build/adapters/copilot-cli/index.js

@@ -0,0 +1,341 @@
+/**
+ * adapters/copilot-cli — GitHub Copilot CLI adapter.
+ *
+ * Native config:
+ *   - MCP:   $COPILOT_HOME/mcp-config.json or ~/.copilot/mcp-config.json
+ *            under root key `mcpServers`.
+ *   - Hooks: $COPILOT_HOME/hooks/context-mode.json or
+ *            ~/.copilot/hooks/context-mode.json.
+ *
+ * Hooks use Copilot CLI's native camelCase event keys (preToolUse /
+ * postToolUse / sessionStart / userPromptSubmitted / agentStop / preCompact)
+ * with flat `{ type, command }` entries. (The CLI also accepts PascalCase
+ * event names alongside camelCase — copilot-cli changelog.md:1065 — so the
+ * casing is not load-bearing; we use camelCase because it is the CLI's native
+ * naming.) Copilot CLI's command output contract is top-level
+ * (`permissionDecision`, `modifiedArgs`, `additionalContext`), so this adapter
+ * overrides the response formatter from CopilotBaseAdapter.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { CopilotBaseAdapter } from "../copilot-base.js";
+import { resolveContextModeDataRoot } from "../base.js";
+import { parseJsonc } from "../../util/jsonc.js";
+import { HOOK_TYPES as COPILOT_HOOK_NAMES, HOOK_SCRIPTS as COPILOT_HOOK_SCRIPTS, buildHookCommand as buildCopilotHookCommand, } from "./hooks.js";
+const COPILOT_PLUGIN_ENV = "CONTEXT_MODE_COPILOT_PLUGIN";
+function isCopilotPluginRuntime() {
+    return process.env[COPILOT_PLUGIN_ENV] === "1";
+}
+function copilotPluginHooksPath(pluginRoot) {
+    return resolve(pluginRoot, "configs", "copilot-cli", "hooks.json");
+}
+function readHookConfig(path) {
+    return parseJsonc(readFileSync(path, "utf-8")) ?? {};
+}
+function hasHook(hooks, hookName) {
+    return Array.isArray(hooks?.[hookName]) && (hooks?.[hookName]).length > 0;
+}
+export function copilotCliHome() {
+    const raw = process.env.COPILOT_HOME;
+    if (raw && raw.trim() !== "") {
+        if (raw.startsWith("~")) {
+            return join(homedir(), raw.replace(/^~[/\\]?/, ""));
+        }
+        return resolve(raw);
+    }
+    return join(homedir(), ".copilot");
+}
+export function copilotCliMcpConfigPath() {
+    return join(copilotCliHome(), "mcp-config.json");
+}
+export class CopilotCliAdapter extends CopilotBaseAdapter {
+    constructor() {
+        super([".copilot"]);
+    }
+    name = "GitHub Copilot CLI";
+    hookModule = {
+        HOOK_TYPES: COPILOT_HOOK_NAMES,
+        HOOK_SCRIPTS: COPILOT_HOOK_SCRIPTS,
+        buildHookCommand: buildCopilotHookCommand,
+    };
+    hookSubdir = "copilot-cli";
+    extractSessionId(input) {
+        const raw = input;
+        if (raw.transcript_path) {
+            const match = raw.transcript_path.match(/([a-f0-9-]{36})\.jsonl$/);
+            if (match)
+                return match[1];
+        }
+        if (raw.conversation_id)
+            return raw.conversation_id;
+        // `session_id` (snake_case) is the field Copilot CLI documents in its hook
+        // payloads (copilot-cli changelog.md:811). Prefer it; `sessionId` (camelCase)
+        // is kept only as a defensive fallback for non-standard payload shapes and is
+        // not a documented Copilot CLI field.
+        if (raw.session_id)
+            return raw.session_id;
+        if (input.sessionId)
+            return input.sessionId;
+        return `pid-${process.ppid}`;
+    }
+    getProjectDir() {
+        return process.cwd();
+    }
+    parsePreToolUseInput(raw) {
+        const input = raw;
+        return {
+            toolName: input.tool_name ?? input.toolName ?? "",
+            toolInput: input.tool_input ?? input.toolArgs ?? {},
+            sessionId: this.extractSessionId(input),
+            projectDir: typeof input.cwd === "string" && input.cwd ? input.cwd : process.cwd(),
+            raw,
+        };
+    }
+    parsePostToolUseInput(raw) {
+        const input = raw;
+        const output = input.tool_result?.text_result_for_llm ??
+            input.toolResult?.textResultForLlm ??
+            (typeof input.tool_response === "string" ? input.tool_response : undefined) ??
+            input.tool_output;
+        return {
+            toolName: input.tool_name ?? input.toolName ?? "",
+            toolInput: input.tool_input ?? input.toolArgs ?? {},
+            toolOutput: output,
+            isError: input.is_error,
+            sessionId: this.extractSessionId(input),
+            projectDir: typeof input.cwd === "string" && input.cwd ? input.cwd : process.cwd(),
+            raw,
+        };
+    }
+    getSettingsPath(_projectDir) {
+        return join(copilotCliHome(), "hooks", "context-mode.json");
+    }
+    getConfigDir(_projectDir) {
+        return copilotCliHome();
+    }
+    getSessionDir() {
+        // Parity with codex/kimi: honor CONTEXT_MODE_DATA_DIR first, else root
+        // session storage at getConfigDir() (= copilotCliHome(), COPILOT_HOME-aware)
+        // so the TS server reads sessions from the SAME place the hook runtime
+        // (COPILOT_OPTS configDirEnv: "COPILOT_HOME") writes them. Without this, a
+        // relocated COPILOT_HOME splits hook writes ($COPILOT_HOME/...) from server
+        // reads (~/.copilot/...) and sessions appear empty/orphaned.
+        const override = resolveContextModeDataRoot();
+        const dir = override
+            ? join(override, "context-mode", "sessions")
+            : join(this.getConfigDir(), "context-mode", "sessions");
+        mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    getInstructionFiles() {
+        return [".github/copilot-instructions.md", "AGENTS.md"];
+    }
+    // ── Hook-config writing (Copilot CLI shape) ────────────
+    //
+    // GitHub Copilot CLI's hooks schema differs from the VS Code / JetBrains
+    // Copilot extensions that share CopilotBaseAdapter:
+    //   - hook entries are FLAT `{ type: "command", command }` — NOT the
+    //     Claude-Code nested `{ matcher, hooks: [...] }` shape the base emits, and
+    //   - we emit a top-level `"version": 1`. This is OPTIONAL, not mandatory:
+    //     the Copilot CLI accepts hook config files that omit the version field
+    //     (copilot-cli changelog.md:1109). We still write version:1 to pin the
+    //     schema explicitly — it is harmless and self-documenting, NOT a
+    //     hooks-never-fire requirement.
+    // The shared base also hardcodes `mkdir .github/hooks` and writes there, but
+    // this adapter's settings live at ~/.copilot/hooks/context-mode.json, so
+    // writeSettings is overridden to create the real parent directory. All three
+    // overrides are scoped to copilot-cli so vscode/jetbrains-copilot keep the
+    // shared base behavior unchanged.
+    generateHookConfig(pluginRoot) {
+        const { HOOK_TYPES, buildHookCommand } = this.hookModule;
+        const flat = (hookType) => [
+            { type: "command", command: buildHookCommand(hookType, pluginRoot) },
+        ];
+        // Emit an entry for every declared hook type (preToolUse, postToolUse,
+        // preCompact, sessionStart, userPromptSubmitted, agentStop).
+        const config = {};
+        for (const hookType of Object.values(HOOK_TYPES)) {
+            config[hookType] = flat(hookType);
+        }
+        return config;
+    }
+    writeSettings(settings) {
+        const configPath = this.getSettingsPath();
+        mkdirSync(dirname(configPath), { recursive: true });
+        writeFileSync(configPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    }
+    configureAllHooks(pluginRoot) {
+        const changes = [];
+        const settings = this.readSettings() ?? {};
+        const hooks = settings.hooks ?? {};
+        const { HOOK_TYPES, HOOK_SCRIPTS, buildHookCommand } = this.hookModule;
+        // Configure every hook type the module declares (preToolUse, postToolUse,
+        // preCompact, sessionStart, userPromptSubmitted, agentStop) — driven by
+        // HOOK_TYPES so new events are picked up automatically.
+        for (const hookType of Object.values(HOOK_TYPES)) {
+            if (!HOOK_SCRIPTS[hookType])
+                continue;
+            const desired = [
+                { type: "command", command: buildHookCommand(hookType, pluginRoot) },
+            ];
+            // Only treat a hook as drift when it differs from desired, so repeated
+            // `context-mode upgrade` runs stay idempotent.
+            if (JSON.stringify(hooks[hookType]) !== JSON.stringify(desired)) {
+                hooks[hookType] = desired;
+                changes.push(`Configured ${hookType} hook`);
+            }
+        }
+        // We pin version:1 explicitly (optional per copilot-cli changelog.md:1109,
+        // but self-documenting); treat a missing/mismatched value as drift to repair.
+        if (settings.version !== 1) {
+            changes.push("Set hooks schema version to 1");
+        }
+        if (changes.length > 0) {
+            settings.version = 1;
+            settings.hooks = hooks;
+            this.writeSettings(settings);
+            changes.push(`Wrote hook config to ${this.getSettingsPath()}`);
+        }
+        return changes;
+    }
+    readSettings() {
+        try {
+            const raw = readFileSync(this.getSettingsPath(), "utf-8");
+            return parseJsonc(raw) ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    formatPreToolUseResponse(response) {
+        if (response.decision === "deny") {
+            return {
+                permissionDecision: "deny",
+                permissionDecisionReason: response.reason ?? "Blocked by context-mode hook",
+            };
+        }
+        if (response.decision === "ask") {
+            return {
+                permissionDecision: "ask",
+                permissionDecisionReason: response.reason ?? "Action requires user confirmation",
+            };
+        }
+        if (response.decision === "modify" && response.updatedInput) {
+            return { modifiedArgs: response.updatedInput };
+        }
+        if (response.decision === "context" && response.additionalContext) {
+            return { additionalContext: response.additionalContext };
+        }
+        return undefined;
+    }
+    formatPostToolUseResponse(response) {
+        if (response.updatedOutput) {
+            return {
+                modifiedResult: {
+                    resultType: "success",
+                    textResultForLlm: response.updatedOutput,
+                },
+            };
+        }
+        if (response.additionalContext) {
+            return { additionalContext: response.additionalContext };
+        }
+        return undefined;
+    }
+    formatPreCompactResponse(response) {
+        void response;
+        return undefined;
+    }
+    formatSessionStartResponse(response) {
+        return response.context ? { additionalContext: response.context } : undefined;
+    }
+    validateHooks(pluginRoot) {
+        const results = [];
+        const pluginRuntime = isCopilotPluginRuntime();
+        const settingsPath = pluginRuntime ? copilotPluginHooksPath(pluginRoot) : this.getSettingsPath();
+        const settingsLabel = pluginRuntime
+            ? `Copilot CLI plugin bundle hooks.json (${settingsPath})`
+            : settingsPath;
+        const fix = pluginRuntime
+            ? "copilot plugin install mksglu/context-mode:configs/copilot-cli"
+            : "context-mode upgrade";
+        try {
+            const config = readHookConfig(settingsPath);
+            const hooks = config.hooks;
+            results.push({
+                check: "Hooks schema version",
+                status: config.version === 1 ? "pass" : "fail",
+                message: config.version === 1
+                    ? `${settingsLabel} declares the required "version": 1`
+                    : `${settingsLabel} is missing top-level "version": 1`,
+                ...(config.version === 1 ? {} : { fix }),
+            });
+            for (const hookName of Object.values(COPILOT_HOOK_NAMES)) {
+                const configured = hasHook(hooks, hookName);
+                results.push({
+                    check: `${hookName} hook`,
+                    status: configured ? "pass" : "fail",
+                    message: configured
+                        ? `${hookName} hook configured in ${settingsLabel}`
+                        : `${hookName} not found in ${settingsLabel}`,
+                    ...(configured ? {} : { fix }),
+                });
+            }
+        }
+        catch {
+            results.push({
+                check: "Hook configuration",
+                status: "fail",
+                message: `Could not read ${settingsLabel}`,
+                fix,
+            });
+        }
+        return results;
+    }
+    checkPluginRegistration() {
+        if (isCopilotPluginRuntime()) {
+            return {
+                check: "MCP registration",
+                status: "pass",
+                message: "context-mode loaded from the Copilot CLI plugin bundle",
+            };
+        }
+        try {
+            const raw = readFileSync(copilotCliMcpConfigPath(), "utf-8");
+            const config = parseJsonc(raw) ?? {};
+            const mcpServers = config?.mcpServers ?? {};
+            if ("context-mode" in mcpServers) {
+                return {
+                    check: "MCP registration",
+                    status: "pass",
+                    message: "context-mode found in Copilot CLI mcp-config.json",
+                };
+            }
+            return {
+                check: "MCP registration",
+                status: "fail",
+                message: "context-mode not found in Copilot CLI mcpServers",
+                // `context-mode upgrade` configures HOOKS only — never the MCP server.
+                // Copilot CLI's own command writes ~/.copilot/mcp-config.json for us.
+                fix: "copilot mcp add context-mode -- context-mode",
+            };
+        }
+        catch {
+            return {
+                check: "MCP registration",
+                status: "fail",
+                message: `Could not read ${copilotCliMcpConfigPath()}`,
+                fix: "copilot mcp add context-mode -- context-mode",
+            };
+        }
+    }
+    getInstalledVersion() {
+        // Copilot's user-level MCP config and local/plugin-dir bundle do not expose
+        // a durable installed plugin version to this process. The npm package
+        // version is already checked above, so avoid the false `vconfigured` WARN.
+        return existsSync(copilotCliMcpConfigPath()) || existsSync(this.getSettingsPath())
+            ? "standalone"
+            : "not installed";
+    }
+}

package/build/adapters/detect.d.ts

@@ -42,7 +42,7 @@ export declare function __seedClaudeCodePluginCacheMissForTests(): void;
  *
  * Issue #545 — algorithmic env-leak fix. The split allows resolveProjectDir
  * to derive ALLOW (own workspace vars) and BAN (other platforms' workspace
- * vars) sets from a single registry, satisfying MUST-3 (15 adapters equal).
+ * vars) sets from a single registry, satisfying MUST-3 (17 adapters equal).
  *
  * Issue #561 — FOREIGN identification vars MUST be scrubbed when spawning a
  * child under a different host (e.g. Pi spawning context-mode child must

package/build/adapters/detect.js

@@ -169,8 +169,9 @@ const _PLATFORM_ENV_VARS_RAW = [
     //   refs/platforms/oh-my-pi/packages/coding-agent/src/mcp/transports/stdio.ts:55-63
     // (env passthrough only, no synthesis). The Pi runtime DOES set
     // PI_CONFIG_DIR (config dir override), PI_SESSION_FILE (active session
-    // path), and PI_COMPILED (binary build marker). PI_CODING_AGENT_DIR is
-    // owned by OMP above; keep it there.
+    // path), PI_COMPILED (binary build marker), and PI_CODING_AGENT=true
+    // in package-spawned MCP children (#760). PI_CODING_AGENT_DIR is owned
+    // by OMP above; keep it there.
     //
     // Issue #545 — PI_WORKSPACE_DIR / PI_PROJECT_DIR are workspace vars set
     // by Pi's bridge so the resolver picks them up under strict mode.
@@ -185,6 +186,7 @@ const _PLATFORM_ENV_VARS_RAW = [
             { name: "PI_CONFIG_DIR", role: "identification" },
             { name: "PI_SESSION_FILE", role: "identification" },
             { name: "PI_COMPILED", role: "identification" },
+            { name: "PI_CODING_AGENT", role: "identification" },
         ]],
     // openclaw — removed (runtime never sets OPENCLAW_HOME or OPENCLAW_CLI;
     // detection falls through to ~/.openclaw/ config-dir tier below).
@@ -273,10 +275,12 @@ export function getSessionDirSegments(platform) {
         case "claude-code": return [".claude"];
         case "gemini-cli": return [".gemini"];
         case "antigravity": return [".gemini"];
+        case "antigravity-cli": return [".gemini"];
         case "openclaw": return [".openclaw"];
         case "codex": return [".codex"];
         case "cursor": return [".cursor"];
         case "vscode-copilot": return [".vscode"];
+        case "copilot-cli": return [".copilot"];
         case "kiro": return [".kiro"];
         case "pi": return [".pi"];
         case "omp": return [".omp"];
@@ -320,7 +324,7 @@ export function detectPlatform(clientInfo) {
     if (platformOverride) {
         const validPlatforms = [
             "claude-code", "gemini-cli", "kilo", "opencode", "codex",
-            "vscode-copilot", "jetbrains-copilot", "cursor", "antigravity", "kiro", "pi", "omp", "zed", "qwen-code", "kimi",
+            "vscode-copilot", "jetbrains-copilot", "copilot-cli", "cursor", "antigravity", "antigravity-cli", "kiro", "pi", "omp", "zed", "qwen-code", "kimi",
         ];
         if (validPlatforms.includes(platformOverride)) {
             return {
@@ -358,6 +362,62 @@ export function detectPlatform(clientInfo) {
     }
     // ── Medium confidence: config directory existence ──────
     const home = homedir();
+    // Issue #774 — dedicated CLI agents (Antigravity CLI `agy`, GitHub Copilot
+    // CLI) MUST be probed BEFORE the generic ~/.claude and ~/.gemini fallbacks.
+    // A user migrating from gemini-cli to `agy` keeps ~/.claude AND ~/.gemini, so
+    // the ~/.claude check below otherwise wins and `context-mode doctor`
+    // mis-detected `agy` as Claude Code — pointing storage at ~/.claude and
+    // reporting the wrong platform (reproduced in #774).
+    //
+    // Regression guard (whole-branch detection-ordering review): these markers
+    // are deliberately narrow so they cannot relocate an existing Claude Code
+    // user's storage from a bare shell. The antigravity-cli markers are either
+    // agy-exclusive (`~/.local/bin/agy`, `~/.gemini/antigravity-cli`) or map to
+    // the SAME `~/.gemini` root as gemini-cli (so a mis-detect is storage-neutral
+    // and never collides with `~/.gemini/settings.json` (gemini-cli) or
+    // `~/.gemini/antigravity/` (Antigravity IDE)). The copilot-cli marker is
+    // gated on a context-mode-written file (NOT a bare `~/.copilot/` directory),
+    // so a Claude Code user who merely co-installed GitHub Copilot CLI — but has
+    // not configured context-mode for it — is NOT pulled away from ~/.claude.
+    // GitHub Copilot CLI's config root is relocatable via COPILOT_HOME (the
+    // documented relocation env, incl. on Windows), so the marker must honor it —
+    // not just ~/.copilot. Mirrors copilotCliHome() in copilot-cli/index.ts.
+    const copilotHome = (() => {
+        const raw = process.env.COPILOT_HOME;
+        if (raw && raw.trim() !== "") {
+            return raw.startsWith("~") ? resolve(home, raw.replace(/^~[/\\]?/, "")) : resolve(raw);
+        }
+        return resolve(home, ".copilot");
+    })();
+    const copilotConfigured = existsSync(resolve(copilotHome, "mcp-config.json")) ||
+        existsSync(resolve(copilotHome, "hooks", "context-mode.json"));
+    // A non-empty COPILOT_HOME is an explicit user/session selection, not a
+    // passive co-install marker. Respect it before agy's global markers so a
+    // Copilot doctor run in an isolated COPILOT_HOME is not stolen by an
+    // unrelated ~/.local/bin/agy or ~/.gemini/config/mcp_config.json.
+    if (process.env.COPILOT_HOME?.trim() && copilotConfigured) {
+        return {
+            platform: "copilot-cli",
+            confidence: "medium",
+            reason: "context-mode config in explicit COPILOT_HOME exists (mcp-config.json or hooks/context-mode.json)",
+        };
+    }
+    if (existsSync(resolve(home, ".local", "bin", "agy")) ||
+        existsSync(resolve(home, ".gemini", "antigravity-cli")) ||
+        existsSync(resolve(home, ".gemini", "config", "mcp_config.json"))) {
+        return {
+            platform: "antigravity-cli",
+            confidence: "medium",
+            reason: "Antigravity CLI marker exists (~/.local/bin/agy, ~/.gemini/antigravity-cli, or ~/.gemini/config/mcp_config.json)",
+        };
+    }
+    if (copilotConfigured) {
+        return {
+            platform: "copilot-cli",
+            confidence: "medium",
+            reason: "context-mode config in Copilot CLI home exists (mcp-config.json or hooks/context-mode.json; honors COPILOT_HOME)",
+        };
+    }
     if (existsSync(resolve(home, ".claude"))) {
         return {
             platform: "claude-code",
@@ -510,6 +570,10 @@ export async function getAdapter(platform) {
             const { JetBrainsCopilotAdapter } = await import("./jetbrains-copilot/index.js");
             return new JetBrainsCopilotAdapter();
         }
+        case "copilot-cli": {
+            const { CopilotCliAdapter } = await import("./copilot-cli/index.js");
+            return new CopilotCliAdapter();
+        }
         case "cursor": {
             const { CursorAdapter } = await import("./cursor/index.js");
             return new CursorAdapter();
@@ -518,6 +582,10 @@ export async function getAdapter(platform) {
             const { AntigravityAdapter } = await import("./antigravity/index.js");
             return new AntigravityAdapter();
         }
+        case "antigravity-cli": {
+            const { AntigravityCliAdapter } = await import("./antigravity-cli/index.js");
+            return new AntigravityCliAdapter();
+        }
         case "kiro": {
             const { KiroAdapter } = await import("./kiro/index.js");
             return new KiroAdapter();

package/build/adapters/openclaw/mcp-tools.js

@@ -194,7 +194,7 @@ export const OPENCLAW_TOOL_DEFS = [
     },
     {
         name: "ctx_insight",
-        description: "Open the context-mode Insight analytics dashboard in the browser.",
+        description: "Open the hosted context-mode Insight dashboard (context-mode.com/insight) in the browser.",
         parameters: {
             type: "object",
             properties: {},