@cortexkit/opencode-magic-context 0.42.5 → 0.43.0

package/src/config/index.ts

@@ -33,7 +33,11 @@ import {
 import { pruneNestedConfigLeaf } from "./prune-config-leaf";
 import { loadRawConfigFile } from "./raw-loader";
 import { stripRemovedAgentConfig } from "./removed-agent-config";
-import { type MagicContextConfig, MagicContextConfigSchema } from "./schema/magic-context";
+import {
+    type MagicContextConfig,
+    MagicContextConfigSchema,
+    PROTECTED_TOKENS_MIN,
+} from "./schema/magic-context";
 import { resolveTransformMode } from "./transform-mode";
 import { substituteConfigVariables } from "./variable";
 
@@ -323,6 +327,18 @@ function redactConfigValue(value: unknown): string {
 
 let warnedProtectedTagsDeprecation = false;
 
+/**
+ * Specific warning for a protected_tokens value that is a number below the
+ * schema minimum. The generic "invalid value (number 20), using default
+ * undefined" message is true but unhelpful: it does not say the value is in the
+ * wrong unit (a leftover protected_tags tag count), and "using default
+ * undefined" reads like a bug. This branch fires ONLY for `number < min`;
+ * every other invalid value (wrong type, above max) keeps the generic message.
+ */
+export function formatProtectedTokensBelowMinWarning(value: number): string {
+    return `protected_tokens is a token floor (minimum ${PROTECTED_TOKENS_MIN}, default derived from the context window); ${value} looks like the old protected_tags count. Remove the key to use the default, or set a token count such as 16000.`;
+}
+
 export function resetProtectedTagsDeprecationWarningForTest(): void {
     warnedProtectedTagsDeprecation = false;
 }
@@ -483,6 +499,20 @@ export function parsePluginConfig(
         delete patched[key];
         const defaultVal = (defaults as unknown as Record<string, unknown>)[key];
         const reason = customMessagesByKey.get(key);
+        // A numeric protected_tokens below the schema minimum is almost always a
+        // leftover protected_tags tag count (10–30) renamed by hand. Replace the
+        // generic invalid-leaf message with one that names the unit mismatch.
+        // Scoped precisely to `number < min` so wrong-type and above-max values
+        // still get the generic message.
+        const invalidRawValue = rawConfig[key];
+        if (
+            key === "protected_tokens" &&
+            typeof invalidRawValue === "number" &&
+            invalidRawValue < PROTECTED_TOKENS_MIN
+        ) {
+            warnings.push(formatProtectedTokensBelowMinWarning(invalidRawValue));
+            continue;
+        }
         warnings.push(
             `"${key}": invalid value (${redactConfigValue(rawConfig[key])}), using default ${JSON.stringify(defaultVal)}.${reason ? ` ${reason}` : ""}`,
         );
@@ -588,7 +618,10 @@ function combinedOutcome(args: {
     return "ok";
 }
 
-export function loadPluginConfigDetailed(directory: string): LoadResultDetailed {
+export function loadPluginConfigDetailed(
+    directory: string,
+    applyRuntimeGlobals = true,
+): LoadResultDetailed {
     const userDetected = detectConfigFile(getUserConfigBasePath());
     const projectDetected = detectConfigFile(getProjectConfigBasePath(directory));
     // Both-harness sources drive the GC-suppression signal; this-harness sources
@@ -720,8 +753,10 @@ export function loadPluginConfigDetailed(directory: string): LoadResultDetailed
         project: projectLoaded ? profileResolution.projectBase.protected_tokens : undefined,
     });
     if (profileResolution.activeProfile) config.profile = profileResolution.activeProfile;
-    setOutputReserveConfig(config.output_reserve);
-    setWindowOverlayPath(config.models?.window_overlay_path);
+    if (applyRuntimeGlobals) {
+        setOutputReserveConfig(config.output_reserve);
+        setWindowOverlayPath(config.models?.window_overlay_path);
+    }
     const leafValidationWarnings = [...(config.configWarnings ?? [])];
     if (config.configWarnings?.length) {
         allWarnings.push(

package/src/config/live-run-config.test.ts

@@ -0,0 +1,237 @@
+import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+    buildDreamTaskRuntimeConfigs,
+    userMemoryCollectionEnabled,
+} from "../features/magic-context/dreamer/task-config";
+import { resolveHistorianModel } from "../shared/model-resolution";
+import { loadPluginConfigDetailed } from "./index";
+import { dreamerRunConfig, historianRunConfig } from "./live-run-config";
+import { LiveConfigReader } from "./live-snapshot";
+
+for (const host of ["OC1", "OC2", "Pi"] as const) {
+    test(`${host} historian samples the next generation while an existing run keeps its model and fallback`, () => {
+        const root = mkdtempSync(join(tmpdir(), "mc-live-historian-"));
+        const previous = { home: process.env.HOME, config: process.env.XDG_CONFIG_HOME };
+        process.env.HOME = root;
+        process.env.XDG_CONFIG_HOME = join(root, "config");
+        const directory = join(root, "project");
+        const file = join(root, "config", "cortexkit", "magic-context.jsonc");
+        mkdirSync(join(root, "config", "cortexkit"), { recursive: true });
+        mkdirSync(join(directory, ".cortexkit"), { recursive: true });
+        try {
+            const block = host === "Pi" ? "pi" : "opencode";
+            const write = (
+                model: string,
+                fallback: string,
+                autoPromote: boolean,
+                minClusters: number,
+            ) =>
+                writeFileSync(
+                    file,
+                    JSON.stringify({
+                        historian: { [block]: { model, fallback_models: [fallback] } },
+                        memory: { auto_promote: autoPromote },
+                        commit_cluster_trigger: { enabled: true, min_clusters: minClusters },
+                    }),
+                );
+            write("anthropic/old-model", "anthropic/old-fallback", true, 3);
+            const load = () => loadPluginConfigDetailed(directory, false).config;
+            const boot = load();
+            const reader = new LiveConfigReader(directory, boot, load, () => {});
+            reader.poll();
+            const runOne = historianRunConfig(boot, reader.current().effective);
+            write(
+                "anthropic/new-model-with-longer-name",
+                "anthropic/new-fallback-with-longer-name",
+                false,
+                5,
+            );
+            const runTwo = historianRunConfig(boot, reader.poll().effective);
+            const harness = host === "Pi" ? "pi" : "opencode";
+            expect(resolveHistorianModel(runOne, harness).primary?.model).toBe(
+                "anthropic/old-model",
+            );
+            expect(resolveHistorianModel(runOne, harness).fallbacks[0]?.model).toBe(
+                "anthropic/old-fallback",
+            );
+            expect(resolveHistorianModel(runTwo, harness).primary?.model).toBe(
+                "anthropic/new-model-with-longer-name",
+            );
+            expect(resolveHistorianModel(runTwo, harness).fallbacks[0]?.model).toBe(
+                "anthropic/new-fallback-with-longer-name",
+            );
+            expect(runOne.memory.auto_promote).toBe(true);
+            expect(runTwo.memory.auto_promote).toBe(false);
+            expect(runOne.commit_cluster_trigger.min_clusters).toBe(3);
+            expect(runTwo.commit_cluster_trigger.min_clusters).toBe(5);
+            expect(reader.current().generation).toBe(2);
+        } finally {
+            if (previous.home === undefined) delete process.env.HOME;
+            else process.env.HOME = previous.home;
+            if (previous.config === undefined) delete process.env.XDG_CONFIG_HOME;
+            else process.env.XDG_CONFIG_HOME = previous.config;
+            rmSync(root, { recursive: true, force: true });
+        }
+    });
+}
+
+for (const host of ["OC1", "OC2", "Pi"] as const) {
+    test(`${host} dreamer samples the new schedule and model chain without changing a running task`, () => {
+        const root = mkdtempSync(join(tmpdir(), "mc-live-dreamer-"));
+        const previous = { home: process.env.HOME, config: process.env.XDG_CONFIG_HOME };
+        process.env.HOME = root;
+        process.env.XDG_CONFIG_HOME = join(root, "config");
+        const directory = join(root, "project");
+        const userFile = join(root, "config", "cortexkit", "magic-context.jsonc");
+        const projectFile = join(directory, ".cortexkit", "magic-context.jsonc");
+        mkdirSync(join(root, "config", "cortexkit"), { recursive: true });
+        mkdirSync(join(directory, ".cortexkit"), { recursive: true });
+        try {
+            const block = host === "Pi" ? "pi" : "opencode";
+            writeFileSync(
+                userFile,
+                JSON.stringify({
+                    dreamer: { [block]: { model: "old/model", fallback_models: ["old/fallback"] } },
+                }),
+            );
+            const writeSchedule = (schedule: string) =>
+                writeFileSync(
+                    projectFile,
+                    JSON.stringify({
+                        dreamer: {
+                            tasks: {
+                                verify: { schedule },
+                                "review-user-memories": {
+                                    schedule: schedule === "0 3 * * *" ? "" : "0 0 * * *",
+                                },
+                            },
+                        },
+                    }),
+                );
+            writeSchedule("0 3 * * *");
+            const load = () => loadPluginConfigDetailed(directory, false).config;
+            const boot = load();
+            const reader = new LiveConfigReader(directory, boot, load, () => {});
+            reader.poll();
+            const runOne = dreamerRunConfig(boot, reader.current().effective);
+            writeFileSync(
+                userFile,
+                JSON.stringify({
+                    dreamer: {
+                        [block]: {
+                            model: "new/model-long",
+                            fallback_models: ["new/fallback-long"],
+                        },
+                    },
+                }),
+            );
+            writeSchedule("15 4 * * *");
+            const runTwo = dreamerRunConfig(boot, reader.poll().effective);
+            const task = (cfg: typeof runOne) =>
+                buildDreamTaskRuntimeConfigs(cfg.dreamer, host === "Pi" ? "pi" : "opencode").find(
+                    (entry) => entry.task === "verify",
+                )!;
+            expect(task(runOne).schedule).toBe("0 3 * * *");
+            expect(userMemoryCollectionEnabled(runOne.dreamer)).toBe(false);
+            expect(task(runOne).model?.model).toBe("old/model");
+            expect(task(runOne).fallbackModels[0]?.model).toBe("old/fallback");
+            expect(task(runTwo).schedule).toBe("15 4 * * *");
+            expect(
+                userMemoryCollectionEnabled(
+                    historianRunConfig(boot, reader.current().effective).dreamer,
+                ),
+            ).toBe(true);
+            expect(task(runTwo).model?.model).toBe("new/model-long");
+            expect(task(runTwo).fallbackModels[0]?.model).toBe("new/fallback-long");
+        } finally {
+            if (previous.home === undefined) delete process.env.HOME;
+            else process.env.HOME = previous.home;
+            if (previous.config === undefined) delete process.env.XDG_CONFIG_HOME;
+            else process.env.XDG_CONFIG_HOME = previous.config;
+            rmSync(root, { recursive: true, force: true });
+        }
+    });
+}
+
+test("malformed project config retains last good values and deduplicates the warning; project overrides remain tier-safe", () => {
+    const root = mkdtempSync(join(tmpdir(), "mc-live-tiers-"));
+    const previous = { home: process.env.HOME, config: process.env.XDG_CONFIG_HOME };
+    process.env.HOME = root;
+    process.env.XDG_CONFIG_HOME = join(root, "config");
+    const directory = join(root, "project");
+    const userFile = join(root, "config", "cortexkit", "magic-context.jsonc");
+    const projectFile = join(directory, ".cortexkit", "magic-context.jsonc");
+    mkdirSync(join(root, "config", "cortexkit"), { recursive: true });
+    mkdirSync(join(directory, ".cortexkit"), { recursive: true });
+    const warnings: string[] = [];
+    try {
+        writeFileSync(
+            userFile,
+            JSON.stringify({
+                dreamer: {
+                    opencode: { model: "user/model" },
+                    tasks: { verify: { schedule: "0 3 * * *" } },
+                    prompt: "trusted",
+                },
+                historian: { opencode: { model: "user/historian" } },
+            }),
+        );
+        writeFileSync(
+            projectFile,
+            JSON.stringify({
+                dreamer: {
+                    opencode: { model: "project/model" },
+                    tasks: { verify: { schedule: "1 3 * * *" } },
+                    prompt: "untrusted",
+                },
+                historian: { opencode: { model: "project/historian" } },
+            }),
+        );
+        const load = () => loadPluginConfigDetailed(directory, false).config;
+        const reader = new LiveConfigReader(directory, load(), load, (message) =>
+            warnings.push(message),
+        );
+        const first = reader.poll();
+        expect(first.effective.dreamer?.opencode?.model).toBe("project/model");
+        expect(first.effective.dreamer?.prompt).toBe("trusted");
+        expect(resolveHistorianModel(first.effective, "opencode").primary?.model).toBe(
+            "user/historian",
+        );
+        writeFileSync(projectFile, "{ broken:");
+        expect(reader.poll()).toBe(first);
+        expect(reader.poll()).toBe(first);
+        expect(warnings.filter((message) => message.includes("config reload failed"))).toHaveLength(
+            1,
+        );
+        writeFileSync(
+            projectFile,
+            JSON.stringify({
+                dreamer: {
+                    opencode: { model: "project/new-model" },
+                    tasks: { verify: { schedule: "2 3 * * *" } },
+                    prompt: "still-untrusted",
+                },
+                historian: { opencode: { model: "project/new-historian" } },
+            }),
+        );
+        const second = reader.poll();
+        expect(second.generation).toBe(2);
+        expect(second.effective.dreamer?.opencode?.model).toBe("project/new-model");
+        expect(second.effective.dreamer?.tasks?.verify.schedule).toBe("2 3 * * *");
+        expect(second.effective.dreamer?.prompt).toBe("trusted");
+        expect(resolveHistorianModel(second.effective, "opencode").primary?.model).toBe(
+            "user/historian",
+        );
+        expect(first.effective.dreamer?.opencode?.model).toBe("project/model");
+    } finally {
+        if (previous.home === undefined) delete process.env.HOME;
+        else process.env.HOME = previous.home;
+        if (previous.config === undefined) delete process.env.XDG_CONFIG_HOME;
+        else process.env.XDG_CONFIG_HOME = previous.config;
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/src/config/live-run-config.ts

@@ -0,0 +1,80 @@
+import { log } from "../shared/logger";
+import { loadPluginConfigDetailed, type MagicContextPluginConfig } from "./index";
+import { LiveConfigReader } from "./live-snapshot";
+import { LIVE_RELOAD_CONFIG_PATHS, type MagicContextConfig } from "./schema/magic-context";
+
+/** Copy only schema-marked live paths from fresh config; other settings retain boot values. */
+export function sampleLiveConfig<T extends MagicContextConfig>(boot: T, fresh: T): T {
+    const result = { ...boot } as Record<string, unknown>;
+    for (const path of LIVE_RELOAD_CONFIG_PATHS) {
+        const parts = path.split(".");
+        let value: unknown = fresh;
+        for (const part of parts) value = (value as Record<string, unknown> | undefined)?.[part];
+        let target = result;
+        for (const part of parts.slice(0, -1)) {
+            const child = target[part];
+            const copy =
+                child && typeof child === "object" && !Array.isArray(child)
+                    ? { ...(child as Record<string, unknown>) }
+                    : {};
+            target[part] = copy;
+            target = copy;
+        }
+        const leaf = parts.at(-1);
+        if (leaf !== undefined) target[leaf] = value;
+    }
+    return result as T;
+}
+
+export function changedLiveKeys(previous: MagicContextConfig, next: MagicContextConfig): string[] {
+    const at = (config: MagicContextConfig, path: string): unknown =>
+        path
+            .split(".")
+            .reduce<unknown>(
+                (node, part) => (node as Record<string, unknown> | undefined)?.[part],
+                config,
+            );
+    return LIVE_RELOAD_CONFIG_PATHS.filter(
+        (path) => JSON.stringify(at(previous, path)) !== JSON.stringify(at(next, path)),
+    );
+}
+
+export const historianRunConfig = sampleLiveConfig;
+export const dreamerRunConfig = sampleLiveConfig;
+
+const pluginReaders = new Map<string, LiveConfigReader<MagicContextPluginConfig>>();
+
+/** Shared by all OpenCode entry points for one project in this process. */
+export function pluginConfigReader(directory: string, boot: MagicContextPluginConfig) {
+    let reader = pluginReaders.get(directory);
+    if (!reader) {
+        reader = new LiveConfigReader(
+            directory,
+            boot,
+            () => {
+                const loaded = loadPluginConfigDetailed(directory, false);
+                if (
+                    loaded.loadOutcome === "project-file-parse-error" ||
+                    loaded.loadOutcome === "project-file-io-error" ||
+                    loaded.loadOutcome === "schema-recovery"
+                ) {
+                    throw new Error(
+                        `invalid configuration: ${loaded.config.configWarnings?.join("; ") ?? loaded.loadOutcome}`,
+                    );
+                }
+                return loaded.config;
+            },
+            // Into our own log file: console output lands in the host's stdout/stderr
+            // (for `opencode serve`, the terminal or service log the user reads).
+            (message) => log(`[config] ${message}`),
+            changedLiveKeys,
+        );
+        reader.poll();
+        pluginReaders.set(directory, reader);
+    }
+    return reader;
+}
+
+export function currentPluginConfigReader(directory: string) {
+    return pluginReaders.get(directory);
+}

package/src/config/live-schema-drift.test.ts

@@ -0,0 +1,67 @@
+import { expect, test } from "bun:test";
+
+import { buildSchema } from "../../scripts/build-schema";
+import { sampleLiveConfig } from "./live-run-config";
+import { LIVE_RELOAD_CONFIG_PATHS, type MagicContextConfig } from "./schema/magic-context";
+
+type SchemaNode = { properties?: Record<string, SchemaNode>; "x-mc-live-reload"?: boolean };
+
+function leaves(node: SchemaNode, prefix = ""): Array<{ path: string; marked: boolean }> {
+    return Object.entries(node.properties ?? {}).flatMap(([key, child]) => {
+        const path = prefix ? `${prefix}.${key}` : key;
+        return child.properties
+            ? leaves(child, path)
+            : [{ path, marked: child["x-mc-live-reload"] === true }];
+    });
+}
+
+function assign(target: Record<string, unknown>, path: string, value: unknown): void {
+    const keys = path.split(".");
+    let node = target;
+    for (const key of keys.slice(0, -1)) {
+        node[key] ??= {};
+        node = node[key] as Record<string, unknown>;
+    }
+    node[keys.at(-1)!] = value;
+}
+
+function lookup(target: Record<string, unknown>, path: string): unknown {
+    return path
+        .split(".")
+        .reduce<unknown>(
+            (node, key) => (node as Record<string, unknown> | undefined)?.[key],
+            target,
+        );
+}
+
+test("schema live marks equal the keys sampled by producer consumers and published JSON schema", async () => {
+    const generated = buildSchema() as SchemaNode;
+    const published = (await Bun.file(
+        new URL("../../../../assets/magic-context.schema.json", import.meta.url),
+    ).json()) as SchemaNode;
+    const generatedLive = leaves(generated)
+        .filter((row) => row.marked)
+        .map((row) => row.path)
+        .sort();
+    const publishedLive = leaves(published)
+        .filter((row) => row.marked)
+        .map((row) => row.path)
+        .sort();
+    const boot = {} as Record<string, unknown>;
+    const fresh = {} as Record<string, unknown>;
+    for (const row of leaves(generated)) assign(fresh, row.path, `changed:${row.path}`);
+    const sampled = sampleLiveConfig(
+        boot as MagicContextConfig,
+        fresh as MagicContextConfig,
+    ) as Record<string, unknown>;
+    const consumed = leaves(generated)
+        .filter((row) => lookup(sampled, row.path) === `changed:${row.path}`)
+        .map((row) => row.path)
+        .sort();
+    expect(generatedLive).toEqual([...LIVE_RELOAD_CONFIG_PATHS].sort());
+    expect(publishedLive).toEqual(generatedLive);
+    expect(consumed).toEqual(generatedLive);
+    expect(generatedLive).not.toContain("language");
+    expect(generatedLive).not.toContain("historian.top_p");
+    expect(generatedLive).not.toContain("protected_tokens");
+});

package/src/config/live-snapshot.test.ts

@@ -0,0 +1,85 @@
+import { expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { parseJsonc } from "../shared/jsonc-parser";
+import { LiveConfigReader } from "./live-snapshot";
+
+test("one snapshot per run survives a malformed tier and adopts both tiers atomically", () => {
+    const oldConfigHome = process.env.XDG_CONFIG_HOME;
+    const root = mkdtempSync(join(tmpdir(), "mc-live-config-"));
+    const project = join(root, "project");
+    const projectFile = join(project, ".cortexkit", "magic-context.jsonc");
+    const userFile = join(root, "config", "cortexkit", "magic-context.jsonc");
+    mkdirSync(join(project, ".cortexkit"), { recursive: true });
+    mkdirSync(join(root, "config", "cortexkit"), { recursive: true });
+    process.env.XDG_CONFIG_HOME = join(root, "config");
+    try {
+        const logs: string[] = [];
+        writeFileSync(userFile, '{"historian":{"model":"user"}}');
+        writeFileSync(projectFile, '{"historian":{"model":"project"}}');
+        const load = () => {
+            const user = parseJsonc<{ historian: { model: string } }>(
+                readFileSync(userFile, "utf8"),
+            );
+            const projectConfig = parseJsonc<{ historian: { model: string } }>(
+                readFileSync(projectFile, "utf8"),
+            );
+            return { model: projectConfig.historian.model ?? user.historian.model };
+        };
+        const reader = new LiveConfigReader(project, load(), load, (line) => logs.push(line));
+        const first = reader.poll();
+        expect(first.generation).toBe(1);
+        writeFileSync(projectFile, '{"historian":');
+        expect(reader.poll()).toBe(first);
+        expect(reader.lastFailure()?.path).toBe(projectFile);
+        reader.poll();
+        expect(logs.filter((line) => line.includes("reload failed"))).toHaveLength(1);
+        writeFileSync(projectFile, '{"historian":{"model":"second-model"}}');
+        const second = reader.poll();
+        expect(second.generation).toBe(2);
+        expect(second.effective.model).toBe("second-model");
+        expect(first.effective.model).toBe("project");
+        expect(reader.lastFailure()).toBeUndefined();
+        expect(logs.filter((line) => line.includes("config reloaded"))).toEqual([
+            "config reloaded gen=2 keys=[model]",
+        ]);
+    } finally {
+        if (oldConfigHome === undefined) delete process.env.XDG_CONFIG_HOME;
+        else process.env.XDG_CONFIG_HOME = oldConfigHome;
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test("a write crossing the tier load boundary is not published as a mixed snapshot", () => {
+    const root = mkdtempSync(join(tmpdir(), "mc-live-crossing-"));
+    const previous = process.env.XDG_CONFIG_HOME;
+    process.env.XDG_CONFIG_HOME = join(root, "config");
+    const project = join(root, "project");
+    const file = join(project, ".cortexkit", "magic-context.jsonc");
+    mkdirSync(join(project, ".cortexkit"), { recursive: true });
+    try {
+        writeFileSync(file, '{"model":"old"}');
+        let crossWrite = false;
+        const load = () => {
+            if (crossWrite) {
+                crossWrite = false;
+                writeFileSync(file, '{"model":"newest-longer"}');
+            }
+            return { model: JSON.parse(readFileSync(file, "utf8")).model as string };
+        };
+        const reader = new LiveConfigReader(project, load(), load, () => {});
+        reader.poll();
+        writeFileSync(file, '{"model":"intermediate"}');
+        crossWrite = true;
+        expect(reader.poll().effective.model).toBe("old");
+        expect(reader.current().generation).toBe(1);
+        expect(reader.poll().effective.model).toBe("newest-longer");
+        expect(reader.current().generation).toBe(2);
+    } finally {
+        if (previous === undefined) delete process.env.XDG_CONFIG_HOME;
+        else process.env.XDG_CONFIG_HOME = previous;
+        rmSync(root, { recursive: true, force: true });
+    }
+});