@cortexkit/opencode-magic-context 0.41.2 → 0.41.4

package/src/shared/cache-ttl-display.ts

@@ -0,0 +1,64 @@
+import type { MagicContextConfig } from "../config/schema/magic-context";
+import { resolveModelConfigValue } from "./prompt-surface";
+
+export type CacheTtlDisplaySource = "config" | "session" | "default";
+
+export interface CacheTtlDisplay {
+    value: string;
+    source: CacheTtlDisplaySource;
+    modelKey: string | undefined;
+}
+
+export interface ResolveCacheTtlDisplayArgs {
+    configured: MagicContextConfig["cache_ttl"];
+    configuredExplicitly: boolean;
+    modelKey: string | undefined;
+    sessionValue: string;
+    /** Model key persisted with the last completed assistant response. */
+    sessionModelKey: string | null;
+}
+
+/**
+ * Resolve status-only TTL text without changing the scheduler's persisted truth.
+ * Use the session value only when its persisted model key matches the model being
+ * displayed; otherwise use live config because the session value may be for another model.
+ */
+export function resolveCacheTtlDisplay(args: ResolveCacheTtlDisplayArgs): CacheTtlDisplay {
+    if (
+        (args.sessionModelKey && (!args.modelKey || args.sessionModelKey === args.modelKey)) ||
+        (!args.modelKey && !args.sessionModelKey && args.sessionValue !== "5m")
+    ) {
+        return {
+            value: args.sessionValue || "5m",
+            source: "session",
+            modelKey: args.modelKey ?? args.sessionModelKey ?? undefined,
+        };
+    }
+
+    if (typeof args.configured === "string") {
+        return {
+            value: args.configured,
+            source: args.configuredExplicitly ? "config" : "default",
+            modelKey: args.modelKey,
+        };
+    }
+
+    const matched = resolveModelConfigValue(args.configured, args.modelKey);
+    if (matched) {
+        return { value: matched.value, source: "config", modelKey: args.modelKey };
+    }
+
+    return {
+        value: args.configured.default ?? "5m",
+        source: "default",
+        modelKey: args.modelKey,
+    };
+}
+
+export function formatCacheTtlDisplay(display: CacheTtlDisplay): string {
+    if (display.source === "session") return `Cache TTL: ${display.value} (session)`;
+    if (display.source === "config") {
+        return `Cache TTL: ${display.value} (config for ${display.modelKey ?? "current model"})`;
+    }
+    return `Cache TTL: ${display.value} (default — no cache_ttl for ${display.modelKey ?? "unknown model"})`;
+}

package/src/shared/cache-ttl-seed.ts

@@ -0,0 +1,23 @@
+import type { MagicContextConfig } from "../config/schema/magic-context";
+import { getOrCreateSessionMeta, updateSessionMeta } from "../features/magic-context/storage-meta";
+import { resolveModelConfigValue } from "./prompt-surface";
+import type { Database } from "./sqlite";
+
+/** Seed only before a completed assistant response has made the session row authoritative. */
+export function seedSessionCacheTtlIfUnsynced(args: {
+    db: Database;
+    sessionId: string;
+    configured: MagicContextConfig["cache_ttl"];
+    modelKey: string;
+}): boolean {
+    const meta = getOrCreateSessionMeta(args.db, args.sessionId);
+    if (meta.lastResponseTime !== 0 || meta.lastObservedModelKey !== null) return false;
+    const cacheTtl =
+        typeof args.configured === "string"
+            ? args.configured
+            : (resolveModelConfigValue(args.configured, args.modelKey)?.value ??
+              args.configured.default ??
+              "5m");
+    updateSessionMeta(args.db, args.sessionId, { cacheTtl });
+    return true;
+}

package/src/shared/config-diagnostics.test.ts

@@ -0,0 +1,29 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+
+import {
+    type ConfigParseFailure,
+    claimConfigParseFailuresOnce,
+    resetClaimedConfigParseFailuresForTesting,
+} from "./config-diagnostics";
+
+const failure: ConfigParseFailure = {
+    warningClass: "file-parse",
+    source: "user",
+    path: "/tmp/magic-context.jsonc",
+    line: 1,
+    column: 1,
+    message: "invalid symbol",
+    recovered: true,
+    warning: "/tmp/magic-context.jsonc:1:1: invalid symbol",
+};
+
+describe("config parse warning notice claims", () => {
+    beforeEach(resetClaimedConfigParseFailuresForTesting);
+
+    it("emits each parse failure once per harness surface", () => {
+        expect(claimConfigParseFailuresOnce("opencode", [failure])).toEqual([failure]);
+        expect(claimConfigParseFailuresOnce("opencode", [failure])).toEqual([]);
+        expect(claimConfigParseFailuresOnce("pi", [failure])).toEqual([failure]);
+        expect(claimConfigParseFailuresOnce("pi", [failure])).toEqual([]);
+    });
+});

package/src/shared/config-diagnostics.ts

@@ -0,0 +1,64 @@
+export const CONFIG_WARNING_CLASS = {
+    FILE_PARSE: "file-parse",
+    FILE_IO: "file-io",
+    INVALID_LEAF: "invalid-leaf",
+} as const;
+
+export type ConfigWarningClass = (typeof CONFIG_WARNING_CLASS)[keyof typeof CONFIG_WARNING_CLASS];
+
+export interface ConfigParseFailure {
+    warningClass: typeof CONFIG_WARNING_CLASS.FILE_PARSE;
+    source: "user" | "project";
+    path: string;
+    line: number;
+    column: number;
+    message: string;
+    recovered: boolean;
+    warning: string;
+}
+
+export interface ConfigWarningDetail {
+    warningClass: ConfigWarningClass;
+    source?: "user" | "project";
+    path?: string;
+    line?: number;
+    column?: number;
+    message: string;
+}
+
+export function formatConfigParseStatusLine(failure: ConfigParseFailure): string {
+    const disposition = failure.recovered
+        ? "recovered values applied; fix the file"
+        : "running on defaults";
+    return `Config: PARSE FAILED (${failure.path}:${failure.line}:${failure.column}) — ${disposition}`;
+}
+
+export function formatConfigParseNotice(failures: readonly ConfigParseFailure[]): string {
+    const lines = failures.map(
+        (failure) => `${formatConfigParseStatusLine(failure)}\n${failure.message}`,
+    );
+    return ["⚠️ Magic Context config parse failure", ...lines].join("\n\n");
+}
+
+const claimedFailures = new Set<string>();
+
+function failureKey(surface: string, failure: ConfigParseFailure): string {
+    return `${surface}\0${failure.path}\0${failure.line}\0${failure.column}\0${failure.message}`;
+}
+
+/** Claim parse-failure notices once for each runtime surface in this process. */
+export function claimConfigParseFailuresOnce(
+    surface: "opencode" | "pi",
+    failures: readonly ConfigParseFailure[],
+): ConfigParseFailure[] {
+    return failures.filter((failure) => {
+        const key = failureKey(surface, failure);
+        if (claimedFailures.has(key)) return false;
+        claimedFailures.add(key);
+        return true;
+    });
+}
+
+export function resetClaimedConfigParseFailuresForTesting(): void {
+    claimedFailures.clear();
+}

package/src/shared/config-warning-surface.ts

@@ -0,0 +1,28 @@
+import type { ConfigParseFailure } from "./config-diagnostics";
+import { formatConfigParseStatusLine } from "./config-diagnostics";
+
+export function buildOpenCodeConfigWarningBanner(
+    warnings: readonly string[],
+    parseFailures: readonly ConfigParseFailure[],
+    allParseFailures: readonly ConfigParseFailure[] = parseFailures,
+): string {
+    const parseWarningStrings = new Set(allParseFailures.map((failure) => failure.warning));
+    const ordinaryWarnings = warnings.filter(
+        (warning) =>
+            ![...parseWarningStrings].some((parseWarning) => warning.includes(parseWarning)),
+    );
+    const entries = [
+        ...parseFailures.map(
+            (failure) =>
+                `- **TOP SEVERITY:** ${formatConfigParseStatusLine(failure)} — ${failure.message}`,
+        ),
+        ...ordinaryWarnings.map((warning) => `- ${warning}`),
+    ];
+    return [
+        "## ⚠️ Magic Context Config Warning",
+        "",
+        ...entries,
+        "",
+        "Fix the reported `magic-context.jsonc` file; Magic Context remains enabled.",
+    ].join("\n");
+}

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

@@ -653,5 +653,29 @@ describe("detectConflicts", () => {
             const result = await resolveCompactionForBoot(client, 20);
             expect(result).toBeNull();
         });
+
+        it("aborts the host request when its boot timeout expires", async () => {
+            let requestSignal: AbortSignal | undefined;
+            const client = {
+                config: {
+                    get: (options?: { signal?: AbortSignal }) => {
+                        requestSignal = options?.signal;
+                        return new Promise<{ data?: unknown }>((_resolve, reject) => {
+                            options?.signal?.addEventListener(
+                                "abort",
+                                () => reject(options.signal?.reason ?? new Error("aborted")),
+                                { once: true },
+                            );
+                        });
+                    },
+                },
+            };
+
+            const result = await resolveCompactionForBoot(client, 20);
+
+            expect(result).toBeNull();
+            expect(requestSignal).toBeDefined();
+            expect(requestSignal?.aborted).toBe(true);
+        });
     });
 });

package/src/shared/conflict-detector.ts

@@ -209,7 +209,7 @@ export function detectConflicts(
  */
 export interface OpencodeConfigClientLike {
     config: {
-        get: () => Promise<{ data?: unknown }>;
+        get: (options?: { signal?: AbortSignal }) => Promise<{ data?: unknown }>;
     };
 }
 
@@ -250,13 +250,29 @@ export async function resolveCompactionForBoot(
     client: OpencodeConfigClientLike,
     timeoutMs = 2_000,
 ): Promise<ResolvedCompaction | null> {
+    const controller = new AbortController();
+    let timer: ReturnType<typeof setTimeout> | undefined;
     try {
-        const result = await Promise.race([
-            client.config.get(),
-            new Promise<never>((_, reject) =>
-                setTimeout(() => reject(new Error("config.get() timed out")), timeoutMs),
-            ),
-        ]);
+        // Install the deadline before invoking the generated SDK method. During
+        // OpenCode bootstrap, /config can recursively wait for the same project
+        // instance that is currently loading this plugin. Deferring invocation
+        // ensures the deadline exists before any synchronous SDK/fetch prefix runs.
+        const timeout = new Promise<null>((resolve) => {
+            timer = setTimeout(
+                () => {
+                    controller.abort(new Error("config.get() timed out"));
+                    resolve(null);
+                },
+                Math.max(0, timeoutMs),
+            );
+            (timer as { unref?: () => void }).unref?.();
+        });
+        const request = Promise.resolve().then(() =>
+            client.config.get({ signal: controller.signal }),
+        );
+        const result = await Promise.race([request, timeout]);
+        if (result === null) return null;
+
         // The SDK's generated `Config` type has no `compaction` key, so read it
         // defensively from the runtime response.
         const compaction = (result?.data as ResolvedCompactionBlock | undefined)?.compaction;
@@ -272,6 +288,8 @@ export async function resolveCompactionForBoot(
         return { auto: compaction.auto, prune: compaction.prune };
     } catch {
         return null;
+    } finally {
+        if (timer) clearTimeout(timer);
     }
 }
 

package/src/shared/data-path.ts

@@ -13,16 +13,17 @@ export function getDataDir(): string {
  * Layout:
  *   - OpenCode: `${os.tmpdir()}/opencode/magic-context/`
  *   - Pi:       `${os.tmpdir()}/pi/magic-context/`
+ *   - OMP:      `${os.tmpdir()}/omp/magic-context/`
  *
  * Why a per-harness subtree of `os.tmpdir()`:
  *   1. OpenCode Desktop runs as an Electron app with a permission sandbox.
  *      Writing to arbitrary tmp paths can trigger user-visible permission
  *      prompts; the `${tmpdir}/opencode/` subtree is allow-listed by
  *      OpenCode, so anything we put under it never asks for permission.
- *   2. Splitting OpenCode from Pi keeps their logs and historian dump
- *      directories cleanly separated. `doctor --issue` for each harness
- *      reports diagnostics from the matching subtree, so an OpenCode
- *      issue report never includes Pi log noise (and vice versa).
+ *   2. Splitting harnesses keeps their logs and historian dump directories
+ *      cleanly separated. `doctor --issue` for each harness reports diagnostics
+ *      from the matching subtree, so issue reports do not include another
+ *      harness's log noise.
  *   3. Pi has no permission sandbox, so the path choice is purely
  *      cosmetic for Pi — it just keeps the layout symmetric.
  *
@@ -37,13 +38,13 @@ export function getMagicContextTempDir(harness: HarnessId = getHarness()): strin
 }
 
 /**
- * Standard log file path the plugin writes to. Pi and OpenCode write to
- * SEPARATE logs under their respective harness subtrees so a single
- * machine running both harnesses doesn't interleave session traces.
+ * Standard log file path the plugin writes to. Each harness writes to a
+ * separate log under its own subtree so a machine running multiple harnesses
+ * does not interleave session traces.
  *
  * The plugin's buffered logger calls this on every flush rather than
- * caching, so `setHarness("pi")` taking effect after module load is
- * reflected in the next flush.
+ * caching, so the boot-time `setHarness()` call is reflected in the next
+ * flush.
  */
 export function getMagicContextLogPath(harness: HarnessId = getHarness()): string {
     // An explicit override wins over the harness temp-dir default, so users on

package/src/shared/harness-provider-map.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import {
+    canonicalModelIdentity,
     modelRefLookupOrder,
     ompModelRefToCanonical,
     piModelRefToCanonical,
@@ -8,6 +9,21 @@ import {
 } from "./harness-provider-map";
 
 describe("harness-provider-map", () => {
+    describe("canonicalModelIdentity", () => {
+        it("collapses Astra route aliases without changing unrelated Copilot models", () => {
+            for (const ref of [
+                "openai/gpt-6-astra",
+                "openai-codex/gpt-6-astra",
+                "github-copilot/gpt-6-astra",
+            ]) {
+                expect(canonicalModelIdentity(ref)).toBe("openai/gpt-6-astra");
+            }
+            expect(canonicalModelIdentity("github-copilot/claude-opus-5")).toBe(
+                "github-copilot/claude-opus-5",
+            );
+        });
+    });
+
     describe("resolveModelRefForPi (canonical -> Pi, used when spawning)", () => {
         it("maps the diverging auth-plugin providers, preserving the model id", () => {
             expect(resolveModelRefForPi("openai/gpt-5.5")).toBe("openai-codex/gpt-5.5");

package/src/shared/harness-provider-map.ts

@@ -58,6 +58,10 @@ const OMP_TO_CANONICAL_PROVIDER: Readonly<Record<string, string>> = {
     "opencode-zen": "opencode",
 };
 
+const CANONICAL_MODEL_IDENTITY_ALIASES: Readonly<Record<string, string>> = {
+    "github-copilot/gpt-6-astra": "openai/gpt-6-astra",
+};
+
 /** Remap only the provider prefix (text before the first "/"), preserving the
  *  model id verbatim. No "/", empty provider, or unmapped provider -> unchanged.
  *  Lookups are own-property only, so provider ids that collide with
@@ -72,6 +76,17 @@ function remapProviderPrefix(ref: string, map: Readonly<Record<string, string>>)
     return `${map[provider]}${ref.slice(slash)}`;
 }
 
+/**
+ * Canonicalize only for identity comparisons and cache policy; callers must not
+ * use the result as a provider spawn route. Provider-wide Pi/OMP aliases are
+ * normalized first; model-specific aliases stay explicit because GitHub Copilot
+ * also serves non-OpenAI model families.
+ */
+export function canonicalModelIdentity(ref: string): string {
+    const harnessCanonical = piModelRefToCanonical(ompModelRefToCanonical(ref));
+    return CANONICAL_MODEL_IDENTITY_ALIASES[harnessCanonical.toLowerCase()] ?? harnessCanonical;
+}
+
 /** Pi-native `provider/model` -> canonical (OpenCode). Identity when unmapped.
  *  Used by the Pi setup wizard so configs it writes stay OpenCode-readable. */
 export function piModelRefToCanonical(ref: string): string {

package/src/shared/harness.ts

@@ -2,7 +2,7 @@
  * Identifier for the host harness this plugin is running inside.
  *
  * Magic Context's SQLite database lives at a vendor-scoped path
- * (`~/.local/share/cortexkit/magic-context/`) so OpenCode and Pi can share
+ * (`~/.local/share/cortexkit/magic-context/`) so OpenCode, Pi, and OMP can share
  * project memories, embedding cache, dreamer runs, and other project-scoped
  * state. Session-scoped tables carry a `harness` column populated from this
  * module so we can disambiguate which harness wrote each session row,
@@ -13,13 +13,13 @@
  * happens:
  * - OpenCode plugin: relies on the default ("opencode") — no setHarness call
  *   needed
- * - Pi plugin: calls `setHarness("pi")` before opening the database
+ * - Pi-compatible plugin: resolves the host and calls `setHarness("pi" | "omp")` before opening the database
  *
  * NEVER read this from configuration or session state — it is a
  * boot-time constant per plugin instance. Cross-harness leakage is a
  * correctness bug, not a feature.
  */
-export type HarnessId = "opencode" | "pi";
+export type HarnessId = "opencode" | "pi" | "omp";
 
 let currentHarness: HarnessId = "opencode";
 let harnessLocked = false;

package/src/shared/jsonc-parser.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
 
-import { parseJsonc } from "./jsonc-parser";
+import { parseJsonc, parseJsoncRecovering } from "./jsonc-parser";
 
 describe("parseJsonc prototype-pollution hardening", () => {
     it("rejects dangerous keys recursively, including inside arrays", () => {
@@ -30,4 +30,17 @@ describe("parseJsonc prototype-pollution hardening", () => {
         expect(Object.getPrototypeOf(items[0])).toBe(Object.prototype);
         expect("polluted" in items[0]).toBe(false);
     });
+
+    it("preserves hardening when tolerant recovery encounters __proto__", () => {
+        const rejected: string[] = [];
+        const parsed = parseJsoncRecovering<Record<string, unknown>>(
+            '\\{\n"__proto__":{"polluted":true},"cache_ttl":"1h"}',
+            { onRejectedKey: (path) => rejected.push(path.join(".")) },
+        );
+
+        expect(parsed.value).toEqual({ cache_ttl: "1h" });
+        expect(parsed.issues[0]).toMatchObject({ line: 1, column: 1 });
+        expect(rejected).toContain("__proto__");
+        expect(({} as { polluted?: boolean }).polluted).toBeUndefined();
+    });
 });

package/src/shared/jsonc-parser.ts

@@ -1,5 +1,15 @@
 import { existsSync, readFileSync } from "node:fs";
 
+import {
+    type ParseError,
+    parse as parseJsoncDocument,
+    printParseErrorCode,
+} from "jsonc-parser/lib/esm/main.js";
+// ^ Deep ESM import on purpose, same as jsonc-edit.ts: the package's "main" is a
+// UMD bundle whose runtime-relative requires (`./impl/format`) survive bundling
+// verbatim and crash the plugin at boot. The build:dists load-probe gate exists
+// to catch exactly this; do not import the bare package name.
+
 export function stripJsonComments(content: string): string {
     let result = "";
     let inString = false;
@@ -155,6 +165,89 @@ export function sanitizeParsedJson<T>(
     return sanitized as T;
 }
 
+export interface JsoncParseIssue {
+    line: number;
+    column: number;
+    offset: number;
+    length: number;
+    message: string;
+}
+
+export interface RecoveringJsoncParseResult<T> {
+    value: T;
+    issues: JsoncParseIssue[];
+}
+
+function lineAndColumnAt(content: string, offset: number): { line: number; column: number } {
+    const before = content.slice(0, Math.max(0, offset));
+    const lines = before.split(/\r?\n/);
+    return { line: lines.length, column: (lines.at(-1)?.length ?? 0) + 1 };
+}
+
+function parseIssue(content: string, error: ParseError): JsoncParseIssue {
+    const location = lineAndColumnAt(content, error.offset);
+    const code = printParseErrorCode(error.error);
+    const message = code.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+    return {
+        ...location,
+        offset: error.offset,
+        length: error.length,
+        message,
+    };
+}
+
+/**
+ * Parse JSONC with the same recovery grammar used by the runtime config loaders.
+ * Syntax diagnostics are never discarded: callers must surface every non-empty
+ * `issues` result even when the parser recovered a usable object.
+ */
+function normalizeJsoncParserObjects(
+    value: unknown,
+    options: ParsedJsonSanitizerOptions,
+    path: string[] = [],
+): unknown {
+    if (Array.isArray(value)) {
+        return value.map((entry, index) =>
+            normalizeJsoncParserObjects(entry, options, [...path, String(index)]),
+        );
+    }
+    if (value === null || typeof value !== "object") return value;
+
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        // jsonc-parser assigns an own "__proto__" property through normal JS
+        // assignment, which changes only this parsed object's prototype. Treat
+        // that prototype as the rejected key and copy only its own safe fields.
+        options.onRejectedKey?.([...path, "__proto__"]);
+    }
+    const normalized: Record<string, unknown> = {};
+    for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
+        Object.defineProperty(normalized, key, {
+            configurable: true,
+            enumerable: true,
+            writable: true,
+            value: normalizeJsoncParserObjects(entry, options, [...path, key]),
+        });
+    }
+    return normalized;
+}
+
+export function parseJsoncRecovering<T = unknown>(
+    content: string,
+    options: ParsedJsonSanitizerOptions = {},
+): RecoveringJsoncParseResult<T> {
+    const errors: ParseError[] = [];
+    const parsed = parseJsoncDocument(content, errors, {
+        allowTrailingComma: true,
+        disallowComments: false,
+        allowEmptyContent: false,
+    }) as T;
+    return {
+        value: sanitizeParsedJson(normalizeJsoncParserObjects(parsed, options) as T, options),
+        issues: errors.map((error) => parseIssue(content, error)),
+    };
+}
+
 export function parseJsonc<T = unknown>(
     content: string,
     options: ParsedJsonSanitizerOptions = {},

package/src/shared/model-resolution.test.ts

@@ -130,6 +130,67 @@ describe("model-resolution", () => {
         });
     });
 
+    test("uses OMP blocks first, falls back to Pi blocks, then preserves existing defaults", () => {
+        const configured = {
+            historian: {
+                pi: {
+                    model: { model: "pi/historian", thinking_level: "high" },
+                    fallback_models: ["pi/historian-fallback"],
+                },
+                omp: {
+                    model: { model: "omp/historian", thinking_level: "auto" },
+                    fallback_models: [{ model: "omp/historian-fallback", thinking_level: "max" }],
+                },
+            },
+            dreamer: {
+                tasks: { verify: { schedule: "0 3 * * *" } },
+                pi: {
+                    model: "pi/dreamer",
+                    tasks: { verify: { model: "pi/verify" } },
+                },
+                omp: {
+                    model: "omp/dreamer",
+                    tasks: {
+                        verify: {
+                            model: { model: "omp/verify", thinking_level: "inherit" },
+                        },
+                    },
+                },
+            },
+        };
+
+        expect(resolveHistorianModel(configured, "omp")).toEqual({
+            primary: { model: "omp/historian", qualifier: "auto" },
+            fallbacks: [{ model: "omp/historian-fallback", qualifier: "max" }],
+        });
+        expect(
+            resolveDreamerTaskModel({ config: configured, harness: "omp", task: "verify" }),
+        ).toMatchObject({ primary: { model: "omp/verify", qualifier: "inherit" } });
+
+        const piFallback = {
+            historian: configured.historian,
+            dreamer: { ...configured.dreamer, omp: undefined },
+        };
+        delete (piFallback.historian as { omp?: unknown }).omp;
+        expect(resolveHistorianModel(piFallback, "omp")?.primary).toEqual({
+            model: "pi/historian",
+            qualifier: "high",
+        });
+        expect(
+            resolveDreamerTaskModel({ config: piFallback, harness: "omp", task: "verify" }),
+        ).toMatchObject({ primary: { model: "pi/verify" } });
+
+        expect(resolveHistorianModel({}, "omp")).toEqual({ fallbacks: [] });
+        const existingDefaults = resolveDreamerTaskModel({
+            config: { dreamer: { tasks: { verify: { schedule: "0 3 * * *" } } } },
+            harness: "omp",
+            task: "verify",
+        });
+        expect(existingDefaults.primary).toBeUndefined();
+        expect(existingDefaults.fallbacks).toEqual([]);
+        expect(existingDefaults.schedule).toBe("0 3 * * *");
+    });
+
     test("resolves ordinary task model and scheduling without crossing harnesses", () => {
         const config = {
             dreamer: {