@cortexkit/opencode-magic-context 0.5.0 → 0.5.2

package/dist/cli/doctor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/cli/doctor.ts"],"names":[],"mappings":"AAWA,wBAAsB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAwHjD"}
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/cli/doctor.ts"],"names":[],"mappings":"AAYA,wBAAsB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAwHjD"}

package/dist/cli/setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/cli/setup.ts"],"names":[],"mappings":"AA4JA,wBAAsB,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAyPhD"}
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/cli/setup.ts"],"names":[],"mappings":"AA6JA,wBAAsB,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAyPhD"}

package/dist/cli.js

@@ -7849,8 +7849,8 @@ var require_src3 = __commonJS((exports, module) => {
 });
 
 // src/cli/doctor.ts
-var import_comment_json3 = __toESM(require_src2(), 1);
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+var import_comment_json2 = __toESM(require_src2(), 1);
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
 
 // src/shared/conflict-detector.ts
 import { join as join2 } from "node:path";
@@ -8152,8 +8152,7 @@ function readOmoDisabledHooks(directory) {
 }
 
 // src/shared/conflict-fixer.ts
-var import_comment_json = __toESM(require_src2(), 1);
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join as join3 } from "node:path";
 var CONFLICTING_OMO_HOOKS = [
   "context-window-monitor",
@@ -8179,16 +8178,11 @@ function readConfig(filePath) {
   if (!existsSync2(filePath)) {
     return {};
   }
-  try {
-    const raw = readFileSync2(filePath, "utf-8");
-    return import_comment_json.parse(raw);
-  } catch {
-    return null;
-  }
+  return readJsoncFile(filePath);
 }
 function writeConfig(filePath, config) {
   ensureParentDir(filePath);
-  writeFileSync(filePath, `${import_comment_json.stringify(config, null, 2)}
+  writeFileSync(filePath, `${JSON.stringify(config, null, 2)}
 `);
 }
 function resolveUserOpenCodeConfigPath() {
@@ -8318,8 +8312,8 @@ function fixConflicts(directory, conflicts) {
 }
 
 // src/shared/tui-config.ts
-var import_comment_json2 = __toESM(require_src2(), 1);
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+var import_comment_json = __toESM(require_src2(), 1);
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname2, join as join5 } from "node:path";
 
 // src/shared/logger.ts
@@ -8374,6 +8368,7 @@ if (!isTestEnv) {
 
 // src/shared/tui-config.ts
 var PLUGIN_NAME = "@cortexkit/opencode-magic-context";
+var PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
 function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
   const jsoncPath = join5(configDir, "tui.jsonc");
@@ -8389,17 +8384,17 @@ function ensureTuiPluginEntry() {
     const configPath = resolveTuiConfigPath();
     let config = {};
     if (existsSync3(configPath)) {
-      const raw = readFileSync3(configPath, "utf-8");
-      config = import_comment_json2.parse(raw) ?? {};
+      const raw = readFileSync2(configPath, "utf-8");
+      config = import_comment_json.parse(raw) ?? {};
     }
     const plugins = Array.isArray(config.plugin) ? config.plugin.filter((p) => typeof p === "string") : [];
     if (plugins.some((p) => p === PLUGIN_NAME || p.startsWith(`${PLUGIN_NAME}@`))) {
       return false;
     }
-    plugins.push(PLUGIN_NAME);
+    plugins.push(PLUGIN_ENTRY);
     config.plugin = plugins;
     mkdirSync2(dirname2(configPath), { recursive: true });
-    writeFileSync2(configPath, `${import_comment_json2.stringify(config, null, 2)}
+    writeFileSync2(configPath, `${import_comment_json.stringify(config, null, 2)}
 `);
     log(`[magic-context] added TUI plugin entry to ${configPath}`);
     return true;
@@ -9601,6 +9596,7 @@ async function selectOne(message, options) {
 
 // src/cli/doctor.ts
 var PLUGIN_NAME2 = "@cortexkit/opencode-magic-context";
+var PLUGIN_ENTRY_WITH_VERSION = `${PLUGIN_NAME2}@latest`;
 async function runDoctor() {
   Wt2("Magic Context Doctor");
   let issues = 0;
@@ -9626,17 +9622,17 @@ async function runDoctor() {
   }
   if (paths.opencodeConfigFormat !== "none") {
     try {
-      const raw = readFileSync4(paths.opencodeConfig, "utf-8");
-      const config = import_comment_json3.parse(raw);
+      const raw = readFileSync3(paths.opencodeConfig, "utf-8");
+      const config = import_comment_json2.parse(raw);
       const plugins = Array.isArray(config?.plugin) ? config.plugin : [];
       const hasPlugin = plugins.some((p) => typeof p === "string" && (p === PLUGIN_NAME2 || p.startsWith(`${PLUGIN_NAME2}@`) || p.includes("opencode-magic-context")));
       const configName = paths.opencodeConfigFormat === "jsonc" ? "opencode.jsonc" : "opencode.json";
       if (hasPlugin) {
         R2.success(`Plugin registered in ${configName}`);
       } else {
-        const updatedPlugins = [...plugins, PLUGIN_NAME2];
+        const updatedPlugins = [...plugins, PLUGIN_ENTRY_WITH_VERSION];
         config.plugin = updatedPlugins;
-        writeFileSync3(paths.opencodeConfig, `${import_comment_json3.stringify(config, null, 2)}
+        writeFileSync3(paths.opencodeConfig, `${import_comment_json2.stringify(config, null, 2)}
 `);
         R2.success(`Added plugin to ${configName}`);
         fixed++;
@@ -9693,19 +9689,20 @@ async function runDoctor() {
 }
 
 // src/cli/setup.ts
-var import_comment_json4 = __toESM(require_src2(), 1);
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+var import_comment_json3 = __toESM(require_src2(), 1);
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname as dirname3 } from "node:path";
 var PLUGIN_NAME3 = "@cortexkit/opencode-magic-context";
+var PLUGIN_ENTRY2 = "@cortexkit/opencode-magic-context@latest";
 function ensureDir(dir) {
   if (!existsSync6(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
 }
 function readJsonc(path2) {
-  const content = readFileSync5(path2, "utf-8");
+  const content = readFileSync4(path2, "utf-8");
   try {
-    return import_comment_json4.parse(content);
+    return import_comment_json3.parse(content);
   } catch (err) {
     console.error(`  ⚠ Failed to parse ${path2}: ${err instanceof Error ? err.message : err}`);
     return null;
@@ -9715,10 +9712,10 @@ function addPluginToOpenCodeConfig(configPath, format) {
   ensureDir(dirname3(configPath));
   if (format === "none") {
     const config = {
-      plugin: [PLUGIN_NAME3],
+      plugin: [PLUGIN_ENTRY2],
       compaction: { auto: false, prune: false }
     };
-    writeFileSync4(configPath, `${import_comment_json4.stringify(config, null, 2)}
+    writeFileSync4(configPath, `${import_comment_json3.stringify(config, null, 2)}
 `);
     return;
   }
@@ -9730,20 +9727,20 @@ function addPluginToOpenCodeConfig(configPath, format) {
   const plugins = existing.plugin ?? [];
   const hasPlugin = plugins.some((p) => p === PLUGIN_NAME3 || p.startsWith(`${PLUGIN_NAME3}@`));
   if (!hasPlugin) {
-    plugins.push(PLUGIN_NAME3);
+    plugins.push(PLUGIN_ENTRY2);
   }
   existing.plugin = plugins;
   const compaction = existing.compaction ?? {};
   compaction.auto = false;
   compaction.prune = false;
   existing.compaction = compaction;
-  writeFileSync4(configPath, `${import_comment_json4.stringify(existing, null, 2)}
+  writeFileSync4(configPath, `${import_comment_json3.stringify(existing, null, 2)}
 `);
 }
 function addPluginToTuiConfig(configPath, format) {
   ensureDir(dirname3(configPath));
   if (format === "none") {
-    writeFileSync4(configPath, `${import_comment_json4.stringify({ plugin: [PLUGIN_NAME3] }, null, 2)}
+    writeFileSync4(configPath, `${import_comment_json3.stringify({ plugin: [PLUGIN_ENTRY2] }, null, 2)}
 `);
     return;
   }
@@ -9755,10 +9752,10 @@ function addPluginToTuiConfig(configPath, format) {
   const plugins = existing.plugin ?? [];
   const hasPlugin = plugins.some((p) => p === PLUGIN_NAME3 || p.startsWith(`${PLUGIN_NAME3}@`));
   if (!hasPlugin) {
-    plugins.push(PLUGIN_NAME3);
+    plugins.push(PLUGIN_ENTRY2);
   }
   existing.plugin = plugins;
-  writeFileSync4(configPath, `${import_comment_json4.stringify(existing, null, 2)}
+  writeFileSync4(configPath, `${import_comment_json3.stringify(existing, null, 2)}
 `);
 }
 function writeMagicContextConfig(configPath, options) {
@@ -9799,7 +9796,7 @@ function writeMagicContextConfig(configPath, options) {
     cacheTtl["anthropic/claude-opus-4-6"] = "59m";
     config.cache_ttl = cacheTtl;
   }
-  writeFileSync4(configPath, `${import_comment_json4.stringify(config, null, 2)}
+  writeFileSync4(configPath, `${import_comment_json3.stringify(config, null, 2)}
 `);
 }
 async function runSetup() {
@@ -9846,7 +9843,7 @@ async function runSetup() {
         if (shouldRemove) {
           plugins.splice(dcpIndex, 1);
           ocConfig.plugin = plugins;
-          writeFileSync4(paths.opencodeConfig, `${import_comment_json4.stringify(ocConfig, null, 2)}
+          writeFileSync4(paths.opencodeConfig, `${import_comment_json3.stringify(ocConfig, null, 2)}
 `);
           R2.success("Removed opencode-dcp from plugin list");
         } else {

package/dist/index.js

@@ -8502,7 +8502,7 @@ function ensureTuiPluginEntry() {
     if (plugins.some((p) => p === PLUGIN_NAME || p.startsWith(`${PLUGIN_NAME}@`))) {
       return false;
     }
-    plugins.push(PLUGIN_NAME);
+    plugins.push(PLUGIN_ENTRY);
     config2.plugin = plugins;
     mkdirSync3(dirname(configPath), { recursive: true });
     writeFileSync2(configPath, `${import_comment_json.stringify(config2, null, 2)}
@@ -8514,11 +8514,12 @@ function ensureTuiPluginEntry() {
     return false;
   }
 }
-var import_comment_json, PLUGIN_NAME = "@cortexkit/opencode-magic-context";
+var import_comment_json, PLUGIN_NAME = "@cortexkit/opencode-magic-context", PLUGIN_ENTRY;
 var init_tui_config = __esm(() => {
   init_logger();
   init_opencode_config_dir();
   import_comment_json = __toESM(require_src2(), 1);
+  PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
 });
 
 // src/agents/dreamer.ts

package/dist/shared/conflict-fixer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conflict-fixer.d.ts","sourceRoot":"","sources":["../../src/shared/conflict-fixer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAmG1D,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,CAAC,WAAW,CAAC,GAAG,MAAM,EAAE,CAiHhG"}
+{"version":3,"file":"conflict-fixer.d.ts","sourceRoot":"","sources":["../../src/shared/conflict-fixer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAmG1D,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,CAAC,WAAW,CAAC,GAAG,MAAM,EAAE,CAiHhG"}

package/dist/shared/tui-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tui-config.d.ts","sourceRoot":"","sources":["../../src/shared/tui-config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAoBH;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA+B9C"}
+{"version":3,"file":"tui-config.d.ts","sourceRoot":"","sources":["../../src/shared/tui-config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAqBH;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA+B9C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",
@@ -28,6 +28,7 @@
   "files": [
     "dist",
     "src/tui",
+    "src/shared",
     "README.md"
   ],
   "scripts": {

package/src/shared/assistant-message-extractor.ts

@@ -0,0 +1,74 @@
+type MessageTime = { created?: number };
+
+type MessageInfo = {
+    role?: string;
+    time?: MessageTime;
+};
+
+type MessagePart = {
+    type?: string;
+    text?: string;
+};
+
+type SessionMessage = {
+    info?: MessageInfo;
+    parts?: unknown;
+};
+
+import { isRecord } from "./record-type-guard";
+
+function asSessionMessage(value: unknown): SessionMessage | null {
+    if (!isRecord(value)) return null;
+    const info = value.info;
+    const parts = value.parts;
+    return {
+        info: isRecord(info)
+            ? {
+                  role: typeof info.role === "string" ? info.role : undefined,
+                  time: isRecord(info.time)
+                      ? {
+                            created:
+                                typeof info.time.created === "number"
+                                    ? info.time.created
+                                    : undefined,
+                        }
+                      : undefined,
+              }
+            : undefined,
+        parts,
+    };
+}
+
+function getCreatedTime(message: SessionMessage): number {
+    return message.info?.time?.created ?? 0;
+}
+
+function getTextParts(message: SessionMessage): MessagePart[] {
+    if (!Array.isArray(message.parts)) return [];
+    return message.parts
+        .filter((part): part is Record<string, unknown> => isRecord(part))
+        .map((part) => ({
+            type: typeof part.type === "string" ? part.type : undefined,
+            text: typeof part.text === "string" ? part.text : undefined,
+        }))
+        .filter((part) => part.type === "text" && Boolean(part.text));
+}
+
+export function extractLatestAssistantText(messages: unknown): string | null {
+    if (!Array.isArray(messages) || messages.length === 0) return null;
+
+    const assistantMessages = messages
+        .map(asSessionMessage)
+        .filter((message): message is SessionMessage => message !== null)
+        .filter((message) => message.info?.role === "assistant")
+        .sort((a, b) => getCreatedTime(b) - getCreatedTime(a));
+
+    const latest = assistantMessages[0];
+    if (!latest) return null;
+
+    return (
+        getTextParts(latest)
+            .map((part) => part.text)
+            .join("\n") || null
+    );
+}

package/src/shared/conflict-detector.ts

@@ -0,0 +1,310 @@
+import { join } from "node:path";
+import { readJsoncFile } from "./jsonc-parser";
+import { getOpenCodeConfigPaths } from "./opencode-config-dir";
+
+interface OpenCodeConfig {
+    compaction?: {
+        auto?: boolean;
+        prune?: boolean;
+    };
+    plugin?: string[];
+}
+
+interface OmoConfig {
+    disabled_hooks?: string[];
+}
+
+export interface ConflictResult {
+    /** Whether any blocking conflict was found */
+    hasConflict: boolean;
+    /** Human-readable reasons for each conflict */
+    reasons: string[];
+    /** Which conflicts were found — used for targeted fixes */
+    conflicts: {
+        compactionAuto: boolean;
+        compactionPrune: boolean;
+        dcpPlugin: boolean;
+        omoPreemptiveCompaction: boolean;
+        omoContextWindowMonitor: boolean;
+        omoAnthropicRecovery: boolean;
+    };
+}
+
+/**
+ * Detect all conflicts that would prevent magic-context from working correctly.
+ * Checks: OpenCode compaction, DCP plugin, OMO conflicting hooks.
+ */
+export function detectConflicts(directory: string): ConflictResult {
+    const conflicts: ConflictResult["conflicts"] = {
+        compactionAuto: false,
+        compactionPrune: false,
+        dcpPlugin: false,
+        omoPreemptiveCompaction: false,
+        omoContextWindowMonitor: false,
+        omoAnthropicRecovery: false,
+    };
+    const reasons: string[] = [];
+
+    // --- Check OpenCode compaction config ---
+    const compactionResult = checkCompaction(directory);
+    if (compactionResult.auto) {
+        conflicts.compactionAuto = true;
+        reasons.push("OpenCode auto-compaction is enabled (compaction.auto=true)");
+    }
+    if (compactionResult.prune) {
+        conflicts.compactionPrune = true;
+        reasons.push("OpenCode prune is enabled (compaction.prune=true)");
+    }
+
+    // --- Check for DCP plugin ---
+    const dcpFound = checkDcpPlugin(directory);
+    if (dcpFound) {
+        conflicts.dcpPlugin = true;
+        reasons.push(
+            "opencode-dcp plugin is installed — it conflicts with Magic Context's context management",
+        );
+    }
+
+    // --- Check OMO conflicting hooks ---
+    const omoResult = checkOmoHooks(directory);
+    if (omoResult.preemptiveCompaction) {
+        conflicts.omoPreemptiveCompaction = true;
+        reasons.push(
+            "oh-my-opencode preemptive-compaction hook is active — it triggers compaction that conflicts with historian",
+        );
+    }
+    if (omoResult.contextWindowMonitor) {
+        conflicts.omoContextWindowMonitor = true;
+        reasons.push(
+            "oh-my-opencode context-window-monitor hook is active — it injects usage warnings that overlap with Magic Context nudges",
+        );
+    }
+    if (omoResult.anthropicRecovery) {
+        conflicts.omoAnthropicRecovery = true;
+        reasons.push(
+            "oh-my-opencode anthropic-context-window-limit-recovery hook is active — it triggers emergency compaction that bypasses historian",
+        );
+    }
+
+    return {
+        hasConflict: reasons.length > 0,
+        reasons,
+        conflicts,
+    };
+}
+
+// --- Compaction detection (extracted from opencode-compaction-detector.ts) ---
+
+function checkCompaction(directory: string): { auto: boolean; prune: boolean } {
+    if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
+        return { auto: false, prune: false };
+    }
+
+    // Check project-level config first (higher precedence)
+    const projectResult = readProjectCompaction(directory);
+    if (projectResult.resolved) return projectResult;
+
+    // Fall back to user-level config
+    const userResult = readUserCompaction();
+    if (userResult.resolved) return userResult;
+
+    // Default: OpenCode has compaction enabled by default
+    return { auto: true, prune: false };
+}
+
+function readProjectCompaction(directory: string): {
+    auto: boolean;
+    prune: boolean;
+    resolved: boolean;
+} {
+    // .opencode/ config has higher precedence
+    const dotOcJsonc = join(directory, ".opencode", "opencode.jsonc");
+    const dotOcJson = join(directory, ".opencode", "opencode.json");
+    const dotOcConfig =
+        readJsoncFile<OpenCodeConfig>(dotOcJsonc) ?? readJsoncFile<OpenCodeConfig>(dotOcJson);
+
+    if (dotOcConfig?.compaction) {
+        const c = dotOcConfig.compaction;
+        if (c.auto !== undefined || c.prune !== undefined) {
+            return { auto: c.auto === true, prune: c.prune === true, resolved: true };
+        }
+    }
+
+    // Root-level project config
+    const rootJsonc = join(directory, "opencode.jsonc");
+    const rootJson = join(directory, "opencode.json");
+    const rootConfig =
+        readJsoncFile<OpenCodeConfig>(rootJsonc) ?? readJsoncFile<OpenCodeConfig>(rootJson);
+
+    if (rootConfig?.compaction) {
+        const c = rootConfig.compaction;
+        if (c.auto !== undefined || c.prune !== undefined) {
+            return { auto: c.auto === true, prune: c.prune === true, resolved: true };
+        }
+    }
+
+    return { auto: false, prune: false, resolved: false };
+}
+
+function readUserCompaction(): { auto: boolean; prune: boolean; resolved: boolean } {
+    try {
+        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+        const config =
+            readJsoncFile<OpenCodeConfig>(paths.configJsonc) ??
+            readJsoncFile<OpenCodeConfig>(paths.configJson);
+
+        if (config?.compaction) {
+            const c = config.compaction;
+            if (c.auto !== undefined || c.prune !== undefined) {
+                return { auto: c.auto === true, prune: c.prune === true, resolved: true };
+            }
+        }
+    } catch {
+        // Intentional: config read is best-effort
+    }
+    return { auto: false, prune: false, resolved: false };
+}
+
+// --- DCP detection ---
+
+function checkDcpPlugin(directory: string): boolean {
+    const plugins = collectPluginEntries(directory);
+    return plugins.some((p) => p.includes("opencode-dcp"));
+}
+
+function collectPluginEntries(directory: string): string[] {
+    const plugins: string[] = [];
+
+    // Project-level configs
+    for (const configPath of [
+        join(directory, ".opencode", "opencode.jsonc"),
+        join(directory, ".opencode", "opencode.json"),
+        join(directory, "opencode.jsonc"),
+        join(directory, "opencode.json"),
+    ]) {
+        const config = readJsoncFile<OpenCodeConfig>(configPath);
+        if (config?.plugin) {
+            plugins.push(...config.plugin);
+        }
+    }
+
+    // User-level config
+    try {
+        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+        for (const configPath of [paths.configJsonc, paths.configJson]) {
+            const config = readJsoncFile<OpenCodeConfig>(configPath);
+            if (config?.plugin) {
+                plugins.push(...config.plugin);
+            }
+        }
+    } catch {
+        // best-effort
+    }
+
+    return plugins;
+}
+
+// --- OMO hook detection ---
+
+function checkOmoHooks(directory: string): {
+    preemptiveCompaction: boolean;
+    contextWindowMonitor: boolean;
+    anthropicRecovery: boolean;
+} {
+    const result = {
+        preemptiveCompaction: false,
+        contextWindowMonitor: false,
+        anthropicRecovery: false,
+    };
+
+    // First check if OMO is even installed
+    const plugins = collectPluginEntries(directory);
+    const hasOmo = plugins.some(
+        (p) =>
+            p.includes("oh-my-opencode") ||
+            p.includes("oh-my-openagent") ||
+            p.includes("@code-yeongyu/"),
+    );
+    if (!hasOmo) return result;
+
+    // Read OMO config to check disabled_hooks
+    const disabledHooks = readOmoDisabledHooks(directory);
+
+    // Hooks are ACTIVE unless explicitly in disabled_hooks
+    result.preemptiveCompaction = !disabledHooks.has("preemptive-compaction");
+    result.contextWindowMonitor = !disabledHooks.has("context-window-monitor");
+    result.anthropicRecovery = !disabledHooks.has("anthropic-context-window-limit-recovery");
+
+    return result;
+}
+
+function readOmoDisabledHooks(directory: string): Set<string> {
+    const disabled = new Set<string>();
+
+    // Check both old and new OMO config names
+    const configNames = [
+        "oh-my-opencode.jsonc",
+        "oh-my-opencode.json",
+        "oh-my-openagent.jsonc",
+        "oh-my-openagent.json",
+    ];
+
+    try {
+        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+        for (const name of configNames) {
+            const configPath = join(paths.configDir, name);
+            const config = readJsoncFile<OmoConfig>(configPath);
+            if (config?.disabled_hooks) {
+                for (const hook of config.disabled_hooks) {
+                    disabled.add(hook);
+                }
+            }
+        }
+    } catch {
+        // best-effort
+    }
+
+    // Also check project-level OMO configs
+    for (const name of configNames) {
+        const config = readJsoncFile<OmoConfig>(join(directory, name));
+        if (config?.disabled_hooks) {
+            for (const hook of config.disabled_hooks) {
+                disabled.add(hook);
+            }
+        }
+    }
+
+    return disabled;
+}
+
+/**
+ * Generate a user-facing summary of conflicts for display in dialogs/notifications.
+ */
+export function formatConflictSummary(result: ConflictResult): string {
+    if (!result.hasConflict) return "";
+
+    const lines = [
+        "⚠️ Magic Context is disabled due to conflicting configuration:\n",
+        ...result.reasons.map((r) => `  • ${r}`),
+        "",
+        "Run `bunx @cortexkit/opencode-magic-context doctor` to fix,",
+        "or resolve these conflicts manually in your OpenCode config.",
+    ];
+    return lines.join("\n");
+}
+
+/**
+ * Generate a short conflict summary for ignored message display.
+ */
+export function formatConflictShort(result: ConflictResult): string {
+    if (!result.hasConflict) return "";
+
+    const lines = [
+        "⚠️ Magic Context is disabled due to conflicting configuration:",
+        "",
+        ...result.reasons.map((r) => `• ${r}`),
+        "",
+        "Fix: run `bunx @cortexkit/opencode-magic-context doctor`",
+    ];
+    return lines.join("\n");
+}