@cortexkit/opencode-magic-context 0.33.1 → 0.34.1

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,151 @@
+/**
+ * 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];
+
+/** Cheap, read-only work counts for one Dreamer task. */
+export interface DreamTaskBacklog {
+    /** Items selected by the task's current backlog predicate. */
+    pending: number;
+    /** Total items in the task's candidate pool. */
+    total: number;
+}
+
+/** Backlog counts keyed by canonical task name. */
+export type DreamTaskBacklogMap = Partial<Record<DreamTaskName, DreamTaskBacklog>>;
+
+/** Stable human-readable rendering shared by /ctx-dream and status surfaces. */
+export function formatDreamTaskBacklogs(
+    backlogs: DreamTaskBacklogMap,
+    tasks: readonly DreamTaskName[] = CANONICAL_DREAM_TASKS,
+): string {
+    return tasks
+        .filter((task) => backlogs[task] !== undefined)
+        .map((task) => {
+            const backlog = backlogs[task];
+            return `- ${task}: ${backlog?.pending ?? 0} pending / ${backlog?.total ?? 0} total`;
+        })
+        .join("\n");
+}
+
+/** Process-local progress for the task currently applying a run chunk. */
+export interface DreamTaskProgress {
+    task: DreamTaskName;
+    processed: number;
+    total: number;
+    startedAt: number;
+}
+
+/** Persisted per-task run counts used by dream-run history and summaries. */
+export interface DreamTaskRunBacklog {
+    pendingAtStart: number;
+    totalAtStart: number;
+    pendingAtEnd: number;
+    totalAtEnd: number;
+    processed: number;
+}
+
+/** Use the decrease in the persisted backlog between the start and end snapshots as the per-run progress count, clamped to zero when the backlog does not decrease. */
+export function processedDreamTaskItems(startPending: number, endPending: number): number {
+    return Math.max(0, startPending - endPending);
+}
+
+/**
+ * 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

@@ -371,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;
+            }
+        });
+    });
 });

package/src/shared/conflict-detector.ts

@@ -38,13 +38,55 @@ export interface ConflictResult {
         omoContextWindowMonitor: boolean;
         omoAnthropicRecovery: boolean;
     };
+    /**
+     * Resolved native compaction state observed during detection, for honest
+     * reporting in both MC modes. `auto`/`prune` reflect the OpenCode
+     * `compaction` block as resolved by the detector (env override, project
+     * then user, default-on). They are populated even when MC compaction is
+     * OFF (in which case they are NOT flagged as conflicts).
+     */
+    nativeCompaction: {
+        auto: boolean;
+        prune: boolean;
+    };
+}
+
+/**
+ * Options for {@link detectConflicts}.
+ *
+ * `compactionEnabled` is the boot-resolved Magic Context compaction mode
+ * (the result of {@link isCompactionEnabled} on the resolved user-tier
+ * config). It MUST be threaded through every production call site — plugin
+ * boot, setup, doctor, conflict-fixer — so the MC-mode decision is never
+ * re-derived at a call site. A call site that genuinely cannot supply it
+ * (e.g. a low-level native-config reader with no MC config handle) MUST
+ * omit it and accept the default `true` (mode-on) behavior, which preserves
+ * today's conflict semantics; it must never silently skip the check.
+ *
+ * When `compactionEnabled` is `false` (compaction-off mode), OpenCode
+ * `compaction.auto=true` / `compaction.prune=true` are NOT plugin-disabling
+ * conflicts — native compaction is the user's chosen window manager. DCP
+ * and the three OMO conflict classes keep their existing policy in BOTH
+ * modes.
+ */
+export interface DetectConflictsOptions {
+    compactionEnabled?: boolean;
 }
 
 /**
  * Detect all conflicts that would prevent magic-context from working correctly.
  * Checks: OpenCode compaction, DCP plugin, OMO conflicting hooks.
+ *
+ * `compactionEnabled` (default `true`) is the resolved MC compaction mode.
+ * When `false` (compaction-off mode), native `compaction.auto`/`prune` are
+ * reported in {@link ConflictResult.nativeCompaction} but are NOT flagged as
+ * conflicts — native compaction is the intended window manager in that mode.
  */
-export function detectConflicts(directory: string): ConflictResult {
+export function detectConflicts(
+    directory: string,
+    options?: DetectConflictsOptions,
+): ConflictResult {
+    const compactionEnabled = options?.compactionEnabled ?? true;
     const conflicts: ConflictResult["conflicts"] = {
         compactionAuto: false,
         compactionPrune: false,
@@ -57,11 +99,15 @@ export function detectConflicts(directory: string): ConflictResult {
 
     // --- Check OpenCode compaction config ---
     const compactionResult = checkCompaction(directory);
-    if (compactionResult.auto) {
+    // Native compaction is a conflict ONLY when MC compaction is ON. In
+    // compaction-off mode the user has explicitly handed the window to native
+    // compaction (or nothing), so compaction.auto=true / prune=true are the
+    // intended state, not a plugin-disabling conflict.
+    if (compactionEnabled && compactionResult.auto) {
         conflicts.compactionAuto = true;
         reasons.push("OpenCode auto-compaction is enabled (compaction.auto=true)");
     }
-    if (compactionResult.prune) {
+    if (compactionEnabled && compactionResult.prune) {
         conflicts.compactionPrune = true;
         reasons.push("OpenCode prune is enabled (compaction.prune=true)");
     }
@@ -100,6 +146,7 @@ export function detectConflicts(directory: string): ConflictResult {
         hasConflict: reasons.length > 0,
         reasons,
         conflicts,
+        nativeCompaction: { auto: compactionResult.auto, prune: compactionResult.prune },
     };
 }