dsh-context-mode 0.1.3 → 0.2.0

package/vendor/context-mode/src/platform/detect.ts

@@ -0,0 +1,645 @@
+/**
+ * adapters/detect — Auto-detect which platform is running.
+ *
+ * Detection priority:
+ *   1. Environment variables (high confidence)
+ *   2. Config directory existence (medium confidence)
+ *   3. Fallback to Claude Code (low confidence — most common)
+ *
+ * Verified env vars per platform (from source code audit):
+ *   - Claude Code:    CLAUDE_CODE_ENTRYPOINT, CLAUDE_PLUGIN_ROOT,
+ *                     CLAUDE_PROJECT_DIR, CLAUDE_SESSION_ID | ~/.claude/
+ *   - Gemini CLI:     GEMINI_PROJECT_DIR (hooks), GEMINI_CLI (MCP) | ~/.gemini/
+ *   - KiloCode:       KILO, KILO_PID | ~/.config/kilo/
+ *   - OpenCode:       OPENCODE_PROJECT_DIR, OPENCODE_CLIENT,
+ *                     OPENCODE_TERMINAL, OPENCODE, OPENCODE_PID |
+ *                     ~/.config/opencode/
+ *   - OpenClaw:       OPENCLAW_HOME, OPENCLAW_CLI | ~/.openclaw/
+ *   - Codex CLI:      CODEX_CI, CODEX_THREAD_ID | ~/.codex/
+ *   - Cursor:         CURSOR_TRACE_ID (MCP), CURSOR_CLI (terminal) | ~/.cursor/
+ *   - VS Code Copilot: VSCODE_PID, VSCODE_CWD | ~/.vscode/
+ *   - JetBrains Copilot: IDEA_INITIAL_DIRECTORY, IDEA_HOME, JETBRAINS_CLIENT_ID | ~/.config/JetBrains/
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+
+import type { PlatformId, DetectionSignal, HookAdapter } from "./types.js";
+import { CLIENT_NAME_TO_PLATFORM } from "./client-map.js";
+
+/**
+ * Issue #539 — fallback disambiguator. When env-var detection would
+ * otherwise resolve to vscode-copilot (because Microsoft's `code` exports
+ * VSCODE_PID into every spawned child), we look at
+ * ~/.claude/plugins/installed_plugins.json. If that file lists context-mode
+ * as an installed plugin, the runtime MUST be Claude Code — VS Code Copilot
+ * has no concept of Claude plugins. Memoized per-process: the file is read
+ * at most once, with a tri-state cache so a missing/malformed file does not
+ * trigger repeated I/O on the detect() hot path.
+ */
+type PluginCache = { hasCM: boolean } | "miss" | null;
+let claudeCodePluginCache: PluginCache = null;
+
+function claudeCodeHasContextModePlugin(): boolean {
+  if (claudeCodePluginCache !== null) {
+    return claudeCodePluginCache !== "miss" && claudeCodePluginCache.hasCM;
+  }
+  try {
+    const path = resolve(homedir(), ".claude", "plugins", "installed_plugins.json");
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw) as {
+      plugins?: Record<string, unknown>;
+      enabledPlugins?: Record<string, unknown>;
+    };
+    const keys = [
+      ...Object.keys(parsed.plugins ?? {}),
+      ...Object.keys(parsed.enabledPlugins ?? {}),
+    ];
+    const hasCM = keys.some((k) => k.includes("context-mode"));
+    claudeCodePluginCache = { hasCM };
+    return hasCM;
+  } catch {
+    claudeCodePluginCache = "miss";
+    return false;
+  }
+}
+
+/** Test-only: reset the installed_plugins.json memo so each test starts cold. */
+export function __resetClaudeCodePluginCacheForTests(): void {
+  claudeCodePluginCache = null;
+}
+
+/**
+ * Test-only: pretend installed_plugins.json does not exist (or has no
+ * context-mode entry). Lets tests that exercise the genuine vscode-copilot
+ * env-var path run on a developer machine that actually has context-mode
+ * installed as a Claude Code plugin.
+ */
+export function __seedClaudeCodePluginCacheMissForTests(): void {
+  claudeCodePluginCache = "miss";
+}
+
+/**
+ * Tag for each PLATFORM_ENV_VARS row.
+ *   - `workspace`: env var names a project/working directory. Used by
+ *     `resolveProjectDir({ strictPlatform })` to form the candidate list,
+ *     and by Pi's bridge to scrub foreign workspace vars on child spawn.
+ *   - `identification`: env var only signals which host is running; carries
+ *     no project path. PRESERVED in normal operation (some are load-bearing
+ *     for hook integrations on the host that owns them, e.g. CLAUDE_PLUGIN_ROOT
+ *     for Claude Code's hook context).
+ *
+ * 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 (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
+ * scrub Claude Code identification vars CLAUDE_CODE_ENTRYPOINT /
+ * CLAUDE_PLUGIN_ROOT to prevent detectPlatform() in the child from
+ * misidentifying the host as claude-code and writing Pi's data into
+ * ~/.claude/context-mode/). See `foreignIdentificationEnv()` below.
+ */
+export type EnvVarRole = "workspace" | "identification";
+export interface PlatformEnvEntry {
+  readonly name: string;
+  readonly role: EnvVarRole;
+  /**
+   * When `false`, this entry is NOT used as a high-confidence detection
+   * signal — only consumed by `workspaceEnvVarsFor`/`foreignWorkspaceEnv`
+   * (project-dir cascade and bridge env scrub). Use for consumer-set
+   * workspace vars that the host runtime never emits itself, so that a
+   * stale env var on an unrelated host does not misclassify the platform.
+   * Default: `true` (entry participates in detection).
+   *
+   * Issue #542 — PI_PROJECT_DIR / PI_WORKSPACE_DIR are consumer-set and
+   * MUST NOT trigger Pi detection on their own.
+   */
+  readonly detect?: boolean;
+}
+
+/**
+ * High-confidence env vars per platform, checked in priority order.
+ * Single source of truth — consumed by detectPlatform() below, by
+ * `resolveProjectDir({ strictPlatform })` for cascade construction, and by
+ * Pi's bridge env scrub. Tests also iterate this map to clear platform-
+ * related env vars deterministically.
+ *
+ * The map shape is `Map<PlatformId, ReadonlyArray<PlatformEnvEntry>>`. Use
+ * `getEnvVarNames(p)` to get just the names (legacy `string[]` shape).
+ */
+const _PLATFORM_ENV_VARS_RAW: ReadonlyArray<readonly [PlatformId, readonly PlatformEnvEntry[]]> = [
+  // Order matters: forks listed BEFORE the fork's parent so collision
+  // detection works. Every entry verified against platform's own runtime
+  // source code (PR #376 follow-up: full audit, May 2026 — see git blame).
+  // Claude Code — verified against a live `env` dump (2026-05-11):
+  //   CLAUDE_CODE_ENTRYPOINT=cli              (set on every CC session)
+  //   CLAUDE_PLUGIN_ROOT=/Users/.../<version>  (set when a plugin is loaded)
+  //   CLAUDE_PROJECT_DIR=/Users/.../project    (set in hooks context)
+  //   CLAUDE_SESSION_ID=<uuid>                 (legacy session marker)
+  // CLAUDE_CODE_ENTRYPOINT and CLAUDE_PLUGIN_ROOT are CC-exclusive — they
+  // are the disambiguators for issue #539 (Claude Code running inside a
+  // VS Code integrated terminal that has VSCODE_PID set). They MUST be
+  // checked here so detect resolves to claude-code BEFORE falling through
+  // to vscode-copilot below.
+  ["claude-code", [
+    { name: "CLAUDE_CODE_ENTRYPOINT", role: "identification" },
+    { name: "CLAUDE_PLUGIN_ROOT",     role: "identification" },
+    { name: "CLAUDE_PROJECT_DIR",     role: "workspace" },
+    { name: "CLAUDE_SESSION_ID",      role: "identification" },
+  ]],
+  // antigravity (Electron/VSCode fork) — google-gemini/gemini-cli
+  // packages/core/src/ide/detect-ide.ts checks ANTIGRAVITY_CLI_ALIAS as the
+  // canonical Antigravity marker. Listed before vscode-copilot.
+  ["antigravity", [
+    { name: "ANTIGRAVITY_CLI_ALIAS", role: "identification" },
+  ]],
+  // cursor (VSCode fork) — listed before vscode-copilot. CURSOR_TRACE_ID has
+  // 800+ hits in major OSS detection libs (Vercel Next.js, Bun, Google
+  // gemini-cli, Nx, CrewAI). CURSOR_CWD is the documented workspace var
+  // (issue #521) — listed first so workspace cascade picks it up.
+  ["cursor", [
+    { name: "CURSOR_CWD",       role: "workspace" },
+    { name: "CURSOR_TRACE_ID",  role: "identification" },
+    { name: "CURSOR_CLI",       role: "identification" },
+  ]],
+  // kilo (OpenCode fork) — Kilo-Org/kilocode packages/opencode/src/index.ts:138 + 139
+  // sets `process.env.KILO = 1` + `process.env.KILO_PID = String(process.pid)`.
+  ["kilo", [
+    { name: "KILO",     role: "identification" },
+    { name: "KILO_PID", role: "identification" },
+  ]],
+  // opencode — sst/opencode packages/opencode/src/index.ts:108-109 sets
+  // OPENCODE=1 + OPENCODE_PID=<pid> on CLI invocations. OpenCode desktop
+  // shells also expose OPENCODE_CLIENT=desktop and OPENCODE_TERMINAL=1.
+  // OPENCODE_PROJECT_DIR is the documented workspace var (consumed by the
+  // legacy resolver cascade) — listed first so the workspace cascade picks
+  // it up under strict mode.
+  ["opencode", [
+    { name: "OPENCODE_PROJECT_DIR", role: "workspace" },
+    { name: "OPENCODE_CLIENT",      role: "identification" },
+    { name: "OPENCODE_TERMINAL",    role: "identification" },
+    { name: "OPENCODE",             role: "identification" },
+    { name: "OPENCODE_PID",         role: "identification" },
+  ]],
+  // zed — zed-industries/zed crates/terminal/src/terminal.rs sets ZED_TERM=true
+  // in `insert_zed_terminal_env()`. Google's gemini-cli uses ZED_SESSION_ID.
+  ["zed", [
+    { name: "ZED_SESSION_ID", role: "identification" },
+    { name: "ZED_TERM",       role: "identification" },
+  ]],
+  // codex — openai/codex codex-rs/core/src/exec_env.rs sets CODEX_THREAD_ID
+  // per exec; unified_exec/process_manager.rs sets CODEX_CI in CI mode.
+  ["codex", [
+    { name: "CODEX_THREAD_ID", role: "identification" },
+    { name: "CODEX_CI",        role: "identification" },
+  ]],
+  // gemini-cli — GEMINI_PROJECT_DIR per google-gemini/gemini-cli
+  // docs/hooks/index.md; GEMINI_CLI is the MCP-server sentinel.
+  ["gemini-cli", [
+    { name: "GEMINI_PROJECT_DIR", role: "workspace" },
+    { name: "GEMINI_CLI",         role: "identification" },
+  ]],
+  // vscode-copilot — VSCODE_PID + VSCODE_CWD set by microsoft/vscode bootstrap.
+  // Listed AFTER cursor and antigravity since they inherit these vars as forks.
+  ["vscode-copilot", [
+    { name: "VSCODE_CWD", role: "workspace" },
+    { name: "VSCODE_PID", role: "identification" },
+  ]],
+  // jetbrains-copilot — IDEA_INITIAL_DIRECTORY set by JetBrains launcher.
+  // (IDEA_HOME and JETBRAINS_CLIENT_ID removed — no source-line evidence.)
+  ["jetbrains-copilot", [
+    { name: "IDEA_INITIAL_DIRECTORY", role: "workspace" },
+  ]],
+  // qwen-code — QWEN_PROJECT_DIR per QwenLM/qwen-code docs/users/features/hooks.md.
+  // (QWEN_SESSION_ID removed — 0 hits in qwen-code repository.)
+  ["qwen-code", [
+    { name: "QWEN_PROJECT_DIR", role: "workspace" },
+  ]],
+  // omp (can1357/oh-my-pi). PI_CODING_AGENT_DIR is the upstream
+  // agent-dir override per `packages/utils/src/dirs.ts:193`. Listed
+  // BEFORE pi so OMP is not misclassified as Pi when both are installed.
+  ["omp", [
+    { name: "PI_CODING_AGENT_DIR", role: "workspace" },
+  ]],
+  // pi — Issue #542 marker correction. PI_PROJECT_DIR is a consumer-set
+  // var (read by src/adapters/pi/extension.ts) but is NOT auto-set by
+  // the Pi runtime — verified against
+  //   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), 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.
+  // PI_WORKSPACE_DIR comes first (extension-set, freshest) before
+  // PI_PROJECT_DIR (user override) per registry-author cascade order.
+  ["pi", [
+    // Issue #545 — workspace vars set by Pi's bridge so resolveProjectDir
+    // under strict mode picks them up. detect=false because PI_*_DIR are
+    // consumer-set and must NOT misclassify a non-Pi host as Pi (#542).
+    { name: "PI_WORKSPACE_DIR", role: "workspace",      detect: false },
+    { name: "PI_PROJECT_DIR",   role: "workspace",      detect: false },
+    { 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).
+  // kiro — not listed (no auto-set process env vars; ~/.kiro/ config-dir tier).
+];
+
+export const PLATFORM_ENV_VARS: ReadonlyMap<PlatformId, readonly PlatformEnvEntry[]> = new Map(
+  _PLATFORM_ENV_VARS_RAW,
+);
+
+/**
+ * Backwards-compat shim: legacy `string[]` shape used by detection logic and
+ * by tests that iterate the registry to clear env vars. Always returns the
+ * names in registry order.
+ */
+export function getEnvVarNames(platform: PlatformId): string[] {
+  return (PLATFORM_ENV_VARS.get(platform) ?? []).map((e) => e.name);
+}
+
+/**
+ * Issue #545 — return only role=workspace env var names for a platform, in
+ * registry order. Empty array for adapters with no workspace var (e.g.
+ * codex, kilo, zed, antigravity, openclaw, kiro). Consumed by
+ * `resolveProjectDir({ strictPlatform })` to build the cascade.
+ */
+export function workspaceEnvVarsFor(platform: PlatformId): string[] {
+  return (PLATFORM_ENV_VARS.get(platform) ?? [])
+    .filter((e) => e.role === "workspace")
+    .map((e) => e.name);
+}
+
+/**
+ * Issue #545 — return the union of workspace env vars from ALL platforms
+ * EXCEPT the given one. Consumed by Pi's bridge env scrub (strip foreign
+ * workspace vars from spawned MCP child) and by the matrix regression test.
+ */
+export function foreignWorkspaceEnv(platform: PlatformId): Set<string> {
+  const ban = new Set<string>();
+  for (const [p, vars] of PLATFORM_ENV_VARS) {
+    if (p === platform) continue;
+    for (const v of vars) {
+      if (v.role === "workspace") ban.add(v.name);
+    }
+  }
+  return ban;
+}
+
+/**
+ * Issue #561 — return the union of identification env vars from ALL
+ * platforms EXCEPT the given one. Sibling of `foreignWorkspaceEnv`,
+ * filtered on `role === "identification"` instead of "workspace".
+ *
+ * Consumed by Pi's bridge env scrub: when Pi spawns the context-mode
+ * MCP child, the child inherits the host shell env including any
+ * identification vars set by a co-resident Claude Code session
+ * (CLAUDE_CODE_ENTRYPOINT / CLAUDE_PLUGIN_ROOT). Without scrubbing,
+ * `detectPlatform()` in the child falls through env priority order and
+ * resolves to claude-code first — Pi's session data then writes into
+ * `~/.claude/context-mode/` instead of Pi's own dir. Scrubbing FOREIGN
+ * identification vars (everyone else's) preserves Pi's OWN identification
+ * vars (PI_CONFIG_DIR / PI_SESSION_FILE / PI_COMPILED) so the child still
+ * detects pi correctly.
+ *
+ * Algorithmic, registry-driven — adding adapter #16 grows the scrub
+ * automatically (no edit to mcp-bridge.ts).
+ */
+export function foreignIdentificationEnv(platform: PlatformId): Set<string> {
+  const ban = new Set<string>();
+  for (const [p, vars] of PLATFORM_ENV_VARS) {
+    if (p === platform) continue;
+    for (const v of vars) {
+      if (v.role === "identification") ban.add(v.name);
+    }
+  }
+  return ban;
+}
+
+/**
+ * Sync map from platform identifier → home-relative path segments where that
+ * platform stores its config. Mirrors the `super([...])` argument passed by
+ * each adapter — kept in sync as the single source of truth used when we need
+ * a session dir BEFORE an adapter has been instantiated (race window between
+ * MCP server start and `initialize` handshake completion).
+ *
+ * Returns `null` for "unknown" or any string outside the supported set so the
+ * caller can decide on a safe fallback.
+ */
+export function getSessionDirSegments(platform: string): string[] | null {
+  switch (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"];
+    case "qwen-code":        return [".qwen"];
+    case "kimi":             return [".kimi-code"];
+    case "kilo":             return [".config", "kilo"];
+    case "opencode":         return [".config", "opencode"];
+    case "zed":              return [".config", "zed"];
+    case "jetbrains-copilot": return [".config", "JetBrains"];
+    default:                 return null;
+  }
+}
+
+/**
+ * Detect the current platform by checking env vars and config dirs.
+ *
+ * @param clientInfo - Optional MCP clientInfo from initialize handshake.
+ *   When provided, takes highest priority (zero-config detection).
+ */
+export function detectPlatform(clientInfo?: { name: string; version?: string }): DetectionSignal {
+  // ── Highest priority: MCP clientInfo ──────────────────
+  if (clientInfo?.name) {
+    const platform = CLIENT_NAME_TO_PLATFORM[clientInfo.name];
+    if (platform) {
+      return {
+        platform,
+        confidence: "high",
+        reason: `MCP clientInfo.name="${clientInfo.name}"`,
+      };
+    }
+    // Qwen Code uses dynamic client names: qwen-cli-mcp-client-<serverName>
+    if (clientInfo.name.startsWith("qwen-cli-mcp-client")) {
+      return {
+        platform: "qwen-code",
+        confidence: "high",
+        reason: `MCP clientInfo.name="${clientInfo.name}" (qwen-cli pattern)`,
+      };
+    }
+  }
+
+  // ── Explicit platform override ────────────────────────
+  const platformOverride = process.env.CONTEXT_MODE_PLATFORM;
+  if (platformOverride) {
+    const validPlatforms: PlatformId[] = [
+      "claude-code", "gemini-cli", "kilo", "opencode", "codex",
+      "vscode-copilot", "jetbrains-copilot", "copilot-cli", "cursor", "antigravity", "antigravity-cli", "kiro", "pi", "omp", "zed", "qwen-code", "kimi",
+    ];
+    if (validPlatforms.includes(platformOverride as PlatformId)) {
+      return {
+        platform: platformOverride as PlatformId,
+        confidence: "high",
+        reason: `CONTEXT_MODE_PLATFORM=${platformOverride} override`,
+      };
+    }
+  }
+
+  // ── High confidence: environment variables ─────────────
+
+  for (const [platform, vars] of PLATFORM_ENV_VARS) {
+    if (vars.some((v) => v.detect !== false && process.env[v.name])) {
+      // Issue #539 belt-and-suspenders: VSCODE_PID/VSCODE_CWD are exported
+      // by VS Code into EVERY child process — including a Claude Code CLI
+      // launched from the integrated terminal. If env vars alone want to
+      // resolve to vscode-copilot, but ~/.claude/plugins/installed_plugins.json
+      // lists context-mode as a Claude Code plugin, the runtime must be
+      // Claude Code (VS Code Copilot has no plugin concept). The env-var
+      // tier above already handles the common case via CLAUDE_CODE_ENTRYPOINT
+      // / CLAUDE_PLUGIN_ROOT; this branch covers MCP-server-only boots where
+      // those vars have not propagated yet.
+      if (platform === "vscode-copilot" && claudeCodeHasContextModePlugin()) {
+        return {
+          platform: "claude-code",
+          confidence: "high",
+          reason:
+            "VSCODE_PID set but ~/.claude/plugins/installed_plugins.json lists context-mode (issue #539 fallback)",
+        };
+      }
+      return {
+        platform,
+        confidence: "high",
+        reason: `${vars.filter((v) => v.detect !== false).map((v) => v.name).join(" or ")} env var set`,
+      };
+    }
+  }
+
+  // ── 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",
+      confidence: "medium",
+      reason: "~/.claude/ directory exists",
+    };
+  }
+
+  if (existsSync(resolve(home, ".gemini"))) {
+    return {
+      platform: "gemini-cli",
+      confidence: "medium",
+      reason: "~/.gemini/ directory exists",
+    };
+  }
+
+  if (existsSync(resolve(home, ".codex"))) {
+    return {
+      platform: "codex",
+      confidence: "medium",
+      reason: "~/.codex/ directory exists",
+    };
+  }
+
+  // Issue #542 — CLI agents BEFORE host IDEs.
+  //
+  // Cursor (a VSCode fork) is the most installed editor across our user
+  // base. Checking ~/.cursor/ first means every CLI agent co-installed
+  // with Cursor (Pi, OMP, Kiro, Qwen) silently routes through
+  // CursorAdapter even though the agent owns the session — Cursor merely
+  // hosts the terminal. Reorder: agents (.kiro/.omp/.pi/.qwen/.openclaw)
+  // win the medium-confidence tier, editors (~/.cursor/, ~/.vscode/,
+  // JetBrains) lose. Verified by the detect-config-dir.test.ts matrix.
+  if (existsSync(resolve(home, ".kiro"))) {
+    return {
+      platform: "kiro",
+      confidence: "medium",
+      reason: "~/.kiro/ directory exists",
+    };
+  }
+
+  // OMP listed BEFORE pi: shared ~/.pi history with OMP-only ~/.omp/ marker.
+  if (existsSync(resolve(home, ".omp"))) {
+    return {
+      platform: "omp",
+      confidence: "medium",
+      reason: "~/.omp/ directory exists",
+    };
+  }
+
+  if (existsSync(resolve(home, ".pi"))) {
+    return {
+      platform: "pi",
+      confidence: "medium",
+      reason: "~/.pi/ directory exists",
+    };
+  }
+
+  if (existsSync(resolve(home, ".qwen"))) {
+    return {
+      platform: "qwen-code",
+      confidence: "medium",
+      reason: "~/.qwen/ directory exists",
+    };
+  }
+
+  if (existsSync(resolve(home, ".kimi-code"))) {
+    return {
+      platform: "kimi",
+      confidence: "medium",
+      reason: "~/.kimi-code/ directory exists",
+    };
+  }
+
+  if (existsSync(resolve(home, ".openclaw"))) {
+    return {
+      platform: "openclaw",
+      confidence: "medium",
+      reason: "~/.openclaw/ directory exists",
+    };
+  }
+
+  // Cursor / host IDEs — checked AFTER all CLI agents (issue #542).
+  if (existsSync(resolve(home, ".cursor"))) {
+    return {
+      platform: "cursor",
+      confidence: "medium",
+      reason: "~/.cursor/ directory exists",
+    };
+  }
+
+  if (existsSync(resolve(home, ".config", "kilo"))) {
+    return {
+      platform: "kilo",
+      confidence: "medium",
+      reason: "~/.config/kilo/ directory exists",
+    };
+  }
+
+  if (existsSync(resolve(home, ".config", "JetBrains"))) {
+    return {
+      platform: "jetbrains-copilot",
+      confidence: "medium",
+      reason: "~/.config/JetBrains/ directory exists",
+    };
+  }
+
+  if (existsSync(resolve(home, ".config", "opencode"))) {
+    return {
+      platform: "opencode",
+      confidence: "medium",
+      reason: "~/.config/opencode/ directory exists",
+    };
+  }
+
+  if (existsSync(resolve(home, ".config", "zed"))) {
+    return {
+      platform: "zed",
+      confidence: "medium",
+      reason: "~/.config/zed/ directory exists",
+    };
+  }
+
+  // ── Low confidence: fallback ───────────────────────────
+
+  return {
+    platform: "claude-code",
+    confidence: "low",
+    reason: "No platform detected, defaulting to Claude Code",
+  };
+}
+
+/**
+ * Get the adapter instance for this fork's single supported host.
+ *
+ * Upstream resolved one of eighteen platform adapters here by dynamically
+ * importing each module. This fork targets DSH only, so those modules are gone
+ * and every path returns the DSH adapter. The `platform` argument is accepted
+ * for call-site compatibility and selects the neutral MCP-only storage
+ * segments that upstream used for hook-less hosts.
+ */
+export async function getAdapter(platform?: PlatformId): Promise<HookAdapter> {
+  const { DshAdapter } = await import("./dsh.js");
+  return new DshAdapter(platform ?? detectPlatform().platform);
+}