@cortexkit/opencode-magic-context 0.33.1 → 0.34.0

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

@@ -5,6 +5,7 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { parse as parseJsonc } from "comment-json";
+import { detectConflicts } from "./conflict-detector";
 import { fixConflicts } from "./conflict-fixer";
 
 const noOmoConflicts = {
@@ -17,19 +18,24 @@ describe("fixConflicts", () => {
     let root: string;
     let projectDir: string;
     let userConfigDir: string;
+    let homeDir: 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");
+        homeDir = join(root, "home");
         mkdirSync(projectDir, { recursive: true });
         mkdirSync(userConfigDir, { recursive: true });
+        mkdirSync(homeDir, { recursive: true });
         originalEnv = {
             OPENCODE_CONFIG_DIR: process.env.OPENCODE_CONFIG_DIR,
             XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
+            HOME: process.env.HOME,
         };
         process.env.OPENCODE_CONFIG_DIR = userConfigDir;
+        process.env.HOME = homeDir;
         delete process.env.XDG_CONFIG_HOME;
     });
 
@@ -125,4 +131,307 @@ describe("fixConflicts", () => {
             ["@other/opencode-dcp-slim@latest", { enabled: true }],
         ]);
     });
+
+    // --- Unified OMO config (oh-my-openagent >= 4.19.0) ---
+
+    describe("unified OMO config paths", () => {
+        const omoConflicts = {
+            compactionAuto: false,
+            compactionPrune: false,
+            dcpPlugin: false,
+            omoPreemptiveCompaction: true,
+            omoContextWindowMonitor: true,
+            omoAnthropicRecovery: true,
+        };
+
+        it("disables hooks inside [opencode] block in ~/.omo/omo.jsonc, comments survive, detector confirms", () => {
+            const omoDir = join(homeDir, ".omo");
+            mkdirSync(omoDir, { recursive: true });
+            const configPath = join(omoDir, "omo.jsonc");
+            writeFileSync(
+                configPath,
+                `{
+  // top-level comment
+  "some-omo-setting": true,
+  "[opencode]": {
+    // opencode block comment
+    "other_setting": "value"
+  }
+}
+`,
+            );
+
+            const actions = fixConflicts(projectDir, omoConflicts);
+
+            expect(actions).toEqual(["Disabled conflicting oh-my-opencode hooks"]);
+
+            const updatedText = readFileSync(configPath, "utf-8");
+            expect(updatedText).toContain("top-level comment");
+            expect(updatedText).toContain("opencode block comment");
+            expect(updatedText).toContain("some-omo-setting");
+
+            const updated = parseJsonc(updatedText) as Record<string, unknown>;
+            const opencodeBlock = updated["[opencode]"] as Record<string, unknown>;
+            expect(opencodeBlock.disabled_hooks).toEqual([
+                "context-window-monitor",
+                "preemptive-compaction",
+                "anthropic-context-window-limit-recovery",
+            ]);
+            expect(opencodeBlock.other_setting).toBe("value");
+
+            // Round-trip: detector should now report no OMO conflicts
+            // Need a project-level opencode.json with OMO plugin for detection
+            writeFileSync(
+                join(projectDir, "opencode.json"),
+                JSON.stringify({ plugin: ["oh-my-opencode"] }),
+            );
+            const result = detectConflicts(projectDir);
+            expect(result.conflicts.omoPreemptiveCompaction).toBe(false);
+            expect(result.conflicts.omoContextWindowMonitor).toBe(false);
+            expect(result.conflicts.omoAnthropicRecovery).toBe(false);
+        });
+
+        it("creates [opencode] block when missing in unified omo.jsonc", () => {
+            const omoDir = join(homeDir, ".omo");
+            mkdirSync(omoDir, { recursive: true });
+            const configPath = join(omoDir, "omo.jsonc");
+            writeFileSync(
+                configPath,
+                `{
+  // just a top-level setting, no [opencode] block
+  "some-omo-setting": true
+}
+`,
+            );
+
+            const actions = fixConflicts(projectDir, omoConflicts);
+
+            expect(actions).toEqual(["Disabled conflicting oh-my-opencode hooks"]);
+
+            const updatedText = readFileSync(configPath, "utf-8");
+            expect(updatedText).toContain("top-level setting");
+
+            const updated = parseJsonc(updatedText) as Record<string, unknown>;
+            const opencodeBlock = updated["[opencode]"] as Record<string, unknown>;
+            expect(opencodeBlock.disabled_hooks).toEqual([
+                "context-window-monitor",
+                "preemptive-compaction",
+                "anthropic-context-window-limit-recovery",
+            ]);
+        });
+
+        it("writes to project-level .omo/omo.jsonc", () => {
+            const omoDir = join(projectDir, ".omo");
+            mkdirSync(omoDir, { recursive: true });
+            const configPath = join(omoDir, "omo.jsonc");
+            writeFileSync(
+                configPath,
+                JSON.stringify({
+                    "[opencode]": {},
+                }),
+            );
+
+            const actions = fixConflicts(projectDir, omoConflicts);
+
+            expect(actions).toEqual(["Disabled conflicting oh-my-opencode hooks"]);
+
+            const updated = parseJsonc(readFileSync(configPath, "utf-8")) as Record<
+                string,
+                unknown
+            >;
+            const opencodeBlock = updated["[opencode]"] as Record<string, unknown>;
+            expect(opencodeBlock.disabled_hooks).toEqual([
+                "context-window-monitor",
+                "preemptive-compaction",
+                "anthropic-context-window-limit-recovery",
+            ]);
+        });
+
+        it("reads omo.json (fallback) when omo.jsonc does not exist", () => {
+            const omoDir = join(homeDir, ".omo");
+            mkdirSync(omoDir, { recursive: true });
+            const configPath = join(omoDir, "omo.json");
+            writeFileSync(
+                configPath,
+                JSON.stringify({
+                    "[opencode]": {},
+                }),
+            );
+
+            const actions = fixConflicts(projectDir, omoConflicts);
+
+            expect(actions).toEqual(["Disabled conflicting oh-my-opencode hooks"]);
+
+            const updated = JSON.parse(readFileSync(configPath, "utf-8"));
+            expect(updated["[opencode]"].disabled_hooks).toEqual([
+                "context-window-monitor",
+                "preemptive-compaction",
+                "anthropic-context-window-limit-recovery",
+            ]);
+        });
+
+        it("updates both legacy and unified config when both exist", () => {
+            // Legacy: project-level oh-my-opencode.json
+            const legacyPath = join(projectDir, "oh-my-opencode.json");
+            writeFileSync(legacyPath, JSON.stringify({ disabled_hooks: [] }));
+
+            // Unified: ~/.omo/omo.jsonc
+            const omoDir = join(homeDir, ".omo");
+            mkdirSync(omoDir, { recursive: true });
+            const unifiedPath = join(omoDir, "omo.jsonc");
+            writeFileSync(
+                unifiedPath,
+                JSON.stringify({
+                    "[opencode]": {},
+                }),
+            );
+
+            const actions = fixConflicts(projectDir, omoConflicts);
+
+            expect(actions).toEqual(["Disabled conflicting oh-my-opencode hooks"]);
+
+            // Legacy: top-level disabled_hooks
+            const legacy = JSON.parse(readFileSync(legacyPath, "utf-8"));
+            expect(legacy.disabled_hooks).toEqual([
+                "context-window-monitor",
+                "preemptive-compaction",
+                "anthropic-context-window-limit-recovery",
+            ]);
+
+            // Unified: inside [opencode] block
+            const unified = JSON.parse(readFileSync(unifiedPath, "utf-8"));
+            expect(unified["[opencode]"].disabled_hooks).toEqual([
+                "context-window-monitor",
+                "preemptive-compaction",
+                "anthropic-context-window-limit-recovery",
+            ]);
+        });
+
+        it("skips non-existent unified paths (no create)", () => {
+            // No .omo directory at all — fixer should find no targets
+            const actions = fixConflicts(projectDir, omoConflicts);
+            expect(actions).toEqual([]);
+        });
+    });
+
+    // --- Compaction-off mode parity (issue #266 S2) ---
+    // In compaction-off mode the fixer MUST NOT flip compaction.auto/prune to
+    // false — native compaction fields are left byte-for-byte as found.
+    // DCP and OMO hook fixes keep their existing policy in BOTH modes.
+    describe("compaction-off mode parity (issue #266)", () => {
+        it("does NOT flip compaction.auto to false when compaction-off", () => {
+            const configPath = join(projectDir, "opencode.jsonc");
+            const original = `{
+  // keep comment
+  "compaction": {
+    "auto": true,
+    "prune": true
+  }
+}
+`;
+            writeFileSync(configPath, original);
+
+            const actions = fixConflicts(
+                projectDir,
+                {
+                    compactionAuto: true,
+                    compactionPrune: true,
+                    dcpPlugin: false,
+                    ...noOmoConflicts,
+                },
+                { compactionEnabled: false },
+            );
+
+            // No compaction repair action in compaction-off mode.
+            expect(actions).toEqual([]);
+            // File is byte-for-byte unchanged (native fields preserved).
+            expect(readFileSync(configPath, "utf-8")).toBe(original);
+        });
+
+        it("still removes DCP plugin in compaction-off mode (DCP policy is mode-independent)", () => {
+            const configPath = join(projectDir, "opencode.jsonc");
+            writeFileSync(
+                configPath,
+                JSON.stringify({
+                    plugin: ["@tarquinen/opencode-dcp@latest"],
+                    compaction: { auto: true, prune: true },
+                }),
+            );
+
+            const actions = fixConflicts(
+                projectDir,
+                { compactionAuto: true, compactionPrune: true, dcpPlugin: true, ...noOmoConflicts },
+                { compactionEnabled: false },
+            );
+
+            // DCP removed, compaction NOT flipped.
+            expect(actions).toEqual(["Removed opencode-dcp plugin"]);
+            const updated = parseJsonc(readFileSync(configPath, "utf-8")) as Record<
+                string,
+                unknown
+            >;
+            expect(updated.compaction).toEqual({ auto: true, prune: true });
+            expect(updated.plugin).toEqual([]);
+        });
+
+        it("still disables OMO hooks in compaction-off mode (OMO policy is mode-independent)", () => {
+            const configPath = join(projectDir, "opencode.json");
+            writeFileSync(configPath, JSON.stringify({ plugin: ["oh-my-opencode"] }));
+            const omoDir = join(homeDir, ".omo");
+            mkdirSync(omoDir, { recursive: true });
+            const omoPath = join(omoDir, "omo.jsonc");
+            writeFileSync(omoPath, JSON.stringify({ "[opencode]": {} }));
+
+            const actions = fixConflicts(
+                projectDir,
+                {
+                    compactionAuto: false,
+                    compactionPrune: false,
+                    dcpPlugin: false,
+                    omoPreemptiveCompaction: true,
+                    omoContextWindowMonitor: true,
+                    omoAnthropicRecovery: true,
+                },
+                { compactionEnabled: false },
+            );
+
+            expect(actions).toEqual(["Disabled conflicting oh-my-opencode hooks"]);
+        });
+
+        // Mutation direction: with mode ON, the same compaction conflict IS
+        // repaired. Proves the off-gate isn't just always-skip.
+        it("mutation direction: same conflict IS repaired when mode forced on", () => {
+            const configPath = join(projectDir, "opencode.jsonc");
+            writeFileSync(configPath, JSON.stringify({ compaction: { auto: true, prune: true } }));
+
+            const offActions = fixConflicts(
+                projectDir,
+                {
+                    compactionAuto: true,
+                    compactionPrune: true,
+                    dcpPlugin: false,
+                    ...noOmoConflicts,
+                },
+                { compactionEnabled: false },
+            );
+            const onActions = fixConflicts(
+                projectDir,
+                {
+                    compactionAuto: true,
+                    compactionPrune: true,
+                    dcpPlugin: false,
+                    ...noOmoConflicts,
+                },
+                { compactionEnabled: true },
+            );
+
+            expect(offActions).toEqual([]);
+            expect(onActions).toEqual(["Disabled auto-compaction"]);
+            const updated = parseJsonc(readFileSync(configPath, "utf-8")) as Record<
+                string,
+                unknown
+            >;
+            expect(updated.compaction).toEqual({ auto: false, prune: false });
+        });
+    });
 });

package/src/shared/conflict-fixer.ts

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { join } from "node:path";
 import { parse, stringify } from "comment-json";
 
@@ -25,6 +26,9 @@ const OMO_CONFIG_NAMES = [
     "oh-my-opencode.json",
 ] as const;
 
+/** Unified OMO config names (oh-my-openagent >= 4.19.0) */
+const OMO_UNIFIED_NAMES = ["omo.jsonc", "omo.json"] as const;
+
 function isRecord(value: unknown): value is JsonObject {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -84,6 +88,7 @@ function collectOmoConfigPaths(directory: string): string[] {
     const paths = new Set<string>();
     const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
 
+    // Legacy OMO config names in the OpenCode config dir and project dir
     for (const fileName of OMO_CONFIG_NAMES) {
         const userPath = join(configDir, fileName);
         const projectPath = join(directory, fileName);
@@ -97,9 +102,48 @@ function collectOmoConfigPaths(directory: string): string[] {
         }
     }
 
+    // New unified omo.jsonc (oh-my-openagent >= 4.19.0)
+    // User-level: ~/.omo/omo.jsonc (fallback ~/.omo/omo.json)
+    const homeDir = process.env.HOME || homedir();
+    const omoHomeDir = join(homeDir, ".omo");
+    for (const name of OMO_UNIFIED_NAMES) {
+        const userPath = join(omoHomeDir, name);
+        if (existsSync(userPath)) {
+            paths.add(userPath);
+        }
+    }
+
+    // Project-level: .omo/omo.jsonc (fallback .omo/omo.json)
+    for (const name of OMO_UNIFIED_NAMES) {
+        const projectPath = join(directory, ".omo", name);
+        if (existsSync(projectPath)) {
+            paths.add(projectPath);
+        }
+    }
+
     return [...paths];
 }
 
+/** Check if a config path is a unified omo.json(c) path (not legacy). */
+function isUnifiedOmoPath(configPath: string): boolean {
+    const basename = configPath.split("/").pop() ?? "";
+    return basename === "omo.jsonc" || basename === "omo.json";
+}
+
+/**
+ * Get or create the `[opencode]` block inside a unified omo.json(c) config.
+ * Returns the block itself so callers can read/write `disabled_hooks` on it.
+ */
+function getOrCreateOmoV2Block(config: JsonObject): JsonObject {
+    const block = config["[opencode]"];
+    if (isRecord(block)) {
+        return block;
+    }
+    const newBlock: JsonObject = {};
+    config["[opencode]"] = newBlock;
+    return newBlock;
+}
+
 function filterDcpPluginEntries(entries: unknown[]): { plugins: unknown[]; removed: boolean } {
     const plugins = entries.filter((entry) => {
         const name = extractPluginName(entry);
@@ -108,13 +152,43 @@ function filterDcpPluginEntries(entries: unknown[]): { plugins: unknown[]; remov
     return { plugins, removed: plugins.length !== entries.length };
 }
 
-export function fixConflicts(directory: string, conflicts: ConflictResult["conflicts"]): string[] {
+/**
+ * Options for {@link fixConflicts}.
+ *
+ * `compactionEnabled` is the boot-resolved MC compaction mode (the result of
+ * {@link isCompactionEnabled} on the resolved user-tier config). When `false`
+ * (compaction-off mode), the fixer MUST NOT flip `compaction.auto`/`prune` to
+ * `false` — native compaction fields are left byte-for-byte as found, because
+ * native compaction (or nothing) is the user's chosen window manager. DCP and
+ * OMO hook fixes keep their existing policy in BOTH modes.
+ *
+ * Default `true` (mode-on) preserves today's fix behavior for call sites that
+ * cannot supply the resolved mode; they fail toward mode-on, never silently
+ * skipping the fix.
+ */
+export interface FixConflictsOptions {
+    compactionEnabled?: boolean;
+}
+
+export function fixConflicts(
+    directory: string,
+    conflicts: ConflictResult["conflicts"],
+    options?: FixConflictsOptions,
+): string[] {
+    const compactionEnabled = options?.compactionEnabled ?? true;
     const actions: string[] = [];
     let updatedCompaction = false;
     let removedDcpPlugin = false;
     let disabledOmoHooks = false;
 
-    if (conflicts.compactionAuto || conflicts.compactionPrune || conflicts.dcpPlugin) {
+    // Native compaction fields are repaired ONLY when MC compaction is ON. In
+    // compaction-off mode the fixer must not rewrite compaction.auto/prune —
+    // native compaction is the intended manager and pre-existing values are
+    // left byte-for-byte as found.
+    const repairCompaction =
+        compactionEnabled && (conflicts.compactionAuto || conflicts.compactionPrune);
+
+    if (repairCompaction || conflicts.dcpPlugin) {
         for (const configPath of collectOpenCodeConfigPaths(directory)) {
             const config = readConfig(configPath);
             if (!config) {
@@ -123,7 +197,7 @@ export function fixConflicts(directory: string, conflicts: ConflictResult["confl
 
             let changed = false;
 
-            if (conflicts.compactionAuto || conflicts.compactionPrune) {
+            if (repairCompaction) {
                 const compaction = isRecord(config.compaction) ? config.compaction : {};
 
                 if (compaction.auto !== false) {
@@ -180,7 +254,10 @@ export function fixConflicts(directory: string, conflicts: ConflictResult["confl
                 continue;
             }
 
-            const disabledHooks = new Set(asStringArray(config.disabled_hooks));
+            // Unified paths nest hooks under the [opencode] block; legacy paths use top-level
+            const target = isUnifiedOmoPath(configPath) ? getOrCreateOmoV2Block(config) : config;
+
+            const disabledHooks = new Set(asStringArray(target.disabled_hooks));
             let changed = false;
 
             for (const hook of hooksToDisable) {
@@ -192,7 +269,7 @@ export function fixConflicts(directory: string, conflicts: ConflictResult["confl
             }
 
             if (changed) {
-                config.disabled_hooks = [
+                target.disabled_hooks = [
                     ...CONFLICTING_OMO_HOOKS.filter((hook) => disabledHooks.has(hook)),
                     ...[...disabledHooks].filter(
                         (hook) =>

package/src/shared/context-limit-provenance.ts

@@ -0,0 +1,6 @@
+export type ContextLimitProvenance = "prompt_only" | "combined" | "unknown";
+
+export function normalizeContextLimitProvenance(value: unknown): ContextLimitProvenance {
+    if (value === "prompt_only" || value === "combined") return value;
+    return "unknown";
+}

package/src/shared/escalation-bands.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "bun:test";
+import { escalationBands } from "./escalation-bands";
+
+describe("escalationBands", () => {
+    test.each([
+        [65, 85],
+        [80, 85],
+        [88, 90],
+        [90, 92],
+    ])("keeps the force band ordered for threshold %i", (threshold, expectedForce) => {
+        const bands = escalationBands(threshold);
+        expect(bands.forceMaterializationPercentage).toBe(expectedForce);
+        expect(threshold).toBeLessThan(bands.forceMaterializationPercentage);
+        expect(bands.forceMaterializationPercentage).toBeGreaterThanOrEqual(85);
+        expect(bands.forceMaterializationPercentage).toBeLessThan(95);
+        expect(bands.emergencyPercentage).toBe(95);
+    });
+
+    test("preserves the exact pre-raise behavior through threshold 80", () => {
+        expect(escalationBands(65).forceMaterializationPercentage).toBe(85);
+        expect(escalationBands(80).forceMaterializationPercentage).toBe(85);
+    });
+});

package/src/shared/escalation-bands.ts

@@ -0,0 +1,18 @@
+export const MAX_EXECUTE_THRESHOLD = 90;
+export const ABSOLUTE_EMERGENCY_PERCENTAGE = 95;
+
+export interface EscalationBands {
+    forceMaterializationPercentage: number;
+    emergencyPercentage: number;
+}
+
+/** Keep force cleanup above normal execution while preserving the absolute 95% wall. */
+export function escalationBands(effectiveThresholdPercentage: number): EscalationBands {
+    const threshold = Number.isFinite(effectiveThresholdPercentage)
+        ? Math.min(effectiveThresholdPercentage, MAX_EXECUTE_THRESHOLD)
+        : 65;
+    return {
+        forceMaterializationPercentage: Math.max(85, threshold + 2),
+        emergencyPercentage: ABSOLUTE_EMERGENCY_PERCENTAGE,
+    };
+}

package/src/shared/format-threshold.ts

@@ -31,7 +31,7 @@ export function formatThresholdPercent(value: number | undefined | null): string
  * Build a terse "clamped" annotation for execute-threshold display, or "" when the
  * configured value was not clamped. Status surfaces (/ctx-status text, pi status
  * dialog) append this so a user who configured e.g. 190000 tokens on a 128K model
- * sees that it was reduced to the 80% safety cap, instead of the value being
+ * sees that it was reduced to the 90% safety cap, instead of the value being
  * silently ignored (issue #241). The note includes the configured value and the cap
  * so the user can see the math.
  *