@mxalbert/context-mode 2.0.0

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

@@ -0,0 +1,342 @@
+/**
+ * adapters/antigravity-cli — Google Antigravity CLI (`agy`) adapter.
+ *
+ * Integration: MCP tools plus agy's Claude-compatible hook surface. `agy`
+ * reads its global MCP profile from `~/.gemini/config/mcp_config.json`
+ * (distinct from the Antigravity IDE's `~/.gemini/antigravity/mcp_config.json`)
+ * and hooks from `~/.gemini/config/hooks.json`, or from an installed agy
+ * plugin's root `hooks.json`.
+ *
+ * context-mode wires only the surfaces that have a verified mapping:
+ *   - PreToolUse for bounded routing enforcement on Bash/Read/Grep/WebFetch
+ *   - PostToolUse capture for executed tool calls
+ *   - best-effort Stop capture for session-end continuity when agy emits it
+ *
+ * PreInvocation/PostInvocation are intentionally not registered here: there is
+ * no verified payload/response contract or shared context-mode pipeline target
+ * for those agy events yet.
+ */
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { homedir } from "node:os";
+import { AntigravityAdapter } from "../antigravity/index.js";
+import { parseJsonc } from "../../util/jsonc.js";
+export function antigravityCliMcpConfigPath() {
+    return resolve(homedir(), ".gemini", "config", "mcp_config.json");
+}
+export function antigravityCliConfigDir() {
+    return resolve(homedir(), ".gemini", "antigravity-cli");
+}
+/** agy reads user hooks from ~/.gemini/config/hooks.json (sibling of mcp_config.json). */
+export function antigravityCliHooksPath() {
+    return resolve(homedir(), ".gemini", "config", "hooks.json");
+}
+/**
+ * `agy plugin install <bundle>` registers MCP + hook + skill into agy's plugin
+ * profile under ~/.gemini/config/plugins/<name>/ (verified on agy 1.0.6, re-verified 1.0.10) — the
+ * canonical install. The global mcp_config.json / hooks.json paths above are the
+ * manual (no-plugin) fallback. doctor must recognize BOTH.
+ */
+export function antigravityCliPluginDir() {
+    return resolve(homedir(), ".gemini", "config", "plugins", "context-mode");
+}
+function antigravityCliPluginMcpPath() {
+    return resolve(antigravityCliPluginDir(), "mcp_config.json");
+}
+function antigravityCliPluginHooksPath() {
+    return resolve(antigravityCliPluginDir(), "hooks.json");
+}
+/** True if context-mode's MCP is registered in any agy profile (plugin or global). */
+function readMcpRegistered(paths) {
+    for (const path of paths) {
+        try {
+            const config = parseJsonc(readFileSync(path, "utf-8")) ?? {};
+            const mcpServers = config?.mcpServers ?? {};
+            if ("context-mode" in mcpServers)
+                return { ok: true, where: path };
+        }
+        catch {
+            /* unreadable/missing — try next */
+        }
+    }
+    return { ok: false };
+}
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function agyProjectDir(raw) {
+    // Refs-backed FIRST: the only real upstream hook-payload example
+    // (refs/platforms/antigravity-cli/examples/title/title.sh:10, README.md:11)
+    // reads the working directory from `workspace.current_dir` — an OBJECT field,
+    // not an array. Prefer it.
+    const workspace = asRecord(raw.workspace);
+    if (typeof workspace.current_dir === "string" && workspace.current_dir) {
+        return workspace.current_dir;
+    }
+    // Fallback: `workspacePaths[0]` is empirically-derived/unverified (no upstream
+    // doc or example confirms this shape) — retained as a defensive fallback only.
+    const workspacePaths = raw.workspacePaths;
+    return Array.isArray(workspacePaths) && workspacePaths.length > 0
+        ? String(workspacePaths[0])
+        : undefined;
+}
+function agySessionId(raw) {
+    // `conversationId` is empirically-derived/unverified — no upstream agy doc or
+    // example confirms a session-id field in the hook payload. Kept as the
+    // best-available identifier; falls back to the process id when absent.
+    return typeof raw.conversationId === "string" && raw.conversationId
+        ? raw.conversationId
+        : `pid-${process.ppid}`;
+}
+function hookEntryHasCommand(entry, command) {
+    const e = asRecord(entry);
+    const nested = Array.isArray(e.hooks) ? e.hooks : [];
+    return nested.some((hook) => asRecord(hook).command === command);
+}
+function hookEntryJsonHasCommand(entry, command) {
+    return JSON.stringify(entry).includes(command);
+}
+function matcherCoversAgyPreToolUse(matcher) {
+    if (typeof matcher !== "string")
+        return false;
+    return ["run_command", "view_file", "grep_search", "web_fetch", "read_url_content"].every((tool) => matcher.includes(tool));
+}
+function hookGroupHasCommand(group, command) {
+    return Array.isArray(group) && group.some((entry) => hookEntryHasCommand(entry, command));
+}
+function hookGroupHasPreToolUse(group) {
+    return Array.isArray(group) && group.some((entry) => {
+        const e = asRecord(entry);
+        return matcherCoversAgyPreToolUse(e.matcher) && hookEntryHasCommand(entry, PRE_HOOK_COMMAND);
+    });
+}
+/** True if all context-mode agy hooks are registered in plugin/global profiles. */
+function readRegisteredHooks(paths) {
+    const found = { preOk: false, postOk: false, stopOk: false, where: undefined };
+    for (const path of paths) {
+        try {
+            const config = parseJsonc(readFileSync(path, "utf-8")) ?? {};
+            const hooks = config.hooks ?? {};
+            const preOk = hookGroupHasPreToolUse(hooks.PreToolUse);
+            const postOk = hookGroupHasCommand(hooks.PostToolUse, POST_HOOK_COMMAND);
+            const stopOk = hookGroupHasCommand(hooks.Stop, STOP_HOOK_COMMAND);
+            if ((preOk || postOk || stopOk) && !found.where)
+                found.where = path;
+            found.preOk ||= preOk;
+            found.postOk ||= postOk;
+            found.stopOk ||= stopOk;
+        }
+        catch {
+            /* unreadable/missing — try next */
+        }
+    }
+    // Stop is registered when possible, but agy 1.0.6 `-p` probes did not emit it
+    // (no Stop-hook change in agy's changelog through 1.0.10). Treat it as
+    // best-effort so doctor does not mark a working Pre/Post install
+    // as degraded solely because Stop is absent.
+    return { ...found, ok: found.preOk && found.postOk };
+}
+/** Dispatcher commands agy invokes from hooks.json. */
+const PRE_HOOK_COMMAND = "context-mode hook antigravity-cli pretooluse";
+const PRE_HOOK_MATCHER = "run_command|view_file|grep_search|web_fetch|read_url_content";
+const POST_HOOK_COMMAND = "context-mode hook antigravity-cli posttooluse";
+const STOP_HOOK_COMMAND = "context-mode hook antigravity-cli stop";
+// Keep in sync with the identical agyContextReason in hooks/core/formatters.mjs:
+// two copies exist because the bundled .mjs formatter (runtime hook path) and
+// this TS adapter are separate layers; the deny-reason text must not drift.
+function agyContextReason(additionalContext) {
+    const text = String(additionalContext ?? "")
+        .replace(/<\/?context_guidance>/g, " ")
+        .replace(/<\/?tip>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    return text
+        ? `context-mode: use the context-mode MCP tools instead of this native tool. ${text}`
+        : "context-mode: use the context-mode MCP tools instead of this native tool so raw bytes stay out of the conversation.";
+}
+function configureHookEntry(hooks, type, desired, command) {
+    const current = Array.isArray(hooks[type]) ? hooks[type] : [];
+    const desiredJson = JSON.stringify(desired);
+    const alreadyExact = current.some((entry) => JSON.stringify(entry) === desiredJson) &&
+        current.every((entry) => !hookEntryJsonHasCommand(entry, command) || JSON.stringify(entry) === desiredJson);
+    if (alreadyExact)
+        return false;
+    hooks[type] = [
+        ...current.filter((entry) => !hookEntryJsonHasCommand(entry, command)),
+        desired,
+    ];
+    return true;
+}
+export class AntigravityCliAdapter extends AntigravityAdapter {
+    name = "Antigravity CLI";
+    paradigm = "json-stdio";
+    capabilities = {
+        preToolUse: true,
+        postToolUse: true,
+        preCompact: false,
+        sessionStart: false,
+        canModifyArgs: false,
+        canModifyOutput: false,
+        canInjectSessionContext: false,
+    };
+    getSettingsPath() {
+        return antigravityCliMcpConfigPath();
+    }
+    getConfigDir(_projectDir) {
+        return antigravityCliConfigDir();
+    }
+    parsePreToolUseInput(raw) {
+        const payload = asRecord(raw);
+        const toolCall = asRecord(payload.toolCall);
+        return {
+            toolName: typeof toolCall.name === "string" ? toolCall.name : "",
+            toolInput: asRecord(toolCall.args),
+            sessionId: agySessionId(payload),
+            projectDir: agyProjectDir(payload),
+            raw,
+        };
+    }
+    parsePostToolUseInput(raw) {
+        const payload = asRecord(raw);
+        const toolCall = asRecord(payload.toolCall);
+        const error = typeof payload.error === "string" ? payload.error : "";
+        return {
+            toolName: typeof toolCall.name === "string" ? toolCall.name : "",
+            toolInput: asRecord(toolCall.args),
+            toolOutput: error,
+            isError: error.length > 0,
+            sessionId: agySessionId(payload),
+            projectDir: agyProjectDir(payload),
+            raw,
+        };
+    }
+    formatPreToolUseResponse(response) {
+        if (response.decision === "deny") {
+            return { decision: "deny", reason: response.reason ?? "Denied by context-mode" };
+        }
+        if (response.decision === "ask") {
+            // Fallback reason so a security-policy ask is never a bare prompt
+            // (mirrors hooks/core/formatters.mjs antigravity-cli.ask).
+            return {
+                decision: "ask",
+                reason: response.reason ?? "Action requires user confirmation",
+            };
+        }
+        if (response.decision === "context" && response.additionalContext) {
+            return {
+                decision: "deny",
+                reason: agyContextReason(response.additionalContext),
+            };
+        }
+        return null;
+    }
+    formatPostToolUseResponse(_response) {
+        return undefined;
+    }
+    checkPluginRegistration() {
+        // Accept the plugin profile (the canonical `agy plugin install` location,
+        // ~/.gemini/config/plugins/context-mode/mcp_config.json) OR the global
+        // mcp_config.json (the manual no-plugin fallback).
+        const { ok, where } = readMcpRegistered([
+            antigravityCliPluginMcpPath(),
+            this.getSettingsPath(),
+        ]);
+        if (ok) {
+            return {
+                check: "MCP registration",
+                status: "pass",
+                message: `context-mode found in Antigravity CLI mcpServers (${where})`,
+            };
+        }
+        return {
+            check: "MCP registration",
+            status: "fail",
+            message: "context-mode not found in Antigravity CLI mcpServers",
+            fix: "agy plugin install https://github.com/mksglu/context-mode/tree/main/configs/antigravity-cli",
+        };
+    }
+    getInstalledVersion() {
+        // Plugin install: read the real version from the installed plugin manifest so
+        // the doctor compares a true semver against npm latest (PASS when current,
+        // a meaningful "outdated bundle" WARN otherwise) — not the literal "configured"
+        // which produced the bogus "vconfigured, latest vX" line.
+        try {
+            const manifest = parseJsonc(readFileSync(resolve(antigravityCliPluginDir(), "plugin.json"), "utf-8"));
+            if (manifest && typeof manifest.version === "string" && manifest.version) {
+                return manifest.version;
+            }
+        }
+        catch {
+            /* not plugin-installed — fall through */
+        }
+        // Manual (global-profile) registration has no plugin manifest: report the
+        // version-less "standalone" MCP mode so doctor shows INFO, not a false WARN.
+        if (readMcpRegistered([this.getSettingsPath()]).ok)
+            return "standalone";
+        return "not installed";
+    }
+    /**
+     * Write/merge the agy hooks into ~/.gemini/config/hooks.json (manual,
+     * non-plugin path). Idempotent — unrelated hook entries are preserved.
+     */
+    configureAllHooks(_pluginRoot) {
+        const changes = [];
+        const hooksPath = antigravityCliHooksPath();
+        let config = {};
+        try {
+            config = parseJsonc(readFileSync(hooksPath, "utf-8")) ?? {};
+        }
+        catch {
+            /* fresh file */
+        }
+        const hooks = config.hooks ?? {};
+        const desiredPre = {
+            matcher: PRE_HOOK_MATCHER,
+            hooks: [{ type: "command", command: PRE_HOOK_COMMAND }],
+        };
+        const desiredPost = {
+            matcher: "",
+            hooks: [{ type: "command", command: POST_HOOK_COMMAND }],
+        };
+        const desiredStop = {
+            matcher: "",
+            hooks: [{ type: "command", command: STOP_HOOK_COMMAND }],
+        };
+        const changedPre = configureHookEntry(hooks, "PreToolUse", desiredPre, PRE_HOOK_COMMAND);
+        const changedPost = configureHookEntry(hooks, "PostToolUse", desiredPost, POST_HOOK_COMMAND);
+        const changedStop = configureHookEntry(hooks, "Stop", desiredStop, STOP_HOOK_COMMAND);
+        const changed = changedPre || changedPost || changedStop;
+        if (changed) {
+            config.hooks = hooks;
+            mkdirSync(dirname(hooksPath), { recursive: true });
+            writeFileSync(hooksPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+            changes.push(`Configured Antigravity CLI PreToolUse/PostToolUse hooks and best-effort Stop hook in ${hooksPath}`);
+        }
+        return changes;
+    }
+    /** Report agy hook status across plugin and manual profiles. */
+    validateHooks(_pluginRoot) {
+        // Accept the plugin profile (the canonical `agy plugin install` location,
+        // ~/.gemini/config/plugins/context-mode/hooks.json) OR the global hooks.json
+        // (the manual `context-mode upgrade` fallback).
+        const { ok, where, preOk, postOk, stopOk } = readRegisteredHooks([
+            antigravityCliPluginHooksPath(),
+            antigravityCliHooksPath(),
+        ]);
+        const missing = [
+            preOk ? null : "PreToolUse",
+            postOk ? null : "PostToolUse",
+            // Stop is best-effort; do not include it in the health gate.
+        ].filter(Boolean).join(", ");
+        return [
+            {
+                check: "Antigravity CLI hooks",
+                status: ok ? "pass" : "warn",
+                message: ok
+                    ? `PreToolUse guard and PostToolUse capture configured in ${where}${stopOk ? "; best-effort Stop hook also configured" : ""}`
+                    : `Antigravity CLI hooks incomplete (${missing || "none found"} missing) — MCP tools still work, but bounded routing enforcement and session capture are degraded. Run \`agy plugin install https://github.com/mksglu/context-mode/tree/main/configs/antigravity-cli\` or \`context-mode upgrade\` to repair hooks.`,
+                ...(ok ? {} : { fix: "agy plugin install https://github.com/mksglu/context-mode/tree/main/configs/antigravity-cli" }),
+            },
+        ];
+    }
+}

package/build/adapters/base.d.ts

@@ -0,0 +1,92 @@
+/**
+ * BaseAdapter — shared implementation for methods identical across all adapters.
+ *
+ * Each concrete adapter extends this and provides platform-specific logic.
+ *
+ * Shared methods:
+ *   - getSessionDir()       — builds session dir from sessionDirSegments
+ *   - backupSettings()      — copies settings file to .bak
+ *
+ * Adapters with custom logic override the relevant method:
+ *   - vscode-copilot: overrides getSessionDir (checks .github dir)
+ *   - opencode: overrides getSessionDir (XDG_CONFIG_HOME / APPDATA)
+ *              and backupSettings (calls checkPluginRegistration first)
+ *   - openclaw: overrides backupSettings (searches 3 config paths)
+ *
+ * NOTE — C2 narrowing (2026-05): `getSessionDBPath` and `getSessionEventsPath`
+ * were removed. Both were SHALLOW pure derivatives of `getSessionDir() +
+ * projectDir` (interface complexity == implementation complexity). All
+ * adapter-storage path computation now flows through ONE site:
+ * `resolveSessionDbPath({ projectDir, sessionsDir: adapter.getSessionDir() })`
+ * in `src/session/db.ts`. Adapters expose only `getSessionDir()` for
+ * storage-related path concerns.
+ *
+ * Issue #649 — `CONTEXT_MODE_DATA_DIR` universal storage override. Many
+ * adapters (Pi, OMP, Gemini CLI, Codex, Cursor, …) had storage hardcoded to
+ * `~/.<platform>/context-mode/sessions/` with no env-var escape hatch. CI
+ * runners on NFS homes, dev containers, and shared-workspace setups need to
+ * point context-mode storage at a writable volume without patching source or
+ * abusing the host platform's own config-dir variable. The override applies
+ * only to context-mode-owned state (`getSessionDir`, `getMemoryDir`) — never
+ * to platform-native config (`getConfigDir`, `getSettingsPath`), which must
+ * stay where the host platform's own tooling expects it. Adapters that
+ * override `getSessionDir`/`getMemoryDir` directly (claude-code, codex,
+ * opencode, vscode-copilot) honor the override by routing through
+ * `resolveContextModeDataRoot()` at the top of their override.
+ */
+/**
+ * Universal storage-root override. Returns the resolved absolute path when
+ * `CONTEXT_MODE_DATA_DIR` is set to a non-blank value, otherwise `null` so
+ * callers fall back to their platform-native default.
+ *
+ * Mirrors the `resolveClaudeConfigDir` contract for env-var handling
+ * (whitespace guard, tilde expansion, relative-path resolution) so users
+ * get one consistent set of rules across every override site.
+ */
+export declare function resolveContextModeDataRoot(env?: NodeJS.ProcessEnv): string | null;
+export declare abstract class BaseAdapter {
+    protected readonly sessionDirSegments: string[];
+    constructor(sessionDirSegments: string[]);
+    getSessionDir(): string;
+    /**
+     * Default: build config dir from sessionDirSegments rooted at $HOME.
+     *
+     * Contract: ALWAYS returns an absolute path. Adapters with project-scoped
+     * or non-home-rooted config dirs (cursor, vscode-copilot, jetbrains-copilot,
+     * openclaw, opencode) override this and resolve their segments against
+     * `projectDir` (or `process.cwd()` when omitted).
+     *
+     * NOT relocated by `CONTEXT_MODE_DATA_DIR` (#649). The platform owns its
+     * settings.json / hooks.json / config.toml location — relocating that
+     * would silently fork platform behaviour from the platform's own tooling.
+     * Use `CLAUDE_CONFIG_DIR`, `CODEX_HOME`, `XDG_CONFIG_HOME`, etc. to move
+     * platform-native config; use `CONTEXT_MODE_DATA_DIR` to move context-mode
+     * storage independently.
+     *
+     * @param _projectDir Unused by the home-rooted default — accepted so
+     *                    project-scoped overrides honor the same signature.
+     */
+    getConfigDir(_projectDir?: string): string;
+    /**
+     * Default: Claude Code convention. Most adapters override with their
+     * own platform-specific instruction file name (AGENTS.md, GEMINI.md, ...).
+     */
+    getInstructionFiles(): string[];
+    /**
+     * Default: <configDir>/memory/<projectHash>. Always absolute (configDir is
+     * absolute by contract). Adapters with a different memory dir name (e.g.,
+     * codex uses "memories" plural) override this.
+     *
+     * Issue #649: when `CONTEXT_MODE_DATA_DIR` is set, memory follows storage
+     * to `<DATA_DIR>/context-mode/memory/` since persistent memory is
+     * context-mode-owned state, not platform-native config.
+     *
+     * Issue #663: when `projectDir` is supplied the path is scoped via
+     * `hashProjectDirCanonical(projectDir)` so two projects running in
+     * parallel never share auto-memory contents. When omitted (legacy
+     * callers), the unscoped path is returned for backwards compatibility.
+     */
+    getMemoryDir(projectDir?: string): string;
+    backupSettings(): string | null;
+    abstract getSettingsPath(): string;
+}

package/build/adapters/base.js

@@ -0,0 +1,135 @@
+/**
+ * BaseAdapter — shared implementation for methods identical across all adapters.
+ *
+ * Each concrete adapter extends this and provides platform-specific logic.
+ *
+ * Shared methods:
+ *   - getSessionDir()       — builds session dir from sessionDirSegments
+ *   - backupSettings()      — copies settings file to .bak
+ *
+ * Adapters with custom logic override the relevant method:
+ *   - vscode-copilot: overrides getSessionDir (checks .github dir)
+ *   - opencode: overrides getSessionDir (XDG_CONFIG_HOME / APPDATA)
+ *              and backupSettings (calls checkPluginRegistration first)
+ *   - openclaw: overrides backupSettings (searches 3 config paths)
+ *
+ * NOTE — C2 narrowing (2026-05): `getSessionDBPath` and `getSessionEventsPath`
+ * were removed. Both were SHALLOW pure derivatives of `getSessionDir() +
+ * projectDir` (interface complexity == implementation complexity). All
+ * adapter-storage path computation now flows through ONE site:
+ * `resolveSessionDbPath({ projectDir, sessionsDir: adapter.getSessionDir() })`
+ * in `src/session/db.ts`. Adapters expose only `getSessionDir()` for
+ * storage-related path concerns.
+ *
+ * Issue #649 — `CONTEXT_MODE_DATA_DIR` universal storage override. Many
+ * adapters (Pi, OMP, Gemini CLI, Codex, Cursor, …) had storage hardcoded to
+ * `~/.<platform>/context-mode/sessions/` with no env-var escape hatch. CI
+ * runners on NFS homes, dev containers, and shared-workspace setups need to
+ * point context-mode storage at a writable volume without patching source or
+ * abusing the host platform's own config-dir variable. The override applies
+ * only to context-mode-owned state (`getSessionDir`, `getMemoryDir`) — never
+ * to platform-native config (`getConfigDir`, `getSettingsPath`), which must
+ * stay where the host platform's own tooling expects it. Adapters that
+ * override `getSessionDir`/`getMemoryDir` directly (claude-code, codex,
+ * opencode, vscode-copilot) honor the override by routing through
+ * `resolveContextModeDataRoot()` at the top of their override.
+ */
+import { join, resolve } from "node:path";
+import { accessSync, copyFileSync, constants, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { hashProjectDirCanonical } from "../session/db.js";
+/**
+ * Universal storage-root override. Returns the resolved absolute path when
+ * `CONTEXT_MODE_DATA_DIR` is set to a non-blank value, otherwise `null` so
+ * callers fall back to their platform-native default.
+ *
+ * Mirrors the `resolveClaudeConfigDir` contract for env-var handling
+ * (whitespace guard, tilde expansion, relative-path resolution) so users
+ * get one consistent set of rules across every override site.
+ */
+export function resolveContextModeDataRoot(env = process.env) {
+    const raw = env.CONTEXT_MODE_DATA_DIR;
+    if (!raw || raw.trim() === "")
+        return null;
+    if (raw.startsWith("~")) {
+        return resolve(homedir(), raw.replace(/^~[/\\]?/, ""));
+    }
+    return resolve(raw);
+}
+export class BaseAdapter {
+    sessionDirSegments;
+    constructor(sessionDirSegments) {
+        this.sessionDirSegments = sessionDirSegments;
+    }
+    getSessionDir() {
+        const override = resolveContextModeDataRoot();
+        const dir = override
+            ? join(override, "context-mode", "sessions")
+            : join(homedir(), ...this.sessionDirSegments, "context-mode", "sessions");
+        mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    /**
+     * Default: build config dir from sessionDirSegments rooted at $HOME.
+     *
+     * Contract: ALWAYS returns an absolute path. Adapters with project-scoped
+     * or non-home-rooted config dirs (cursor, vscode-copilot, jetbrains-copilot,
+     * openclaw, opencode) override this and resolve their segments against
+     * `projectDir` (or `process.cwd()` when omitted).
+     *
+     * NOT relocated by `CONTEXT_MODE_DATA_DIR` (#649). The platform owns its
+     * settings.json / hooks.json / config.toml location — relocating that
+     * would silently fork platform behaviour from the platform's own tooling.
+     * Use `CLAUDE_CONFIG_DIR`, `CODEX_HOME`, `XDG_CONFIG_HOME`, etc. to move
+     * platform-native config; use `CONTEXT_MODE_DATA_DIR` to move context-mode
+     * storage independently.
+     *
+     * @param _projectDir Unused by the home-rooted default — accepted so
+     *                    project-scoped overrides honor the same signature.
+     */
+    getConfigDir(_projectDir) {
+        return join(homedir(), ...this.sessionDirSegments);
+    }
+    /**
+     * Default: Claude Code convention. Most adapters override with their
+     * own platform-specific instruction file name (AGENTS.md, GEMINI.md, ...).
+     */
+    getInstructionFiles() {
+        return ["CLAUDE.md"];
+    }
+    /**
+     * Default: <configDir>/memory/<projectHash>. Always absolute (configDir is
+     * absolute by contract). Adapters with a different memory dir name (e.g.,
+     * codex uses "memories" plural) override this.
+     *
+     * Issue #649: when `CONTEXT_MODE_DATA_DIR` is set, memory follows storage
+     * to `<DATA_DIR>/context-mode/memory/` since persistent memory is
+     * context-mode-owned state, not platform-native config.
+     *
+     * Issue #663: when `projectDir` is supplied the path is scoped via
+     * `hashProjectDirCanonical(projectDir)` so two projects running in
+     * parallel never share auto-memory contents. When omitted (legacy
+     * callers), the unscoped path is returned for backwards compatibility.
+     */
+    getMemoryDir(projectDir) {
+        const override = resolveContextModeDataRoot();
+        const base = override
+            ? join(override, "context-mode", "memory")
+            : join(this.getConfigDir(), "memory");
+        if (!projectDir)
+            return base;
+        return join(base, hashProjectDirCanonical(projectDir));
+    }
+    backupSettings() {
+        const settingsPath = this.getSettingsPath();
+        try {
+            accessSync(settingsPath, constants.R_OK);
+            const backupPath = settingsPath + ".bak";
+            copyFileSync(settingsPath, backupPath);
+            return backupPath;
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/build/adapters/claude-code/config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * adapters/claude-code/config — Thin re-exports from ClaudeCodeAdapter.
+ *
+ * This module exists for backward compatibility. All logic lives in the
+ * adapter class (index.ts). New code should use getAdapter() from detect.ts.
+ */
+export { ClaudeCodeAdapter } from "./index.js";
+export { HOOK_TYPES, HOOK_SCRIPTS, PRE_TOOL_USE_MATCHER_PATTERN } from "./hooks.js";

package/build/adapters/claude-code/config.js

@@ -0,0 +1,8 @@
+/**
+ * adapters/claude-code/config — Thin re-exports from ClaudeCodeAdapter.
+ *
+ * This module exists for backward compatibility. All logic lives in the
+ * adapter class (index.ts). New code should use getAdapter() from detect.ts.
+ */
+export { ClaudeCodeAdapter } from "./index.js";
+export { HOOK_TYPES, HOOK_SCRIPTS, PRE_TOOL_USE_MATCHER_PATTERN } from "./hooks.js";