@cortexkit/opencode-magic-context 0.33.0 → 0.34.0

package/src/features/magic-context/dreamer/cron.ts

@@ -0,0 +1,243 @@
+/**
+ * Minimal 5-field cron evaluator for per-task dreamer scheduling.
+ *
+ * Why vendored (no dependency): we only need "next occurrence after time T", the
+ * 3-day package-release-age floor makes pulling a dep awkward, and the surface is
+ * small. Shared core — both OpenCode and Pi import this via @magic-context/core.
+ *
+ * Fields: `minute hour day-of-month month day-of-week`
+ *   minute 0-59 · hour 0-23 · dom 1-31 · month 1-12 · dow 0-6 (0 or 7 = Sunday)
+ * Each field supports: a star wildcard, a star-with-step (every-N), a single
+ * value `a`, a range `a-b`, a range-with-step `a-b/step`, an open step `a/step`
+ * (a..max), and comma-lists of any of those. Numeric only — month and weekday
+ * NAMES are intentionally unsupported (smaller surface; add later if asked).
+ * Empty string `""` means "never" and is handled by the caller, not here.
+ *
+ * Day matching uses Vixie OR-semantics: when BOTH dom and dow are restricted
+ * (not `*`), a day matches if EITHER matches; when only one is restricted, only
+ * that one is consulted; when neither is restricted, every day matches.
+ *
+ * Timezone: all matching is in the machine's LOCAL time — the dreamer's whole
+ * purpose is "run while the user is asleep", which is a wall-clock concept.
+ * nextOccurrence steps by real (epoch) minutes and reads LOCAL civil fields off
+ * each candidate, so DST transitions are handled correctly by construction (no
+ * setHours/local-constructor normalization, which is DST-ambiguous).
+ */
+
+export interface ParsedCron {
+    minute: Set<number>;
+    hour: Set<number>;
+    dom: Set<number>;
+    month: Set<number>;
+    dow: Set<number>;
+    /** Original field token was not `*` — drives Vixie dom/dow OR-semantics. */
+    domRestricted: boolean;
+    dowRestricted: boolean;
+}
+
+export type ParseCronResult = { ok: true; cron: ParsedCron } | { ok: false; error: string };
+
+interface FieldSpec {
+    name: string;
+    min: number;
+    max: number;
+}
+
+const FIELDS: FieldSpec[] = [
+    { name: "minute", min: 0, max: 59 },
+    { name: "hour", min: 0, max: 23 },
+    { name: "day-of-month", min: 1, max: 31 },
+    { name: "month", min: 1, max: 12 },
+    { name: "day-of-week", min: 0, max: 7 }, // 7 normalized to 0 (Sunday)
+];
+
+const MINUTE_MS = 60_000;
+/**
+ * Forward search bound for nextOccurrence. ~4 years covers Feb-29-only crons
+ * (leap years are ≤4 apart) and the longest legitimate gaps; anything past it is
+ * treated as "never" (e.g. an impossible `0 0 31 2 *` — Feb 31). Generous so a
+ * valid-but-rare schedule is never wrongly reported as never.
+ */
+const MAX_SEARCH_MS = 4 * 366 * 24 * 60 * MINUTE_MS;
+
+/** Parse one field into the set of matching values, or null on error. */
+function parseField(token: string, spec: FieldSpec): Set<number> | null {
+    const values = new Set<number>();
+    const normalize = (n: number): number => (spec.name === "day-of-week" && n === 7 ? 0 : n);
+
+    for (const part of token.split(",")) {
+        const piece = part.trim();
+        if (piece.length === 0) return null;
+
+        // Split off an optional /step.
+        const [rangePart, stepPart, ...extra] = piece.split("/");
+        if (extra.length > 0) return null;
+        let step = 1;
+        if (stepPart !== undefined) {
+            if (!/^\d+$/.test(stepPart)) return null;
+            step = Number(stepPart);
+            if (step < 1) return null;
+        }
+
+        let lo: number;
+        let hi: number;
+        if (rangePart === "*") {
+            lo = spec.min;
+            hi = spec.max;
+        } else if (rangePart.includes("-")) {
+            const [loStr, hiStr, ...rest] = rangePart.split("-");
+            if (rest.length > 0) return null;
+            if (!/^\d+$/.test(loStr) || !/^\d+$/.test(hiStr)) return null;
+            lo = Number(loStr);
+            hi = Number(hiStr);
+        } else {
+            if (!/^\d+$/.test(rangePart)) return null;
+            lo = Number(rangePart);
+            // `a/step` (no upper bound) means a..max by step.
+            hi = stepPart !== undefined ? spec.max : lo;
+        }
+
+        // Validate against the field range BEFORE dow-7 normalization so `7` is
+        // accepted (it's a valid Sunday alias) but `8` is rejected.
+        if (lo < spec.min || lo > spec.max || hi < spec.min || hi > spec.max) return null;
+        if (lo > hi) return null;
+
+        for (let v = lo; v <= hi; v += step) {
+            values.add(normalize(v));
+        }
+    }
+
+    return values.size > 0 ? values : null;
+}
+
+/** Parse a 5-field cron expression. Empty/whitespace is rejected here — callers
+ *  treat `""` as "never" before calling. */
+export function parseCron(expression: string): ParseCronResult {
+    const trimmed = expression.trim();
+    if (trimmed.length === 0) {
+        return { ok: false, error: "empty cron expression" };
+    }
+    const tokens = trimmed.split(/\s+/);
+    if (tokens.length !== 5) {
+        return {
+            ok: false,
+            error: `expected 5 fields (minute hour day-of-month month day-of-week), got ${tokens.length}`,
+        };
+    }
+
+    const sets: Set<number>[] = [];
+    for (let i = 0; i < FIELDS.length; i++) {
+        const parsed = parseField(tokens[i], FIELDS[i]);
+        if (!parsed) {
+            return {
+                ok: false,
+                error: `invalid ${FIELDS[i].name} field "${tokens[i]}" (allowed ${FIELDS[i].min}-${FIELDS[i].max})`,
+            };
+        }
+        sets.push(parsed);
+    }
+
+    return {
+        ok: true,
+        cron: {
+            minute: sets[0],
+            hour: sets[1],
+            dom: sets[2],
+            month: sets[3],
+            dow: sets[4],
+            domRestricted: tokens[2] !== "*",
+            dowRestricted: tokens[4] !== "*",
+        },
+    };
+}
+
+/** True if the expression parses; thin wrapper for config validation. */
+export function isValidCron(expression: string): boolean {
+    return parseCron(expression).ok;
+}
+
+function matchesDay(cron: ParsedCron, date: Date): boolean {
+    const dom = cron.dom.has(date.getDate());
+    const dow = cron.dow.has(date.getDay());
+    if (cron.domRestricted && cron.dowRestricted) return dom || dow;
+    if (cron.domRestricted) return dom;
+    if (cron.dowRestricted) return dow;
+    return true;
+}
+
+/** True if `date`'s local civil fields match the cron. */
+export function matchesCron(cron: ParsedCron, date: Date): boolean {
+    return (
+        cron.minute.has(date.getMinutes()) &&
+        cron.hour.has(date.getHours()) &&
+        cron.month.has(date.getMonth() + 1) &&
+        matchesDay(cron, date)
+    );
+}
+
+/** Local civil-minute key `YYYY-MM-DD HH:mm` — used to dedupe the repeated wall
+ *  minute on a DST fall-back so a run isn't fired twice for the same slot. */
+function civilMinuteKey(date: Date): string {
+    const p = (n: number, w = 2) => String(n).padStart(w, "0");
+    return `${p(date.getFullYear(), 4)}-${p(date.getMonth() + 1)}-${p(date.getDate())} ${p(date.getHours())}:${p(date.getMinutes())}`;
+}
+
+/**
+ * First instant strictly after `after` whose LOCAL civil time matches `cron`.
+ * Returns null if none within the ~4-year cap (effectively-never schedules).
+ *
+ * @param excludeCivilMinute Skip any candidate sharing this `YYYY-MM-DD HH:mm`
+ *   key. Pass the just-consumed run's scheduled civil minute when advancing
+ *   `next_due_at` so a DST fall-back's repeated wall minute doesn't double-fire
+ *   the same daily slot. (For sub-hourly every-N schedules, only the exact
+ *   consumed minute is skipped; the other repeated-hour minutes still fire, which
+ *   is correct — more real time elapsed.)
+ */
+export function nextOccurrence(
+    cron: ParsedCron,
+    after: Date,
+    excludeCivilMinute?: string,
+    maxSearchMs = MAX_SEARCH_MS,
+): Date | null {
+    const afterMs = after.getTime();
+    // Align to the next whole minute strictly after `after` (never returns `after`).
+    let cursorMs = Math.floor(afterMs / MINUTE_MS) * MINUTE_MS + MINUTE_MS;
+    const capMs = afterMs + Math.max(0, Math.min(MAX_SEARCH_MS, maxSearchMs));
+
+    while (cursorMs <= capMs) {
+        const candidate = new Date(cursorMs);
+        if (matchesCron(cron, candidate)) {
+            if (!excludeCivilMinute || civilMinuteKey(candidate) !== excludeCivilMinute) {
+                return candidate;
+            }
+        }
+        cursorMs += MINUTE_MS;
+    }
+    return null;
+}
+
+/**
+ * Convenience: parse + compute next-due epoch (ms) for a schedule string.
+ * Returns null for `""` / invalid / effectively-never schedules — the caller
+ * persists `next_due_at = NULL` in all of those cases.
+ *
+ * @param consumedScheduledAtMs When advancing after a run, pass the epoch of the
+ *   slot just satisfied (the prior `next_due_at`); its civil minute is excluded
+ *   to prevent the DST repeated-minute double-fire.
+ */
+export function nextDueAtMs(
+    expression: string,
+    afterMs: number,
+    consumedScheduledAtMs?: number,
+    maxSearchMs = MAX_SEARCH_MS,
+): number | null {
+    if (expression.trim().length === 0) return null;
+    const parsed = parseCron(expression);
+    if (!parsed.ok) return null;
+    const exclude =
+        consumedScheduledAtMs !== undefined
+            ? civilMinuteKey(new Date(consumedScheduledAtMs))
+            : undefined;
+    const next = nextOccurrence(parsed.cron, new Date(afterMs), exclude, maxSearchMs);
+    return next ? next.getTime() : null;
+}

package/src/features/magic-context/dreamer/task-registry.ts

@@ -0,0 +1,104 @@
+/**
+ * Canonical Dreamer v2 task registry (pure — no DB imports, so the config schema
+ * can import the task names without pulling runtime code).
+ *
+ * v2 promotes the former post-phases (review-user-memories, key-files,
+ * evaluate-smart-notes) to first-class scheduled tasks alongside the agentic
+ * maintenance tasks, and assigns each a LEASE DOMAIN so disjoint-state tasks run
+ * concurrently while memory-mutating tasks serialize. See lease.ts + the A+B spec.
+ */
+
+export const CANONICAL_DREAM_TASKS = [
+    // map-memories runs BEFORE verify (it records the file mappings verify gates
+    // on) and shares the memory lease, so it leads the canonical order.
+    "map-memories",
+    "verify",
+    "verify-broad",
+    "curate",
+    "compress-cues",
+    "classify-memories",
+    "retrospective",
+    "maintain-docs",
+    "evaluate-smart-notes",
+    "review-user-memories",
+    "promote-primers",
+    "refresh-primers",
+] as const;
+
+export type DreamTaskName = (typeof CANONICAL_DREAM_TASKS)[number];
+
+/**
+ * The agentic tasks — those run as a generic dreamer agent session driven by
+ * `buildDreamTaskPrompt`. The other canonical tasks (map-memories, verify,
+ * verify-broad, classify-memories, review-user-memories, evaluate-smart-notes,
+ * primers, retrospective) have their own specialized runners and do NOT go
+ * through the prompt builder.
+ */
+export const AGENTIC_DREAM_TASKS = ["curate", "maintain-docs"] as const;
+
+/**
+ * Tasks that read-modify-write the project `memories` table (+ epoch +
+ * supersede-delta rows). They SHARE one per-project "memory" lease so they
+ * serialize with each other — concurrent runs race semantically (stale-view
+ * merges/splits). Canonical run order when several are due in one drain.
+ */
+export const MEMORY_DOMAIN_TASKS: readonly DreamTaskName[] = [
+    "map-memories",
+    "verify",
+    "verify-broad",
+    "curate",
+    "compress-cues",
+    "classify-memories",
+    "retrospective",
+    "promote-primers",
+    "refresh-primers",
+];
+
+const MEMORY_DOMAIN_SET = new Set<DreamTaskName>(MEMORY_DOMAIN_TASKS);
+
+/**
+ * Lease KIND per task. `memory` + the three independent kinds are per-project;
+ * `user-memories` is GLOBAL (mutates the cross-project user-profile pool, so two
+ * different projects' dreamers must not review concurrently).
+ */
+export type LeaseKind = "memory" | "maintain-docs" | "evaluate-smart-notes" | "user-memories";
+
+export function leaseKindFor(task: DreamTaskName): LeaseKind {
+    if (MEMORY_DOMAIN_SET.has(task)) return "memory";
+    switch (task) {
+        case "review-user-memories":
+            return "user-memories";
+        case "promote-primers":
+        case "refresh-primers":
+            return "memory";
+        case "maintain-docs":
+            return "maintain-docs";
+        case "evaluate-smart-notes":
+            return "evaluate-smart-notes";
+        default:
+            // Memory-domain tasks already returned above; this is unreachable.
+            return "memory";
+    }
+}
+
+/**
+ * Resolve the concrete lease key for a task in a project. The global
+ * `user-memories` lease is NOT project-scoped (one reviewer across all projects);
+ * every other domain is keyed by project so different projects never block.
+ */
+export function leaseKeyFor(task: DreamTaskName, projectIdentity: string): string {
+    const kind = leaseKindFor(task);
+    return kind === "user-memories" ? "user-memories" : `${kind}:${projectIdentity}`;
+}
+
+export function isCanonicalDreamTask(value: string): value is DreamTaskName {
+    return (CANONICAL_DREAM_TASKS as readonly string[]).includes(value);
+}
+
+/**
+ * Stable canonical ordering used when multiple due tasks share a lease domain
+ * (preserves the suite order for the memory domain).
+ */
+export function compareTaskOrder(a: DreamTaskName, b: DreamTaskName): number {
+    return CANONICAL_DREAM_TASKS.indexOf(a) - CANONICAL_DREAM_TASKS.indexOf(b);
+}

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

@@ -15,6 +15,7 @@ import { detectConflicts } from "./conflict-detector";
 describe("detectConflicts", () => {
     let projectDir: string;
     let userConfigDir: string;
+    let homeDir: string;
     let originalEnv: Record<string, string | undefined>;
 
     beforeEach(() => {
@@ -23,6 +24,8 @@ describe("detectConflicts", () => {
         mkdirSync(projectDir, { recursive: true });
         userConfigDir = join(root, "user-config", "opencode");
         mkdirSync(userConfigDir, { recursive: true });
+        homeDir = join(root, "home");
+        mkdirSync(homeDir, { recursive: true });
 
         // Save and override every env var that affects config-path resolution.
         // OPENCODE_CONFIG_DIR takes precedence over XDG_CONFIG_HOME, so we set
@@ -32,8 +35,10 @@ describe("detectConflicts", () => {
             OPENCODE_CONFIG_DIR: process.env.OPENCODE_CONFIG_DIR,
             XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
             OPENCODE_DISABLE_AUTOCOMPACT: process.env.OPENCODE_DISABLE_AUTOCOMPACT,
+            HOME: process.env.HOME,
         };
         process.env.OPENCODE_CONFIG_DIR = userConfigDir;
+        process.env.HOME = homeDir;
         delete process.env.XDG_CONFIG_HOME;
         // Disable auto-compaction default during tests so we isolate plugin
         // detection from compaction detection.
@@ -166,7 +171,7 @@ describe("detectConflicts", () => {
             expect(result.conflicts.omoPreemptiveCompaction).toBe(true);
         });
 
-        it("respects disabled_hooks in project-level OMO config", () => {
+        it("respects disabled_hooks in project-level OMO config (old format)", () => {
             writeProjectConfig(["oh-my-opencode"]);
             // Use project-scoped OMO config to avoid relying on user
             // config-path resolution, which can be leaked across files
@@ -184,6 +189,130 @@ describe("detectConflicts", () => {
             const result = detectConflicts(projectDir);
             expect(result.hasConflict).toBe(false);
         });
+
+        // --- New unified omo.jsonc (oh-my-openagent >= 4.19.0) ---
+
+        it("detects disabled_hooks in new ~/.omo/omo.jsonc (user-level)", () => {
+            writeProjectConfig(["oh-my-opencode"]);
+            const omoDir = join(homeDir, ".omo");
+            mkdirSync(omoDir, { recursive: true });
+            writeFileSync(
+                join(omoDir, "omo.jsonc"),
+                JSON.stringify({
+                    "[opencode]": {
+                        disabled_hooks: [
+                            "preemptive-compaction",
+                            "context-window-monitor",
+                            "anthropic-context-window-limit-recovery",
+                        ],
+                    },
+                }),
+            );
+            const result = detectConflicts(projectDir);
+            expect(result.hasConflict).toBe(false);
+        });
+
+        it("detects disabled_hooks in new .omo/omo.jsonc (project-level)", () => {
+            writeProjectConfig(["oh-my-opencode"]);
+            const omoDir = join(projectDir, ".omo");
+            mkdirSync(omoDir, { recursive: true });
+            writeFileSync(
+                join(omoDir, "omo.jsonc"),
+                JSON.stringify({
+                    "[opencode]": {
+                        disabled_hooks: [
+                            "preemptive-compaction",
+                            "context-window-monitor",
+                            "anthropic-context-window-limit-recovery",
+                        ],
+                    },
+                }),
+            );
+            const result = detectConflicts(projectDir);
+            expect(result.hasConflict).toBe(false);
+        });
+
+        it("detects hooks as active when new omo.jsonc has no disabled_hooks", () => {
+            writeProjectConfig(["oh-my-opencode"]);
+            const omoDir = join(homeDir, ".omo");
+            mkdirSync(omoDir, { recursive: true });
+            writeFileSync(
+                join(omoDir, "omo.jsonc"),
+                JSON.stringify({
+                    "[opencode]": {
+                        // No disabled_hooks — hooks default ACTIVE
+                    },
+                }),
+            );
+            const result = detectConflicts(projectDir);
+            expect(result.conflicts.omoPreemptiveCompaction).toBe(true);
+            expect(result.conflicts.omoContextWindowMonitor).toBe(true);
+            expect(result.conflicts.omoAnthropicRecovery).toBe(true);
+        });
+
+        it("reads disabled_hooks from both old and new config paths", () => {
+            writeProjectConfig(["oh-my-opencode"]);
+            // Old path: only disables preemptive-compaction
+            writeFileSync(
+                join(projectDir, "oh-my-opencode.json"),
+                JSON.stringify({
+                    disabled_hooks: ["preemptive-compaction"],
+                }),
+            );
+            // New path: disables the other two
+            const omoDir = join(homeDir, ".omo");
+            mkdirSync(omoDir, { recursive: true });
+            writeFileSync(
+                join(omoDir, "omo.jsonc"),
+                JSON.stringify({
+                    "[opencode]": {
+                        disabled_hooks: [
+                            "context-window-monitor",
+                            "anthropic-context-window-limit-recovery",
+                        ],
+                    },
+                }),
+            );
+            const result = detectConflicts(projectDir);
+            // All three are disabled across both configs
+            expect(result.hasConflict).toBe(false);
+        });
+
+        it("reads omo.json (fallback) when omo.jsonc does not exist", () => {
+            writeProjectConfig(["oh-my-opencode"]);
+            const omoDir = join(homeDir, ".omo");
+            mkdirSync(omoDir, { recursive: true });
+            writeFileSync(
+                join(omoDir, "omo.json"),
+                JSON.stringify({
+                    "[opencode]": {
+                        disabled_hooks: [
+                            "preemptive-compaction",
+                            "context-window-monitor",
+                            "anthropic-context-window-limit-recovery",
+                        ],
+                    },
+                }),
+            );
+            const result = detectConflicts(projectDir);
+            expect(result.hasConflict).toBe(false);
+        });
+
+        it("ignores new omo.jsonc when OMO is not installed", () => {
+            writeProjectConfig([]);
+            const omoDir = join(homeDir, ".omo");
+            mkdirSync(omoDir, { recursive: true });
+            writeFileSync(
+                join(omoDir, "omo.jsonc"),
+                JSON.stringify({
+                    "[opencode]": {
+                        disabled_hooks: ["preemptive-compaction"],
+                    },
+                }),
+            );
+            const result = detectConflicts(projectDir);
+            expect(result.hasConflict).toBe(false);
+        });
     });
 
     // --- Combined / control cases ---
@@ -242,4 +371,125 @@ describe("detectConflicts", () => {
             expect(result.hasConflict).toBe(false);
         });
     });
+
+    // --- Compaction-off mode matrix (issue #266 S2) ---
+    // The detector must NOT flag OpenCode compaction.auto=true / prune=true as
+    // a plugin-disabling conflict when MC compaction is OFF (compaction-off
+    // mode), or compaction-off users get a DISABLED plugin — the exact inverse
+    // of intent. With MC compaction ON, today's conflict behavior is unchanged.
+    //
+    // The 2x2 matrix: MC mode (on/off) x native compaction.auto (true/false).
+    // Each case asserts BOTH the conflict verdict AND the plugin-enabled
+    // outcome (the boot path disables the plugin when hasConflict).
+    describe("compaction-off mode matrix (issue #266)", () => {
+        // The suite beforeEach sets OPENCODE_DISABLE_AUTOCOMPACT=1 to isolate
+        // plugin detection from compaction detection. These matrix tests
+        // exercise compaction detection directly, so they clear that env var
+        // and write an explicit compaction block to control the native state.
+        function writeCompactionConfig(auto: boolean, prune = false): void {
+            const prev = process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            writeFileSync(
+                join(projectDir, "opencode.json"),
+                JSON.stringify({ compaction: { auto, prune } }),
+            );
+            if (prev !== undefined) process.env.OPENCODE_DISABLE_AUTOCOMPACT = prev;
+        }
+
+        function detectWithMode(compactionEnabled: boolean) {
+            const prev = process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            try {
+                return detectConflicts(projectDir, { compactionEnabled });
+            } finally {
+                if (prev !== undefined) process.env.OPENCODE_DISABLE_AUTOCOMPACT = prev;
+            }
+        }
+
+        it("MC ON + auto=true → conflict fires, plugin would be disabled", () => {
+            writeCompactionConfig(true);
+            const result = detectWithMode(true);
+            expect(result.hasConflict).toBe(true);
+            expect(result.conflicts.compactionAuto).toBe(true);
+        });
+
+        it("MC ON + auto=false → no compaction conflict, plugin stays enabled", () => {
+            writeCompactionConfig(false);
+            const result = detectWithMode(true);
+            expect(result.conflicts.compactionAuto).toBe(false);
+            expect(result.hasConflict).toBe(false);
+        });
+
+        it("MC OFF + auto=true → NO conflict, plugin stays enabled (native compaction active)", () => {
+            writeCompactionConfig(true);
+            const result = detectWithMode(false);
+            expect(result.conflicts.compactionAuto).toBe(false);
+            expect(result.conflicts.compactionPrune).toBe(false);
+            expect(result.hasConflict).toBe(false);
+            // Native compaction state is still reported honestly.
+            expect(result.nativeCompaction.auto).toBe(true);
+        });
+
+        it("MC OFF + auto=false → NO conflict, no-manager configuration reported honestly", () => {
+            writeCompactionConfig(false);
+            const result = detectWithMode(false);
+            expect(result.conflicts.compactionAuto).toBe(false);
+            expect(result.hasConflict).toBe(false);
+            // No-manager: neither MC nor native compaction owns the window.
+            expect(result.nativeCompaction.auto).toBe(false);
+            expect(result.nativeCompaction.prune).toBe(false);
+        });
+
+        // Mutation direction: force mode-on in the detector with auto=true →
+        // conflict fires. This proves the off-gate isn't just always-pass —
+        // the same native config that was NOT a conflict in the off case
+        // becomes a conflict when the mode is forced on.
+        it("mutation direction: same auto=true config DOES conflict when mode forced on", () => {
+            writeCompactionConfig(true);
+            const offResult = detectWithMode(false);
+            const onResult = detectWithMode(true);
+            expect(offResult.hasConflict).toBe(false);
+            expect(onResult.hasConflict).toBe(true);
+            expect(onResult.conflicts.compactionAuto).toBe(true);
+        });
+
+        // prune=true follows the same gate as auto=true.
+        it("MC OFF + prune=true → NO conflict (prune is not a conflict in compaction-off mode)", () => {
+            writeCompactionConfig(false, true);
+            const result = detectWithMode(false);
+            expect(result.conflicts.compactionPrune).toBe(false);
+            expect(result.hasConflict).toBe(false);
+            expect(result.nativeCompaction.prune).toBe(true);
+        });
+
+        // DCP and OMO conflicts keep their existing policy in BOTH modes.
+        it("MC OFF + DCP plugin → DCP conflict still fires (compaction-off does not broaden compatibility)", () => {
+            writeProjectConfig(["@tarquinen/opencode-dcp"]);
+            const result = detectWithMode(false);
+            expect(result.conflicts.dcpPlugin).toBe(true);
+            expect(result.hasConflict).toBe(true);
+        });
+
+        it("MC OFF + OMO hooks → OMO conflicts still fire in both modes", () => {
+            writeProjectConfig(["oh-my-opencode"]);
+            const result = detectWithMode(false);
+            expect(result.conflicts.omoPreemptiveCompaction).toBe(true);
+            expect(result.hasConflict).toBe(true);
+        });
+
+        // Default (no options) preserves today's mode-on behavior — a call
+        // site that cannot supply the resolved mode fails toward mode-on.
+        it("default (no options) treats compaction.auto=true as a conflict (fail toward mode-on)", () => {
+            writeCompactionConfig(true);
+            const prev = process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            try {
+                const result = detectConflicts(projectDir);
+                expect(result.conflicts.compactionAuto).toBe(true);
+                expect(result.hasConflict).toBe(true);
+            } finally {
+                if (prev !== undefined) process.env.OPENCODE_DISABLE_AUTOCOMPACT = prev;
+            }
+        });
+    });
 });