@wolfx/opencode-magic-context 0.21.8-patch.1

package/src/shared/conflict-fixer.test.ts

@@ -0,0 +1,124 @@
+/// <reference types="bun-types" />
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parse as parseJsonc } from "comment-json";
+import { fixConflicts } from "./conflict-fixer";
+
+const noOmoConflicts = {
+    omoPreemptiveCompaction: false,
+    omoContextWindowMonitor: false,
+    omoAnthropicRecovery: false,
+};
+
+describe("fixConflicts", () => {
+    let root: string;
+    let projectDir: string;
+    let userConfigDir: string;
+    let originalEnv: Record<string, string | undefined>;
+
+    beforeEach(() => {
+        root = mkdtempSync(join(tmpdir(), "mc-conflict-fixer-"));
+        projectDir = join(root, "project");
+        userConfigDir = join(root, "user-config", "opencode");
+        mkdirSync(projectDir, { recursive: true });
+        mkdirSync(userConfigDir, { recursive: true });
+        originalEnv = {
+            OPENCODE_CONFIG_DIR: process.env.OPENCODE_CONFIG_DIR,
+            XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
+        };
+        process.env.OPENCODE_CONFIG_DIR = userConfigDir;
+        delete process.env.XDG_CONFIG_HOME;
+    });
+
+    afterEach(() => {
+        for (const [key, value] of Object.entries(originalEnv)) {
+            if (value === undefined) delete process.env[key];
+            else process.env[key] = value;
+        }
+        rmSync(root, { recursive: true, force: true });
+    });
+
+    it("preserves JSONC comments and tuple plugin entries while removing canonical DCP", () => {
+        const configPath = join(projectDir, "opencode.jsonc");
+        writeFileSync(
+            configPath,
+            `{
+  // keep this file-level comment
+  "plugin": [
+    ["@plannotator/opencode@latest", { "workflow": "plan-agent" }],
+    ["@tarquinen/opencode-dcp@latest", { "enabled": true }],
+    "@wolfx/opencode-magic-context@latest"
+  ],
+  "compaction": {
+    // keep this compaction comment
+    "auto": true,
+    "prune": true
+  }
+}
+`,
+        );
+
+        const actions = fixConflicts(projectDir, {
+            compactionAuto: true,
+            compactionPrune: true,
+            dcpPlugin: true,
+            ...noOmoConflicts,
+        });
+
+        const updatedText = readFileSync(configPath, "utf-8");
+        const updated = parseJsonc(updatedText) as Record<string, unknown>;
+        expect(actions).toEqual(["Disabled auto-compaction", "Removed opencode-dcp plugin"]);
+        expect(updatedText).toContain("keep this file-level comment");
+        expect(updatedText).toContain("keep this compaction comment");
+        expect(updated.compaction).toEqual({ auto: false, prune: false });
+        expect(updated.plugin).toEqual([
+            ["@plannotator/opencode@latest", { workflow: "plan-agent" }],
+            "@wolfx/opencode-magic-context@latest",
+        ]);
+    });
+
+    it("skips non-existent target files instead of creating user config", () => {
+        const actions = fixConflicts(projectDir, {
+            compactionAuto: true,
+            compactionPrune: true,
+            dcpPlugin: true,
+            ...noOmoConflicts,
+        });
+
+        expect(actions).toEqual([]);
+        expect(existsSync(join(userConfigDir, "opencode.json"))).toBe(false);
+        expect(existsSync(join(userConfigDir, "opencode.jsonc"))).toBe(false);
+    });
+
+    it("keeps DCP forks and substring-only names because matching is canonical", () => {
+        const configPath = join(projectDir, "opencode.json");
+        writeFileSync(
+            configPath,
+            JSON.stringify({
+                plugin: [
+                    "@some-fork/opencode-dcp-fork",
+                    "file:///tmp/opencode-dcp-dev",
+                    ["@other/opencode-dcp-slim@latest", { enabled: true }],
+                ],
+            }),
+        );
+
+        const actions = fixConflicts(projectDir, {
+            compactionAuto: false,
+            compactionPrune: false,
+            dcpPlugin: true,
+            ...noOmoConflicts,
+        });
+
+        const updated = parseJsonc(readFileSync(configPath, "utf-8")) as Record<string, unknown>;
+        expect(actions).toEqual([]);
+        expect(updated.plugin).toEqual([
+            "@some-fork/opencode-dcp-fork",
+            "file:///tmp/opencode-dcp-dev",
+            ["@other/opencode-dcp-slim@latest", { enabled: true }],
+        ]);
+    });
+});

package/src/shared/conflict-fixer.ts

@@ -0,0 +1,222 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse, stringify } from "comment-json";
+
+import {
+    type ConflictResult,
+    DCP_PACKAGE_NAMES,
+    extractPluginName,
+    matchesPackageName,
+} from "./conflict-detector";
+import { getOpenCodeConfigPaths } from "./opencode-config-dir";
+
+type JsonObject = Record<string, unknown>;
+
+const CONFLICTING_OMO_HOOKS = [
+    "context-window-monitor",
+    "preemptive-compaction",
+    "anthropic-context-window-limit-recovery",
+] as const;
+
+const OMO_CONFIG_NAMES = [
+    "oh-my-openagent.jsonc",
+    "oh-my-openagent.json",
+    "oh-my-opencode.jsonc",
+    "oh-my-opencode.json",
+] as const;
+
+function isRecord(value: unknown): value is JsonObject {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function asStringArray(value: unknown): string[] {
+    return Array.isArray(value)
+        ? value.filter((item): item is string => typeof item === "string")
+        : [];
+}
+
+function readConfig(filePath: string): JsonObject | null {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+
+    try {
+        const parsed = parse(readFileSync(filePath, "utf-8"));
+        return isRecord(parsed) ? parsed : null;
+    } catch {
+        return null;
+    }
+}
+
+function writeConfig(filePath: string, config: JsonObject): void {
+    writeFileSync(filePath, `${stringify(config, null, 2)}\n`);
+}
+
+function resolveUserOpenCodeConfigPath(): string {
+    const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+    if (existsSync(paths.configJsonc)) return paths.configJsonc;
+    return paths.configJson;
+}
+
+function collectOpenCodeConfigPaths(directory: string): string[] {
+    const paths = new Set<string>();
+    const userConfig = resolveUserOpenCodeConfigPath();
+
+    if (existsSync(userConfig)) {
+        paths.add(userConfig);
+    }
+
+    for (const filePath of [
+        join(directory, ".opencode", "opencode.jsonc"),
+        join(directory, ".opencode", "opencode.json"),
+        join(directory, "opencode.jsonc"),
+        join(directory, "opencode.json"),
+    ]) {
+        if (existsSync(filePath)) {
+            paths.add(filePath);
+        }
+    }
+
+    return [...paths];
+}
+
+function collectOmoConfigPaths(directory: string): string[] {
+    const paths = new Set<string>();
+    const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
+
+    for (const fileName of OMO_CONFIG_NAMES) {
+        const userPath = join(configDir, fileName);
+        const projectPath = join(directory, fileName);
+
+        if (existsSync(userPath)) {
+            paths.add(userPath);
+        }
+
+        if (existsSync(projectPath)) {
+            paths.add(projectPath);
+        }
+    }
+
+    return [...paths];
+}
+
+function filterDcpPluginEntries(entries: unknown[]): { plugins: unknown[]; removed: boolean } {
+    const plugins = entries.filter((entry) => {
+        const name = extractPluginName(entry);
+        return name ? !matchesPackageName(name, DCP_PACKAGE_NAMES) : true;
+    });
+    return { plugins, removed: plugins.length !== entries.length };
+}
+
+export function fixConflicts(directory: string, conflicts: ConflictResult["conflicts"]): string[] {
+    const actions: string[] = [];
+    let updatedCompaction = false;
+    let removedDcpPlugin = false;
+    let disabledOmoHooks = false;
+
+    if (conflicts.compactionAuto || conflicts.compactionPrune || conflicts.dcpPlugin) {
+        for (const configPath of collectOpenCodeConfigPaths(directory)) {
+            const config = readConfig(configPath);
+            if (!config) {
+                continue;
+            }
+
+            let changed = false;
+
+            if (conflicts.compactionAuto || conflicts.compactionPrune) {
+                const compaction = isRecord(config.compaction) ? config.compaction : {};
+
+                if (compaction.auto !== false) {
+                    compaction.auto = false;
+                    changed = true;
+                    updatedCompaction = true;
+                }
+
+                if (compaction.prune !== false) {
+                    compaction.prune = false;
+                    changed = true;
+                    updatedCompaction = true;
+                }
+
+                config.compaction = compaction;
+            }
+
+            if (conflicts.dcpPlugin) {
+                const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+                const filtered = filterDcpPluginEntries(plugins);
+
+                if (filtered.removed) {
+                    config.plugin = filtered.plugins;
+                    changed = true;
+                    removedDcpPlugin = true;
+                }
+            }
+
+            if (changed) {
+                writeConfig(configPath, config);
+            }
+        }
+    }
+
+    if (
+        conflicts.omoContextWindowMonitor ||
+        conflicts.omoPreemptiveCompaction ||
+        conflicts.omoAnthropicRecovery
+    ) {
+        const hooksToDisable = new Set<string>();
+        if (conflicts.omoContextWindowMonitor) {
+            hooksToDisable.add("context-window-monitor");
+        }
+        if (conflicts.omoPreemptiveCompaction) {
+            hooksToDisable.add("preemptive-compaction");
+        }
+        if (conflicts.omoAnthropicRecovery) {
+            hooksToDisable.add("anthropic-context-window-limit-recovery");
+        }
+
+        for (const configPath of collectOmoConfigPaths(directory)) {
+            const config = readConfig(configPath);
+            if (!config) {
+                continue;
+            }
+
+            const disabledHooks = new Set(asStringArray(config.disabled_hooks));
+            let changed = false;
+
+            for (const hook of hooksToDisable) {
+                if (!disabledHooks.has(hook)) {
+                    disabledHooks.add(hook);
+                    changed = true;
+                    disabledOmoHooks = true;
+                }
+            }
+
+            if (changed) {
+                config.disabled_hooks = [
+                    ...CONFLICTING_OMO_HOOKS.filter((hook) => disabledHooks.has(hook)),
+                    ...[...disabledHooks].filter(
+                        (hook) =>
+                            !CONFLICTING_OMO_HOOKS.includes(
+                                hook as (typeof CONFLICTING_OMO_HOOKS)[number],
+                            ),
+                    ),
+                ];
+                writeConfig(configPath, config);
+            }
+        }
+    }
+
+    if (updatedCompaction) {
+        actions.push("Disabled auto-compaction");
+    }
+
+    if (removedDcpPlugin) {
+        actions.push("Removed opencode-dcp plugin");
+    }
+
+    if (disabledOmoHooks) {
+        actions.push("Disabled conflicting oh-my-opencode hooks");
+    }
+
+    return actions;
+}

package/src/shared/data-path.test.ts

@@ -0,0 +1,159 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+    getCacheDir,
+    getDataDir,
+    getLegacyOpenCodeMagicContextStorageDir,
+    getMagicContextStorageDir,
+    getOpenCodeCacheDir,
+    getOpenCodeStorageDir,
+    getProjectMagicContextDir,
+    getProjectMagicContextHistorianDir,
+} from "./data-path";
+
+const savedEnv = {
+    XDG_CACHE_HOME: process.env.XDG_CACHE_HOME,
+    XDG_DATA_HOME: process.env.XDG_DATA_HOME,
+    LOCALAPPDATA: process.env.LOCALAPPDATA,
+};
+
+describe("data-path", () => {
+    beforeEach(() => {
+        process.env.XDG_CACHE_HOME = undefined;
+        process.env.XDG_DATA_HOME = undefined;
+        process.env.LOCALAPPDATA = undefined;
+        // Bun's env handling: explicit delete for unset
+        delete process.env.XDG_CACHE_HOME;
+        delete process.env.XDG_DATA_HOME;
+        delete process.env.LOCALAPPDATA;
+    });
+
+    afterEach(() => {
+        if (savedEnv.XDG_CACHE_HOME !== undefined)
+            process.env.XDG_CACHE_HOME = savedEnv.XDG_CACHE_HOME;
+        if (savedEnv.XDG_DATA_HOME !== undefined)
+            process.env.XDG_DATA_HOME = savedEnv.XDG_DATA_HOME;
+        if (savedEnv.LOCALAPPDATA !== undefined) process.env.LOCALAPPDATA = savedEnv.LOCALAPPDATA;
+    });
+
+    test("getCacheDir falls back to <homedir>/.cache when XDG_CACHE_HOME is unset (all platforms)", () => {
+        // Matches OpenCode's xdg-basedir behavior on every platform, including
+        // Windows. A previous bug mapped Windows to %LOCALAPPDATA% and caused
+        // doctor --force to target a non-existent cache directory.
+        expect(getCacheDir()).toBe(path.join(os.homedir(), ".cache"));
+    });
+
+    test("getCacheDir honors XDG_CACHE_HOME when set", () => {
+        process.env.XDG_CACHE_HOME = "/tmp/custom-cache";
+        expect(getCacheDir()).toBe("/tmp/custom-cache");
+    });
+
+    test("getCacheDir ignores LOCALAPPDATA on Windows (must match OpenCode's xdg-basedir)", () => {
+        // Even with LOCALAPPDATA set, cache must go to ~/.cache to match
+        // OpenCode's own resolution. Otherwise doctor --force clears the
+        // wrong directory on Windows.
+        process.env.LOCALAPPDATA = "C:\\Users\\Test\\AppData\\Local";
+        expect(getCacheDir()).toBe(path.join(os.homedir(), ".cache"));
+    });
+
+    test("getOpenCodeCacheDir appends 'opencode' to the cache base", () => {
+        expect(getOpenCodeCacheDir()).toBe(path.join(os.homedir(), ".cache", "opencode"));
+    });
+
+    test("getOpenCodeCacheDir with XDG_CACHE_HOME set", () => {
+        process.env.XDG_CACHE_HOME = "/tmp/custom-cache";
+        expect(getOpenCodeCacheDir()).toBe(path.join("/tmp/custom-cache", "opencode"));
+    });
+
+    test("getDataDir falls back to <homedir>/.local/share when XDG_DATA_HOME is unset", () => {
+        expect(getDataDir()).toBe(path.join(os.homedir(), ".local", "share"));
+    });
+
+    test("getOpenCodeStorageDir composes correctly", () => {
+        expect(getOpenCodeStorageDir()).toBe(
+            path.join(os.homedir(), ".local", "share", "opencode", "storage"),
+        );
+    });
+
+    test("getMagicContextStorageDir uses cortexkit/magic-context layout", () => {
+        // Cross-harness shared path: both OpenCode and Pi plugins read/write here,
+        // unlike the legacy opencode/storage/plugin/magic-context location which
+        // was OpenCode-specific. See ARCHITECTURE_DECISIONS memory for rationale.
+        expect(getMagicContextStorageDir()).toBe(
+            path.join(os.homedir(), ".local", "share", "cortexkit", "magic-context"),
+        );
+    });
+
+    test("getMagicContextStorageDir honors XDG_DATA_HOME", () => {
+        process.env.XDG_DATA_HOME = "/tmp/custom-data";
+        expect(getMagicContextStorageDir()).toBe(
+            path.join("/tmp/custom-data", "cortexkit", "magic-context"),
+        );
+    });
+
+    test("getLegacyOpenCodeMagicContextStorageDir points at the pre-cortexkit OpenCode path", () => {
+        // Used only for one-time migration of pre-shared-storage data into the new
+        // location. Must remain stable so users with legacy installs can still
+        // have their data migrated forward across multiple plugin upgrades.
+        expect(getLegacyOpenCodeMagicContextStorageDir()).toBe(
+            path.join(
+                os.homedir(),
+                ".local",
+                "share",
+                "opencode",
+                "storage",
+                "plugin",
+                "magic-context",
+            ),
+        );
+    });
+
+    test("legacy storage dir distinct from new shared dir even with same XDG override", () => {
+        // Sanity check: even when XDG_DATA_HOME points the same place, the two
+        // resolvers must return different paths so the migration copy doesn't
+        // self-overwrite.
+        process.env.XDG_DATA_HOME = "/tmp/test-xdg";
+        const legacy = getLegacyOpenCodeMagicContextStorageDir();
+        const shared = getMagicContextStorageDir();
+        expect(legacy).not.toBe(shared);
+        expect(legacy).toContain("opencode");
+        expect(shared).toContain("cortexkit");
+    });
+
+    test("getProjectMagicContextDir composes <project>/.opencode/magic-context", () => {
+        // Project-local artifacts (historian state file, failure dumps) live
+        // inside the project so OpenCode's external_directory permission system
+        // treats them as project-internal. Without this, historian's Read tool
+        // would trigger a permission prompt on every run when artifacts lived
+        // under os.tmpdir().
+        expect(getProjectMagicContextDir("/Users/me/Work/proj")).toBe(
+            path.join("/Users/me/Work/proj", ".opencode", "magic-context"),
+        );
+    });
+
+    test("getProjectMagicContextHistorianDir appends historian/", () => {
+        expect(getProjectMagicContextHistorianDir("/Users/me/Work/proj")).toBe(
+            path.join("/Users/me/Work/proj", ".opencode", "magic-context", "historian"),
+        );
+    });
+
+    test("getProjectMagicContextDir is unaffected by XDG_DATA_HOME", () => {
+        // Project-local paths anchor to the project directory the caller
+        // passes in, NOT to any user-config env var. Setting XDG_DATA_HOME
+        // (which changes the shared storage dir) must not change the
+        // project-local historian dir.
+        process.env.XDG_DATA_HOME = "/tmp/custom-data";
+        expect(getProjectMagicContextDir("/some/project")).toBe(
+            path.join("/some/project", ".opencode", "magic-context"),
+        );
+    });
+
+    test("getProjectMagicContextDir handles trailing slashes via path.join", () => {
+        // path.join normalizes redundant separators so callers don't need to
+        // worry about how the project directory was constructed.
+        expect(getProjectMagicContextDir("/some/project/")).toBe(
+            path.join("/some/project/", ".opencode", "magic-context"),
+        );
+    });
+});

package/src/shared/data-path.ts

@@ -0,0 +1,155 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import { getHarness, type HarnessId } from "./harness";
+
+export function getDataDir(): string {
+    return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
+}
+
+/**
+ * Per-harness scratch directory under the OS temp dir.
+ *
+ * Layout:
+ *   - OpenCode: `${os.tmpdir()}/opencode/magic-context/`
+ *   - Pi:       `${os.tmpdir()}/pi/magic-context/`
+ *
+ * Why a per-harness subtree of `os.tmpdir()`:
+ *   1. OpenCode Desktop runs as an Electron app with a permission sandbox.
+ *      Writing to arbitrary tmp paths can trigger user-visible permission
+ *      prompts; the `${tmpdir}/opencode/` subtree is allow-listed by
+ *      OpenCode, so anything we put under it never asks for permission.
+ *   2. Splitting OpenCode from Pi keeps their logs and historian dump
+ *      directories cleanly separated. `doctor --issue` for each harness
+ *      reports diagnostics from the matching subtree, so an OpenCode
+ *      issue report never includes Pi log noise (and vice versa).
+ *   3. Pi has no permission sandbox, so the path choice is purely
+ *      cosmetic for Pi — it just keeps the layout symmetric.
+ *
+ * Pass an explicit `harness` only when the caller already knows the
+ * harness without relying on the global `setHarness()` state (e.g. the
+ * CLI's doctor commands, which target a specific harness regardless of
+ * which plugin is loaded). Production runtime callers should omit it so
+ * the helper picks up the boot-time harness automatically.
+ */
+export function getMagicContextTempDir(harness: HarnessId = getHarness()): string {
+    return path.join(os.tmpdir(), harness, "magic-context");
+}
+
+/**
+ * Standard log file path the plugin writes to. Pi and OpenCode write to
+ * SEPARATE logs under their respective harness subtrees so a single
+ * machine running both harnesses doesn't interleave session traces.
+ *
+ * The plugin's buffered logger calls this on every flush rather than
+ * caching, so `setHarness("pi")` taking effect after module load is
+ * reflected in the next flush.
+ */
+export function getMagicContextLogPath(harness: HarnessId = getHarness()): string {
+    return path.join(getMagicContextTempDir(harness), "magic-context.log");
+}
+
+/**
+ * Directory used for both historian validation-failure dumps and the
+ * existing-state offload XMLs that large historian/recomp passes write
+ * before invoking the model. Per-harness so dumps from different
+ * harnesses don't collide on filename and so `doctor --issue` for each
+ * harness reports only its own historian artifacts.
+ */
+export function getMagicContextHistorianDir(harness: HarnessId = getHarness()): string {
+    return path.join(getMagicContextTempDir(harness), "historian");
+}
+
+/**
+ * Project-local magic-context artifact directory.
+ *
+ * Layout: `<project-directory>/.opencode/magic-context/`
+ *
+ * Used for artifacts that the historian/recomp pipeline writes during a run
+ * and that the model is asked to read via its native Read tool. OpenCode's
+ * `external_directory` permission system asks the user before reading any
+ * file outside the project directory or its worktree, which interrupts every
+ * historian run when artifacts live under `os.tmpdir()`. Writing under the
+ * project's own `.opencode/` subtree falls inside the project boundary and
+ * never triggers a permission prompt.
+ *
+ * The `.opencode/` parent dir is OpenCode's own per-project convention (used
+ * for project-local config, plans, dumps, plugin installs). Anchoring
+ * magic-context artifacts under `.opencode/magic-context/` keeps them
+ * co-located with related OpenCode metadata and makes them easy for users to
+ * locate when debugging.
+ *
+ * Logger does NOT use this — log files stay in the per-harness tmp subtree
+ * because they are written by the plugin process itself (no model-side Read
+ * tool call, no permission prompt) and span sessions/projects.
+ */
+export function getProjectMagicContextDir(directory: string): string {
+    return path.join(directory, ".opencode", "magic-context");
+}
+
+/**
+ * Project-local historian artifact directory.
+ *
+ * Layout: `<project-directory>/.opencode/magic-context/historian/`
+ *
+ * Used for:
+ *   - existing-state offload XMLs that long historian/recomp passes write
+ *     before invoking the model (the model reads the file via Read tool)
+ *   - validation-failure dump XMLs preserved for debugging
+ *
+ * Callers must `mkdirSync(dir, { recursive: true })` before writing — the
+ * `.opencode/` parent may not exist on a fresh project, and write failures
+ * here must degrade gracefully (e.g. historian falls back to inline state).
+ */
+export function getProjectMagicContextHistorianDir(directory: string): string {
+    return path.join(getProjectMagicContextDir(directory), "historian");
+}
+
+export function getOpenCodeStorageDir(): string {
+    return path.join(getDataDir(), "opencode", "storage");
+}
+
+/**
+ * Resolve the shared magic-context storage directory.
+ *
+ * Magic-context's own data (compartments, facts, memories, embeddings, dream
+ * runs, notes, etc.) lives at this path regardless of which harness loaded the
+ * plugin (OpenCode or Pi). This enables:
+ *   - Shared project memories across harnesses
+ *   - Shared embedding cache
+ *   - Shared Dreamer runs (one per project per machine)
+ *   - Future cross-harness session migration
+ *
+ * Layout: <XDG_DATA_HOME>/cortexkit/magic-context/
+ */
+export function getMagicContextStorageDir(): string {
+    return path.join(getDataDir(), "cortexkit", "magic-context");
+}
+
+/**
+ * Legacy magic-context storage directory used by the OpenCode plugin before the
+ * shared cortexkit path. Used only for one-time migration of existing data into
+ * the new shared location. The legacy directory is left in place after copy so
+ * users can roll back if needed; manual cleanup is safe after one stable
+ * release.
+ */
+export function getLegacyOpenCodeMagicContextStorageDir(): string {
+    return path.join(getOpenCodeStorageDir(), "plugin", "magic-context");
+}
+
+/**
+ * Resolve OpenCode's cache base directory.
+ *
+ * OpenCode uses the `xdg-basedir` package, which — on every platform, including
+ * Windows — falls back to `<homedir>/.cache` when `XDG_CACHE_HOME` is unset.
+ * A previous Windows-specific branch that resolved to `%LOCALAPPDATA%` did not
+ * match OpenCode's own resolution and caused `doctor --force` to target a
+ * non-existent directory, leaving the real cache at `C:\Users\<user>\.cache`
+ * untouched.
+ */
+export function getCacheDir(): string {
+    return process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache");
+}
+
+export function getOpenCodeCacheDir(): string {
+    return path.join(getCacheDir(), "opencode");
+}