@cortexkit/opencode-magic-context 0.47.0 → 0.48.0

package/src/shared/host-stall-profiler-report.ts

@@ -0,0 +1,248 @@
+/**
+ * Shared host stall report helpers. Both JavaScriptCore and V8 samples use
+ * innermost-first frames so native calls can be attributed to their JS caller.
+ *
+ * Kept separate from runtime backends so attribution can be tested without
+ * running watchdog timers or starting a sampling profiler.
+ */
+
+import { readFileSync } from "node:fs";
+import * as path from "node:path";
+
+/** One frame from Bun's JavaScriptCore sampling API; V8 frames are normalized to this shape. */
+export interface JscSampleFrame {
+    name?: string;
+    sourceURL?: string;
+    line?: number;
+    column?: number;
+    category?: string;
+}
+
+/** One sample: `frames[0]` is the innermost (currently executing) frame. */
+export interface JscSampleTrace {
+    /** Monotonic seconds. JSC has a separate origin; V8 conversion uses the watchdog clock. */
+    timestamp?: number;
+    frames?: JscSampleFrame[];
+}
+
+/** Deepest stack kept per sample; deeper frames are folded into one marker. */
+export const MAX_STACK_DEPTH = 64;
+export const TOP_STACK_COUNT = 30;
+export const TOP_FRAME_COUNT = 30;
+
+/** JSC uses UINT32_MAX for "no line/column known". */
+const UNKNOWN_POSITION = 4294967295;
+
+/**
+ * Owners that never explain a stall by themselves: a native host function is
+ * attributed to its JavaScript caller, and host-core/runtime frames sit below
+ * every plugin hook. A sample is attributed to the innermost frame whose owner
+ * is NOT one of these, so a plugin calling a blocking native API is blamed,
+ * not the native API or the host that invoked the plugin.
+ */
+const BACKGROUND_OWNERS = new Set(["native", "runtime", "opencode", "pi", "omp"]);
+
+const packageNameCache = new Map<string, string | null>();
+
+function urlToPath(url: string): string {
+    if (url.startsWith("file://")) {
+        try {
+            return decodeURIComponent(new URL(url).pathname);
+        } catch {
+            return url.slice("file://".length);
+        }
+    }
+    return url;
+}
+
+/**
+ * Nearest `package.json` name above a source file, memoized per directory.
+ * Only reached for sources outside `node_modules` (a plugin loaded from a
+ * local checkout), and only after a stall has ended, so the bounded
+ * synchronous reads never run on a hot path.
+ */
+function nearestPackageName(filePath: string): string | null {
+    let dir = path.dirname(filePath);
+    const visited: string[] = [];
+    for (let depth = 0; depth < 12; depth++) {
+        const cached = packageNameCache.get(dir);
+        if (cached !== undefined) {
+            for (const seen of visited) packageNameCache.set(seen, cached);
+            return cached;
+        }
+        visited.push(dir);
+        try {
+            const parsed = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8")) as {
+                name?: unknown;
+            };
+            const name = typeof parsed.name === "string" && parsed.name ? parsed.name : null;
+            if (name) {
+                for (const seen of visited) packageNameCache.set(seen, name);
+                return name;
+            }
+        } catch {
+            // No readable package.json at this level; keep walking up.
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    for (const seen of visited) packageNameCache.set(seen, null);
+    return null;
+}
+
+/**
+ * Map a frame's source URL to the code that owns it.
+ *
+ * - no URL: `native` (a host function such as a SQLite `get` or `readFileSync`)
+ * - Bun/Node builtin modules: `runtime`
+ * - the compiled OpenCode binary's embedded filesystem (`$bunfs`, `~BUN`): `opencode`
+ * - anything under `node_modules/<pkg>`: `npm:<pkg>` (the innermost package)
+ * - Pi/OMP core packages: `pi` / `omp`; agent extensions: package name or `extension:<entry>`
+ * - a file in an OpenCode `plugin/` or `plugins/` directory: `plugin:<file>`
+ * - any other file: `pkg:<name>` from the nearest package.json, else `file:<path>`
+ */
+export function sourceOwner(sourceURL: string | undefined): string {
+    if (!sourceURL) return "native";
+    if (/^(?:node|bun|builtin|internal):/.test(sourceURL)) return "runtime";
+    if (sourceURL.includes("$bunfs") || sourceURL.includes("~BUN")) return "opencode";
+    const filePath = urlToPath(sourceURL).replaceAll("\\", "/");
+    const modules = [...filePath.matchAll(/\/node_modules\/((?:@[^/]+\/)?[^/]+)/g)];
+    const innermost = modules.at(-1);
+    if (innermost) {
+        const name = innermost[1];
+        if (name === "@cortexkit/pi-magic-context") return `pkg:${name}`;
+        if (/^@(?:earendil-works|mariozechner)\/pi-(?:coding-agent|agent-core|ai|tui)$/.test(name))
+            return "pi";
+        if (/^@oh-my-pi\/pi-(?:coding-agent|agent-core|ai|tui)$/.test(name)) return "omp";
+        return `npm:${name}`;
+    }
+    const extension = filePath.match(/\/(?:\.pi|\.omp)\/agent\/extensions\/([^/]+)/);
+    if (extension) {
+        const name = nearestPackageName(filePath);
+        return name ? `pkg:${name}` : `extension:${extension[1]}`;
+    }
+    const pluginDir = filePath.match(/\/plugins?\/([^/]+)$/);
+    if (pluginDir && /\/(?:\.?opencode)\/plugins?\//.test(filePath)) {
+        return `plugin:${pluginDir[1]}`;
+    }
+    const name = nearestPackageName(filePath);
+    return name ? `pkg:${name}` : `file:${filePath}`;
+}
+
+function frameLabel(frame: JscSampleFrame): string {
+    const name = frame.name && frame.name.length > 0 ? frame.name : "(anonymous)";
+    if (!frame.sourceURL) return `${name} [native]`;
+    const line =
+        typeof frame.line === "number" && frame.line !== UNKNOWN_POSITION ? `:${frame.line}` : "";
+    return `${name} ${frame.sourceURL}${line}`;
+}
+
+export interface OwnedFrame {
+    label: string;
+    owner: string;
+}
+
+/** Prefer the innermost plugin/extension frame over native, runtime or host-core callers. */
+export function attributeSample(frames: OwnedFrame[]): string {
+    for (const frame of frames) {
+        if (!BACKGROUND_OWNERS.has(frame.owner)) return frame.owner;
+    }
+    for (const frame of frames) {
+        if (frame.owner !== "native") return frame.owner;
+    }
+    return "native";
+}
+
+export interface CountedFrame {
+    frame: string;
+    owner: string;
+    samples: number;
+}
+
+export interface CountedStack {
+    samples: number;
+    owner: string;
+    frames: string[];
+}
+
+export interface StallAggregate {
+    samples: number;
+    owners: Array<{ owner: string; samples: number; percent: number }>;
+    /** Innermost frame of each sample, native host functions included. */
+    top_frames: CountedFrame[];
+    /** Innermost frame that has JavaScript source, i.e. the JS caller of any native frame. */
+    top_js_frames: CountedFrame[];
+    top_stacks: CountedStack[];
+}
+
+function bump<T>(map: Map<string, T & { samples: number }>, key: string, init: () => T): void {
+    const existing = map.get(key);
+    if (existing) existing.samples += 1;
+    else map.set(key, { ...init(), samples: 1 });
+}
+
+function topBySamples<T extends { samples: number }>(values: Iterable<T>, limit: number): T[] {
+    return [...values].sort((a, b) => b.samples - a.samples).slice(0, limit);
+}
+
+export function aggregateTraces(traces: JscSampleTrace[]): StallAggregate {
+    const ownerOf = new Map<string, string>();
+    const owned = (frame: JscSampleFrame): OwnedFrame => {
+        const url = frame.sourceURL ?? "";
+        let owner = ownerOf.get(url);
+        if (owner === undefined) {
+            owner = sourceOwner(frame.sourceURL);
+            ownerOf.set(url, owner);
+        }
+        return { label: frameLabel(frame), owner };
+    };
+
+    const owners = new Map<string, { owner: string; samples: number }>();
+    const topFrames = new Map<string, CountedFrame>();
+    const topJsFrames = new Map<string, CountedFrame>();
+    const stacks = new Map<string, CountedStack>();
+    let samples = 0;
+
+    for (const trace of traces) {
+        const raw = Array.isArray(trace.frames) ? trace.frames : [];
+        if (raw.length === 0) continue;
+        samples += 1;
+        const frames = raw.slice(0, MAX_STACK_DEPTH).map(owned);
+        const owner = attributeSample(frames);
+        bump(owners, owner, () => ({ owner }));
+
+        const leaf = frames[0];
+        bump(topFrames, `${leaf.owner}\u0000${leaf.label}`, () => ({
+            frame: leaf.label,
+            owner: leaf.owner,
+        }));
+        const jsIndex = raw.findIndex(
+            (frame, index) => index < MAX_STACK_DEPTH && !!frame.sourceURL,
+        );
+        if (jsIndex >= 0) {
+            const js = frames[jsIndex];
+            bump(topJsFrames, `${js.owner}\u0000${js.label}`, () => ({
+                frame: js.label,
+                owner: js.owner,
+            }));
+        }
+
+        const labels = frames.map((frame) => `${frame.label} (${frame.owner})`);
+        if (raw.length > MAX_STACK_DEPTH) {
+            labels.push(`… ${raw.length - MAX_STACK_DEPTH} outer frames omitted`);
+        }
+        bump(stacks, labels.join("\n"), () => ({ owner, frames: labels }));
+    }
+
+    return {
+        samples,
+        owners: topBySamples(owners.values(), Number.POSITIVE_INFINITY).map((entry) => ({
+            ...entry,
+            percent: samples === 0 ? 0 : Math.round((entry.samples / samples) * 1000) / 10,
+        })),
+        top_frames: topBySamples(topFrames.values(), TOP_FRAME_COUNT),
+        top_js_frames: topBySamples(topJsFrames.values(), TOP_FRAME_COUNT),
+        top_stacks: topBySamples(stacks.values(), TOP_STACK_COUNT),
+    };
+}

package/src/shared/host-stall-profiler.ts

@@ -0,0 +1,57 @@
+import * as path from "node:path";
+import { getMagicContextStorageDir } from "./data-path";
+import { createHostStallProfiler } from "./host-stall-profiler-bun";
+import {
+    HOST_PROFILER_DIRNAME,
+    type HostStallProfilerHandle,
+    type ProfilerRuntimeDeps,
+} from "./host-stall-profiler-common";
+import { createNodeHostStallProfiler, type InspectorSession } from "./host-stall-profiler-node";
+import { log } from "./logger";
+
+export * from "./host-stall-profiler-common";
+
+export function hostStallProfilerDir(): string {
+    return path.join(getMagicContextStorageDir(), HOST_PROFILER_DIRNAME);
+}
+
+const PROCESS_PROFILER_KEY = Symbol.for("cortexkit.magic-context.host-stall-profiler");
+// Resolve at runtime: Node-only consumers do not install Bun's type declarations.
+const jscModule: string = "bun:jsc";
+
+/** All plugin/project instances watch the same main thread and share one sampler. */
+export function startHostStallProfilerSwitch(): void {
+    try {
+        const holder = globalThis as unknown as Record<symbol, HostStallProfilerHandle | undefined>;
+        if (holder[PROCESS_PROFILER_KEY]) return;
+        const deps: ProfilerRuntimeDeps = {
+            profilerDir: hostStallProfilerDir,
+            now: () => performance.now(),
+            wallNow: () => Date.now(),
+            setInterval: (callback, ms) => {
+                const handle = setInterval(callback, ms);
+                (handle as { unref?: () => void }).unref?.();
+                return handle;
+            },
+            clearInterval: (handle) => clearInterval(handle as ReturnType<typeof setInterval>),
+            rss: () => process.memoryUsage.rss(),
+            log,
+            pid: process.pid,
+            bunVersion: process.versions.bun ?? null,
+        };
+        const handle = process.versions.bun
+            ? createHostStallProfiler({ ...deps, loadJsc: () => import(jscModule) })
+            : createNodeHostStallProfiler({
+                  ...deps,
+                  createSession: async () => {
+                      const { Session } = await import("node:inspector");
+                      return new Session() as unknown as InspectorSession;
+                  },
+                  memoryUsage: () => process.memoryUsage(),
+              });
+        holder[PROCESS_PROFILER_KEY] = handle;
+        handle.start();
+    } catch (error) {
+        log("[magic-context] host stall profiler: could not start the enable-file switch", error);
+    }
+}

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

@@ -231,41 +231,78 @@ describe("model-resolution", () => {
         });
     });
 
-    test("uses mural model between compress-cues task and harness default", () => {
+    test("resolves compress-cues to each harness's dreamer default and ignores mural.model", () => {
+        // The retired shared mural.model sits in the same config to prove it
+        // no longer feeds resolution on any harness.
         const config = {
+            mural: { enabled: true, model: "google/antigravity-gemini-3.8-flash" },
             dreamer: {
                 tasks: { "compress-cues": { schedule: "0 4 * * *" } },
                 opencode: {
                     model: { model: "open/default", variant: "default-variant" },
-                    tasks: { "compress-cues": { variant: "task-local-must-not-leak" } },
                 },
                 pi: {
-                    model: { model: "pi/default", thinking_level: "high" },
+                    model: {
+                        model: "google-antigravity/antigravity-gemini-3.8-flash",
+                        thinking_level: "high",
+                    },
                     tasks: { "compress-cues": {} },
                 },
             },
         };
 
         expect(
-            resolveDreamerTaskModel({
-                config,
-                harness: "opencode",
-                task: "compress-cues",
-                muralModel: "mural/model",
-            }),
+            resolveDreamerTaskModel({ config, harness: "opencode", task: "compress-cues" }),
         ).toMatchObject({
-            primary: { model: "mural/model", qualifier: "default-variant" },
+            primary: { model: "open/default", qualifier: "default-variant" },
             fallbacks: [],
+            schedule: "0 4 * * *",
         });
         expect(
-            resolveDreamerTaskModel({
-                config,
-                harness: "pi",
-                task: "compress-cues",
-                muralModel: "mural/model",
-            }),
+            resolveDreamerTaskModel({ config, harness: "pi", task: "compress-cues" }),
+        ).toMatchObject({
+            primary: {
+                model: "google-antigravity/antigravity-gemini-3.8-flash",
+                qualifier: "high",
+            },
+            fallbacks: [],
+            schedule: "0 4 * * *",
+        });
+    });
+
+    test("a per-harness compress-cues task override wins over the harness default", () => {
+        const config = {
+            mural: { enabled: true, model: "shared/must-not-win" },
+            dreamer: {
+                opencode: {
+                    model: "open/default",
+                    fallback_models: ["open/default-fallback"],
+                    tasks: {
+                        "compress-cues": {
+                            model: { model: "open/cues", variant: "low" },
+                            fallback_models: ["open/cues-fallback"],
+                        },
+                    },
+                },
+                pi: {
+                    model: "pi/default",
+                    thinking_level: "high",
+                    tasks: { "compress-cues": { model: "pi/cues" } },
+                },
+            },
+        };
+
+        expect(
+            resolveDreamerTaskModel({ config, harness: "opencode", task: "compress-cues" }),
+        ).toMatchObject({
+            primary: { model: "open/cues", qualifier: "low" },
+            fallbacks: [{ model: "open/cues-fallback" }],
+        });
+        // A task override without its own qualifier uses the harness default's qualifier.
+        expect(
+            resolveDreamerTaskModel({ config, harness: "pi", task: "compress-cues" }),
         ).toMatchObject({
-            primary: { model: "mural/model", qualifier: "high" },
+            primary: { model: "pi/cues", qualifier: "high" },
             fallbacks: [],
         });
     });

package/src/shared/model-resolution.ts

@@ -137,14 +137,13 @@ export interface ResolvedDreamerTaskModel {
 
 /**
  * Resolve a dreamer task from one harness subtree. Model selection is task →
- * harness default, except compress-cues inserts its harness-independent mural
- * string between those two rungs. Scheduling remains at dreamer.tasks.<task>.
+ * harness default for every task, compress-cues included. Scheduling remains
+ * at dreamer.tasks.<task>.
  */
 export function resolveDreamerTaskModel(args: {
     config: unknown;
     harness: ModelHarness;
     task: string;
-    muralModel?: unknown;
 }): ResolvedDreamerTaskModel {
     const dreamer = asRecord(asRecord(args.config)?.dreamer);
     const harnessBlock = resolveHarnessBlock(dreamer, args.harness);
@@ -166,19 +165,13 @@ export function resolveDreamerTaskModel(args: {
     }
 
     const taskQualifier = taskBlock?.[args.harness === "opencode" ? "variant" : "thinking_level"];
-    // A mural string borrows the harness default's qualifier whether that
-    // qualifier is written beside `model` or inside the default entry object.
+    // A task override without its own qualifier borrows the harness default's
+    // qualifier, whether written beside `model` or inside the default entry object.
     const harnessQualifier =
         harnessBlock[args.harness === "opencode" ? "variant" : "thinking_level"] ??
         normalizeModelEntry(harnessBlock.model, args.harness)?.qualifier;
     const taskHasModel = taskBlock !== undefined && hasOwn(taskBlock, "model");
-    const usesMuralModel =
-        !taskHasModel && args.task === "compress-cues" && Boolean(readString(args.muralModel));
-    const primarySource = taskHasModel
-        ? taskBlock?.model
-        : usesMuralModel
-          ? args.muralModel
-          : harnessBlock.model;
+    const primarySource = taskHasModel ? taskBlock?.model : harnessBlock.model;
     const fallbackSource =
         taskBlock !== undefined && hasOwn(taskBlock, "fallback_models")
             ? taskBlock.fallback_models
@@ -187,11 +180,7 @@ export function resolveDreamerTaskModel(args: {
     return {
         primary: resolvePrimaryEntry({
             entry: primarySource,
-            // mural.model is a plain string, so its qualifier is always the
-            // executing harness default rather than a task-local default.
-            defaultQualifier: usesMuralModel
-                ? harnessQualifier
-                : (taskQualifier ?? harnessQualifier),
+            defaultQualifier: taskQualifier ?? harnessQualifier,
             harness: args.harness,
         }),
         fallbacks: resolveFallbackEntries(fallbackSource, args.harness),

package/src/shared/sqlite.test.ts

@@ -1,12 +1,64 @@
 import { describe, expect, it } from "bun:test";
+import { spawnSync } from "node:child_process";
 import {
     Database,
+    detectSqliteRuntime,
     getSqliteMemoryStats,
     loadSqliteModule,
     SqliteRuntimeUnavailableError,
 } from "./sqlite";
 
 describe("SQLite runtime selector", () => {
+    it("suppresses only the node:sqlite experimental warning in a real Node process", () => {
+        // Node 24.21 no longer emits this warning, so inject it during loading
+        // to keep the suppression assertion load-bearing on newer runtimes.
+        const selectorUrl = new URL("./sqlite.ts", import.meta.url).href;
+        const script = `
+            import { loadSqliteModule } from ${JSON.stringify(selectorUrl)};
+            const originalEmitWarning = process.emitWarning;
+            let listenerSawX = false;
+            process.on("warning", (warning) => {
+                if (warning.message === "x") listenerSawX = true;
+            });
+            await loadSqliteModule("Node.js", async (specifier) => {
+                if (specifier !== "node:sqlite") throw new Error("unexpected backend: " + specifier);
+                process.emitWarning("SQLite is an experimental feature and might change at any time", "ExperimentalWarning");
+                process.emitWarning("x", "ExperimentalWarning");
+                return {};
+            });
+            if (process.emitWarning !== originalEmitWarning) throw new Error("emitWarning was not restored");
+            process.emitWarning("after", "ExperimentalWarning");
+            await new Promise((resolve) => setImmediate(resolve));
+            if (!listenerSawX) throw new Error("the original warning listener was not called");
+        `;
+        const child = spawnSync("node", ["--trace-warnings", "--input-type=module", "-e", script], {
+            encoding: "utf8",
+            windowsHide: true,
+        });
+
+        expect(child.error).toBeUndefined();
+        expect(child.status).toBe(0);
+        expect(child.stderr).not.toContain("SQLite is an experimental feature");
+        expect(child.stderr).toContain("ExperimentalWarning: x");
+        expect(child.stderr).toContain("ExperimentalWarning: after");
+        expect(child.stderr).toMatch(/ExperimentalWarning: x[\s\S]*?\n\s+at /);
+    });
+
+    it("leaves Bun and OpenCode warning emission untouched", async () => {
+        expect(detectSqliteRuntime()).toBe("Bun");
+        const originalEmitWarning = process.emitWarning;
+        let requestedSpecifier = "";
+
+        await loadSqliteModule("Bun", async (specifier) => {
+            requestedSpecifier = specifier;
+            expect(process.emitWarning).toBe(originalEmitWarning);
+            return {};
+        });
+
+        expect(requestedSpecifier).toBe("bun:sqlite");
+        expect(process.emitWarning).toBe(originalEmitWarning);
+    });
+
     it("reports live connection PRAGMAs and removes closed handles", () => {
         const before = getSqliteMemoryStats().connectionCount;
         const db = new Database(":memory:");