@cortexkit/opencode-magic-context 0.36.0 → 0.36.1

package/src/shared/prompt-surface.test.ts

@@ -1,7 +1,13 @@
 import { describe, expect, it } from "bun:test";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 
 import { resolveCacheTtl } from "../hooks/magic-context/event-resolvers";
-import { modelKeyLookupOrder, resolvePromptSurface } from "./prompt-surface";
+import {
+    modelKeyLookupOrder,
+    promptSurfaceConfigIdentity,
+    resolvePromptSurface,
+} from "./prompt-surface";
 
 describe("prompt-surface resolution", () => {
     it("keeps cache_ttl and prompt-surface routing on the same lookup walk", () => {
@@ -11,6 +17,7 @@ describe("prompt-surface resolution", () => {
             "google/*": "light" as const,
             "CaseSensitive/model": "light" as const,
             "progressive/base": "light" as const,
+            "bare-model": "light" as const,
         };
         const cacheTtl = {
             default: "full",
@@ -26,6 +33,7 @@ describe("prompt-surface resolution", () => {
             ["casesensitive/model", "full"],
             ["CaseSensitive/model", "light"],
             ["progressive/base-extra", "light"],
+            ["provider/bare-model", "light"],
             ["unknown/model", "full"],
             [undefined, "full"],
         ] as const;
@@ -39,11 +47,50 @@ describe("prompt-surface resolution", () => {
         }
     });
 
-    it("applies exact, wildcard, then default precedence", () => {
+    it("derives a stable config identity independent of object key order", () => {
+        const left = promptSurfaceConfigIdentity({
+            default: "full",
+            models: { "provider/b": "light", "provider/a": "full" },
+            tool_descriptions: { ctx_search: "Search", ctx_note: "Note" },
+        });
+        const right = promptSurfaceConfigIdentity({
+            tool_descriptions: { ctx_note: "Note", ctx_search: "Search" },
+            models: { "provider/a": "full", "provider/b": "light" },
+            default: "full",
+        });
+        expect(left).toBe(right);
+        expect(
+            promptSurfaceConfigIdentity({ default: "light", models: { "provider/a": "full" } }),
+        ).not.toBe(right);
+    });
+
+    it("matches the Rust cache_ttl resolver over shared routing vectors", () => {
+        const vectors = JSON.parse(
+            readFileSync(
+                resolve(
+                    import.meta.dir,
+                    "../../../../crates/mc-module/testdata/cache-ttl-routing-vectors.json",
+                ),
+                "utf8",
+            ),
+        ) as {
+            default: string;
+            models: Record<string, string>;
+            cases: Array<{ name: string; modelKey: string; expected: string }>;
+        };
+        const config = { default: vectors.default, ...vectors.models };
+
+        for (const vector of vectors.cases) {
+            expect(resolveCacheTtl(config, vector.modelKey), vector.name).toBe(vector.expected);
+        }
+    });
+
+    it("applies exact, bare, wildcard, then default precedence", () => {
         const config = {
             default: "full" as const,
             models: {
                 "provider/model": "light" as const,
+                bare: "light" as const,
                 "provider/*": "full" as const,
             },
         };
@@ -52,6 +99,10 @@ describe("prompt-surface resolution", () => {
             preset: "light",
             source: "exact",
         });
+        expect(resolvePromptSurface(config, "provider/bare")).toEqual({
+            preset: "light",
+            source: "bare",
+        });
         expect(resolvePromptSurface(config, "provider/other")).toEqual({
             preset: "full",
             source: "wildcard",

package/src/shared/prompt-surface.ts

@@ -13,14 +13,29 @@ export interface PromptSurfaceConfig {
     tool_descriptions?: Readonly<Record<string, string>>;
 }
 
-export type PromptSurfaceResolutionSource = "exact" | "wildcard" | "default";
+/** Stable wire identity for the config fields that can alter a served prompt surface. */
+export function promptSurfaceConfigIdentity(config: PromptSurfaceConfig | undefined): string {
+    return JSON.stringify({
+        default: config?.default ?? "full",
+        models: Object.entries(config?.models ?? {}).sort(([left], [right]) =>
+            left < right ? -1 : left > right ? 1 : 0,
+        ),
+        guidanceOverridePath: config?.guidance_override_path ?? null,
+        toolDescriptions: Object.entries(config?.tool_descriptions ?? {}).sort(([left], [right]) =>
+            left < right ? -1 : left > right ? 1 : 0,
+        ),
+    });
+}
+
+export type PromptSurfaceResolutionSource = "exact" | "bare" | "wildcard" | "default";
 
-/** Validate the literal provider/model and provider/* key grammar. */
+/** Validate bare model, provider/model, and provider/* routing keys. */
 export function isValidPromptSurfaceModelKey(key: string): boolean {
     if (key.length === 0 || key.trim() !== key) return false;
 
     const slash = key.indexOf("/");
-    if (slash <= 0 || slash === key.length - 1) return false;
+    if (slash < 0) return !key.includes("*");
+    if (slash === 0 || slash === key.length - 1) return false;
 
     const provider = key.slice(0, slash);
     const modelID = key.slice(slash + 1);
@@ -42,7 +57,7 @@ export function isValidPromptSurfaceModelKey(key: string): boolean {
     );
 }
 
-export type ModelKeyLookupSource = PromptSurfaceResolutionSource | "bare";
+export type ModelKeyLookupSource = Exclude<PromptSurfaceResolutionSource, "default">;
 
 export interface ModelKeyCandidate {
     key: string;
@@ -117,11 +132,7 @@ export function resolvePromptSurface(
     const fallback = config?.default ?? "full";
     const match = resolveModelConfigValue(config?.models, modelKey);
 
-    // Bare model keys are accepted by cache_ttl for compatibility, but the
-    // prompt_surface schema deliberately accepts only provider/model keys and
-    // provider wildcards. Ignore a bare entry if an unvalidated object reaches
-    // this API so prompt routing keeps its documented grammar.
-    if (match && match.source !== "bare") {
+    if (match) {
         return { preset: match.value, source: match.source };
     }
 

package/src/shared/rpc-utils.test.ts

@@ -6,6 +6,8 @@ import type { readFileSync } from "node:fs";
 import {
     __resetRpcIdentityTestHooks,
     __setRpcIdentityTestHooks,
+    discoverLivePiProcessIds,
+    inspectLivePiProcesses,
     isPidIdentityPlausible,
     type RpcPortFileRecord,
 } from "./rpc-utils";
@@ -44,6 +46,40 @@ afterEach(() => {
     __resetRpcIdentityTestHooks();
 });
 
+describe("discoverLivePiProcessIds", () => {
+    test("finds Pi-family harness commands while excluding the current process", () => {
+        __setRpcIdentityTestHooks({
+            processListExecFileSync: (() =>
+                [
+                    ` ${process.pid} /usr/local/bin/pi`,
+                    " 41001 /usr/local/bin/pi --model test",
+                    " 41002 node /opt/node_modules/@mariozechner/pi-coding-agent/dist/cli.js",
+                    " 41003 bun /opt/node_modules/@oh-my-pi/pi-coding-agent/dist/cli.js",
+                    " 41004 /Applications/OpenCode.app/Contents/MacOS/opencode",
+                    " 41005 node /workspace/pi-plugin/src/index.ts",
+                    " 41006 npm install @earendil-works/pi-coding-agent",
+                    " 41007 /usr/local/bin/omp --model test",
+                ].join("\n")) as typeof execFileSync,
+        });
+
+        expect(discoverLivePiProcessIds()).toEqual([41001, 41002, 41003, 41007]);
+    });
+
+    test("reports uncertainty instead of treating an unavailable process list as empty", () => {
+        __setRpcIdentityTestHooks({
+            processListExecFileSync: (() => {
+                throw new Error("ps unavailable");
+            }) as typeof execFileSync,
+        });
+
+        expect(inspectLivePiProcesses()).toEqual({
+            state: "unreadable",
+            processIds: [],
+            error: "ps unavailable",
+        });
+    });
+});
+
 describe("isPidIdentityPlausible", () => {
     test("rejects a reused Linux PID when proc start time is substantially newer", () => {
         const readPaths: string[] = [];

package/src/shared/rpc-utils.ts

@@ -67,6 +67,8 @@ const OPEN_CODE_COMMAND_MARKERS = ["opencode", "node", "bun", "electron"];
 
 let rpcIdentityReadFileSync: typeof readFileSync = readFileSync;
 let rpcIdentityExecFileSync: typeof execFileSync = execFileSync;
+let rpcProcessListExecFileSync: typeof execFileSync = execFileSync;
+let rpcProcessListTestOverride = false;
 let rpcIdentityPlatform: NodeJS.Platform = process.platform;
 let rpcIdentityNowMs: () => number = () => Date.now();
 
@@ -179,11 +181,14 @@ export function isPidIdentityPlausible(record: RpcPortFileRecord): boolean {
 export function __setRpcIdentityTestHooks(hooks: {
     readFileSync?: typeof readFileSync;
     execFileSync?: typeof execFileSync;
+    processListExecFileSync?: typeof execFileSync;
     platform?: NodeJS.Platform;
     nowMs?: () => number;
 }): void {
     rpcIdentityReadFileSync = hooks.readFileSync ?? readFileSync;
     rpcIdentityExecFileSync = hooks.execFileSync ?? execFileSync;
+    rpcProcessListExecFileSync = hooks.processListExecFileSync ?? execFileSync;
+    rpcProcessListTestOverride = hooks.processListExecFileSync !== undefined;
     rpcIdentityPlatform = hooks.platform ?? process.platform;
     rpcIdentityNowMs = hooks.nowMs ?? (() => Date.now());
 }
@@ -191,10 +196,76 @@ export function __setRpcIdentityTestHooks(hooks: {
 export function __resetRpcIdentityTestHooks(): void {
     rpcIdentityReadFileSync = readFileSync;
     rpcIdentityExecFileSync = execFileSync;
+    rpcProcessListExecFileSync = execFileSync;
+    rpcProcessListTestOverride = false;
     rpcIdentityPlatform = process.platform;
     rpcIdentityNowMs = () => Date.now();
 }
 
+function commandLooksLikePi(command: string): boolean {
+    const normalized = command.trim().toLowerCase().replaceAll("\\", "/");
+    const tokens = normalized.split(/\s+/).filter(Boolean);
+    const executableName = (token: string | undefined): string =>
+        (token ?? "").split("/").at(-1) ?? "";
+    const first = executableName(tokens[0]).replace(/\.exe$/, "");
+    if (["pi", "pi.cmd", "omp", "oh-my-pi"].includes(first)) return true;
+    if (["node", "bun", "deno"].includes(first)) {
+        const script = executableName(tokens[1]);
+        return (
+            ["pi", "pi.js", "pi.mjs", "pi.cjs"].includes(script) ||
+            normalized.includes("pi-coding-agent")
+        );
+    }
+    return false;
+}
+
+/** Result of checking whether Pi/OMP processes may currently hold the shared database. */
+export interface PiProcessDiscovery {
+    state: "known" | "unreadable";
+    processIds: number[];
+    error?: string;
+}
+
+/**
+ * Inspect Pi/OMP processes without converting a failed process-list probe into
+ * false evidence that no harness is running. Destructive maintenance callers
+ * use the unreadable state to fail closed; ordinary migration guards retain
+ * their historical best-effort process list through discoverLivePiProcessIds().
+ */
+export function inspectLivePiProcesses(): PiProcessDiscovery {
+    if (process.env.NODE_ENV === "test" && !rpcProcessListTestOverride) {
+        return { state: "known", processIds: [] };
+    }
+    try {
+        const output = String(
+            rpcProcessListExecFileSync("ps", ["-axo", "pid=,command="], {
+                encoding: "utf8",
+                timeout: PS_PROBE_TIMEOUT_MS,
+            }),
+        );
+        const pids = new Set<number>();
+        for (const line of output.split(/\r?\n/)) {
+            const match = /^\s*(\d+)\s+(.+)$/.exec(line);
+            if (!match) continue;
+            const pid = Number(match[1]);
+            if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) continue;
+            if (commandLooksLikePi(match[2])) pids.add(pid);
+        }
+        return { state: "known", processIds: [...pids].sort((left, right) => left - right) };
+    } catch (error) {
+        return {
+            state: "unreadable",
+            processIds: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+
+/** Enumerate live Pi/OMP harness processes before deciding whether migration can proceed. */
+export function discoverLivePiProcessIds(): number[] {
+    return inspectLivePiProcesses().processIds;
+}
+
 export function parseRpcPortFile(content: string, fallbackPid = 0): RpcPortFileRecord | null {
     const trimmed = content.trim();
     if (!trimmed) return null;

package/src/shared/tui-preferences.test.ts

@@ -1,9 +1,11 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { parse } from "comment-json";
 import {
+    __resetTuiPreferencesWatchTestHooks,
+    __setTuiPreferencesWatchTestHooks,
     computeEffectiveOrder,
     DEFAULT_PREFS,
     DEFAULT_SLOT_ORDER,
@@ -13,6 +15,7 @@ import {
     readTuiPreferencesFile,
     resolveMagicContextPrefs,
     TUI_PREFS_FILE_ENV,
+    watchTuiPreferences,
 } from "./tui-preferences";
 
 let dir: string;
@@ -28,6 +31,7 @@ beforeEach(async () => {
 });
 
 afterEach(async () => {
+    __resetTuiPreferencesWatchTestHooks();
     for (const key of ENV_KEYS) {
         if (savedEnv[key] === undefined) delete process.env[key];
         else process.env[key] = savedEnv[key];
@@ -79,6 +83,52 @@ describe("readTuiPreferencesFile (tolerant)", () => {
     });
 });
 
+describe("watchTuiPreferences", () => {
+    test("notifies when the initial read resolves after an atomic replacement", async () => {
+        const previous = `{"magic-context":{"sections":{"memory":true}}}\n`;
+        const next = `{"magic-context":{"sections":{"memory":false}}}\n`;
+        await writeFile(file, previous, "utf8");
+
+        let resolveInitialRead!: (text: string) => void;
+        const pendingInitialRead = new Promise<string>((resolve) => {
+            resolveInitialRead = resolve;
+        });
+        let emitWatchEvent!: (event: string, filename: string | null) => void;
+        let readCount = 0;
+        __setTuiPreferencesWatchTestHooks({
+            readFile: () => {
+                readCount += 1;
+                return readCount === 1 ? pendingInitialRead : Promise.resolve(next);
+            },
+            watch: (_directory, listener) => {
+                emitWatchEvent = listener;
+                return { close() {} };
+            },
+        });
+
+        const observed = new Promise<{ memory: boolean }>((resolve) => {
+            const stop = watchTuiPreferences(() => {
+                void readTuiPreferencesFile().then((root) => {
+                    stop();
+                    resolve({ memory: resolveMagicContextPrefs(root).sections.memory });
+                });
+            });
+        });
+
+        const replacement = `${file}.external.tmp`;
+        await writeFile(replacement, next, "utf8");
+        await rename(replacement, file);
+        emitWatchEvent("rename", basename(file));
+        resolveInitialRead(next);
+
+        const result = await Promise.race([
+            observed,
+            new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), 300)),
+        ]);
+        expect(result).toEqual({ memory: false });
+    });
+});
+
 describe("resolveMagicContextPrefs (per-key validation)", () => {
     test("missing key → full defaults clone", () => {
         expect(resolveMagicContextPrefs({})).toEqual(DEFAULT_PREFS);

package/src/shared/tui-preferences.ts

@@ -250,6 +250,28 @@ export function queueTuiPreferenceUpdate(
 
 const WATCH_DEBOUNCE_MS = 150;
 
+type WatchReadFile = (file: string) => Promise<string>;
+type WatchDirectory = (
+    directory: string,
+    listener: (event: string, filename: string | null) => void,
+) => { close(): void };
+
+let watchReadFile: WatchReadFile = (file) => readFile(file, "utf8");
+let watchDirectory: WatchDirectory = (directory, listener) => watch(directory, listener);
+
+export function __setTuiPreferencesWatchTestHooks(hooks: {
+    readFile?: WatchReadFile;
+    watch?: WatchDirectory;
+}): void {
+    watchReadFile = hooks.readFile ?? ((file) => readFile(file, "utf8"));
+    watchDirectory = hooks.watch ?? ((directory, listener) => watch(directory, listener));
+}
+
+export function __resetTuiPreferencesWatchTestHooks(): void {
+    watchReadFile = (file) => readFile(file, "utf8");
+    watchDirectory = (directory, listener) => watch(directory, listener);
+}
+
 // Watches the DIRECTORY, not the file: editors and our own atomic writes replace
 // the file via rename, which kills file-level watchers.
 //
@@ -266,16 +288,22 @@ export function watchTuiPreferences(onChange: () => void): () => void {
     const name = basename(file);
     let timer: ReturnType<typeof setTimeout> | null = null;
     let lastSeen: string | null = null;
-    // Seed asynchronously; a real change before the seed resolves still wins
-    // because the debounce re-reads fresh and compares against `lastSeen` (null
-    // → does not match → fires).
-    void readFile(file, "utf8")
-        .then((text) => {
-            if (lastSeen === null) lastSeen = text;
-        })
-        .catch(() => {});
     try {
-        const watcher = watch(dirname(file), (_event, filename) => {
+        lastSeen = readFileSync(file, "utf8");
+    } catch {
+        // A missing or temporarily unreadable baseline is retried after registration.
+    }
+    const reconcile = (): void => {
+        void watchReadFile(file)
+            .catch(() => null)
+            .then((text) => {
+                if (text === null || text === lastSeen) return;
+                lastSeen = text;
+                onChange();
+            });
+    };
+    try {
+        const watcher = watchDirectory(dirname(file), (_event, filename) => {
             const isOurs =
                 filename === name ||
                 (filename?.startsWith(`${name}.`) && filename.endsWith(".tmp"));
@@ -283,16 +311,13 @@ export function watchTuiPreferences(onChange: () => void): () => void {
             if (timer) clearTimeout(timer);
             timer = setTimeout(() => {
                 timer = null;
-                void readFile(file, "utf8")
-                    .catch(() => null)
-                    .then((text) => {
-                        if (text === null) return;
-                        if (text === lastSeen) return;
-                        lastSeen = text;
-                        onChange();
-                    });
+                reconcile();
             }, WATCH_DEBOUNCE_MS);
         });
+        // Reconcile after registration: a change between the baseline read and
+        // watcher installation is observed here, while later changes schedule
+        // the same reconciliation path through the watcher callback above.
+        reconcile();
         return () => {
             if (timer) clearTimeout(timer);
             watcher.close();