@cortexkit/opencode-magic-context 0.41.1 → 0.41.3

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/index.ts

@@ -4,3 +4,4 @@ export * from "./normalize-sdk-response";
 export * from "./prompt-surface";
 export * from "./prompt-surface-runtime";
 export * from "./resolve-fallbacks";
+export * from "./summarize-child-stderr";

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

@@ -10,21 +10,25 @@ import {
 
 describe("model-resolution", () => {
     test("keeps historian temperature opt-in while preserving explicit overrides", () => {
-        expect(resolveHistorianAgentOverrides(undefined)).toEqual({
-            maxTokens: 32_000,
-        });
-        expect(
-            resolveHistorianAgentOverrides({
-                temperature: 0.2,
+        const fixtures = [
+            { temperature: undefined, expected: undefined },
+            { temperature: 0.1, expected: 0.1 },
+            { temperature: 0, expected: 0 },
+        ] as const;
+        for (const fixture of fixtures) {
+            const resolved = resolveHistorianAgentOverrides({
+                ...(fixture.temperature !== undefined ? { temperature: fixture.temperature } : {}),
                 maxTokens: 16_000,
                 opencode: { model: "google/flash", variant: "low" },
-            }),
-        ).toEqual({
-            temperature: 0.2,
-            maxTokens: 16_000,
-            model: "google/flash",
-            variant: "low",
-        });
+                pi: { model: "pi/must-not-leak", thinking_level: "high" },
+            });
+            expect(resolved).toEqual({
+                maxTokens: 16_000,
+                ...(fixture.expected !== undefined ? { temperature: fixture.expected } : {}),
+                model: "google/flash",
+                variant: "low",
+            });
+        }
     });
 
     test("normalizes string and object entries to the same model identity", () => {
@@ -126,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: {

package/src/shared/model-resolution.ts

@@ -1,4 +1,4 @@
-export type ModelHarness = "opencode" | "pi";
+export type ModelHarness = "opencode" | "pi" | "omp";
 
 export interface ResolvedModelEntry {
     /** Canonical provider/model reference used for identity and model selection. */
@@ -27,6 +27,14 @@ function hasOwn(record: ConfigRecord, key: string): boolean {
     return Object.hasOwn(record, key);
 }
 
+function resolveHarnessBlock(
+    container: ConfigRecord | undefined,
+    harness: ModelHarness,
+): ConfigRecord | undefined {
+    const selected = harness === "omp" ? (container?.omp ?? container?.pi) : container?.[harness];
+    return asRecord(selected);
+}
+
 /**
  * Collapses the string and object spellings of a harness model entry into the
  * same model identity. Qualifiers stay separate because they alter an attempt,
@@ -98,15 +106,15 @@ export interface ResolvedHistorianModel {
 }
 
 /**
- * Resolve historian model attempts from exactly one harness block. Flat keys
- * and the other harness are deliberately never consulted after cutover.
+ * Resolve historian model attempts from the selected harness block. OMP uses
+ * its own block when present and falls back to Pi when it is absent.
  */
 export function resolveHistorianModel(
     config: unknown,
     harness: ModelHarness,
 ): ResolvedHistorianModel {
     const historian = asRecord(asRecord(config)?.historian);
-    const block = asRecord(historian?.[harness]);
+    const block = resolveHarnessBlock(historian, harness);
     if (!block) return { fallbacks: [] };
 
     return {
@@ -139,7 +147,7 @@ export function resolveDreamerTaskModel(args: {
     muralModel?: unknown;
 }): ResolvedDreamerTaskModel {
     const dreamer = asRecord(asRecord(args.config)?.dreamer);
-    const harnessBlock = asRecord(dreamer?.[args.harness]);
+    const harnessBlock = resolveHarnessBlock(dreamer, args.harness);
     const taskBlock = asRecord(asRecord(harnessBlock?.tasks)?.[args.task]);
     const schedulingTask = asRecord(asRecord(dreamer?.tasks)?.[args.task]);
     if (!harnessBlock) {
@@ -211,6 +219,7 @@ export function resolveOpenCodeAgentOverrides(agent: unknown): Record<string, un
         thinking_level: _thinking,
         opencode,
         pi,
+        omp,
         tasks,
         ...rest
     } = source;

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

@@ -2,7 +2,6 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
 
 import {
-    type ConfigHarness,
     cortexKitUserConfigBasePath,
     resolveLegacyConfigSourcesForHarness,
 } from "../config/migrate-config-location";
@@ -13,6 +12,7 @@ import {
     CTX_REDUCE_LIGHT_DESCRIPTION,
     CTX_SEARCH_LIGHT_DESCRIPTION,
 } from "../tools/light-descriptions";
+import type { HarnessId } from "./harness";
 import { piModelRefToCanonical } from "./harness-provider-map";
 import { detectConfigFile } from "./jsonc-parser";
 import {
@@ -88,7 +88,7 @@ export interface PromptSurfaceRuntime {
 }
 
 export interface CreatePromptSurfaceRuntimeOptions {
-    harness?: ConfigHarness;
+    harness?: HarnessId;
     directory?: string;
     /** Explicit test/integration seam; production derives the USER config directory. */
     userConfigDirectory?: string;
@@ -105,7 +105,7 @@ function resolveUserConfigDirectory(options: CreatePromptSurfaceRuntimeOptions):
     if (options.harness) {
         const legacy = resolveLegacyConfigSourcesForHarness(
             options.directory ?? process.cwd(),
-            options.harness,
+            options.harness === "omp" ? "pi" : options.harness,
         ).user.find((source) => existsSync(source.path));
         if (legacy) return dirname(legacy.path);
     }

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

@@ -53,6 +53,45 @@ function tasklistOutput(entries: Array<[number, string]>): string {
     ].join("\r\n");
 }
 
+const WINDOWS_LAUNCHER_PID = 42424;
+const WINDOWS_FOREIGN_PID = 41001;
+const PLUGIN_BUILD_MS = 1_700_000_000_000;
+const OLDER_THAN_PLUGIN_MS = PLUGIN_BUILD_MS - 60_000;
+const OMP_PI_ARC_COMMAND =
+    "C:\\Users\\qiiks\\.bun\\bin\\omp.exe C:\\Users\\qiiks\\AppData\\Roaming\\npm\\node_modules\\@oh-my-pi\\pi-coding-agent\\dist\\cli.js";
+const BUN_PI_CHILD_COMMAND =
+    "C:\\Users\\qiiks\\.bun\\bin\\bun.exe C:\\Users\\qiiks\\AppData\\Roaming\\npm\\node_modules\\@oh-my-pi\\pi-coding-agent\\dist\\cli.js";
+const BARE_OMP_COMMAND = "C:\\Users\\qiiks\\.bun\\bin\\omp.exe";
+
+function padWmi(value: number, width = 2): string {
+    return String(value).padStart(width, "0");
+}
+
+/** Format an epoch millisecond timestamp as a WMI CreationDate string. */
+function wmiCreationDate(ms: number, offsetMinutes = 0): string {
+    const shifted = new Date(ms + offsetMinutes * 60_000);
+    const sign = offsetMinutes >= 0 ? "+" : "-";
+    return `${shifted.getUTCFullYear()}${padWmi(shifted.getUTCMonth() + 1)}${padWmi(shifted.getUTCDate())}${padWmi(shifted.getUTCHours())}${padWmi(shifted.getUTCMinutes())}${padWmi(shifted.getUTCSeconds())}.000000${sign}${padWmi(Math.abs(offsetMinutes), 3)}`;
+}
+
+function cimOutput(
+    rows: Array<{
+        ProcessId: number;
+        ParentProcessId: number;
+        CommandLine: string | null;
+        CreationDate: string;
+    }>,
+): string {
+    return JSON.stringify(rows.length === 1 ? rows[0] : rows);
+}
+
+function windowsProcessListExec(
+    handler: (file: string, args: readonly string[]) => string,
+): typeof execFileSync {
+    return ((file: string | URL, args: readonly string[] = []) =>
+        handler(String(file), args)) as typeof execFileSync;
+}
+
 afterEach(() => {
     __resetRpcIdentityTestHooks();
 });
@@ -97,7 +136,12 @@ describe("discoverLivePiProcessIds", () => {
                 ].join("\n")) as typeof execFileSync,
         });
 
-        expect(discoverLivePiProcessIds()).toEqual([41001, 41002, 41003, 41007]);
+        expect(inspectLivePiProcesses()).toEqual({
+            state: "known",
+            processIds: [41002, 41003],
+            inconclusivePids: [41001, 41007],
+        });
+        expect(discoverLivePiProcessIds()).toEqual([41002, 41003]);
     });
 
     test("reports uncertainty instead of treating an unavailable process list as empty", () => {
@@ -114,12 +158,13 @@ describe("discoverLivePiProcessIds", () => {
         });
     });
 
-    test("uses tasklist instead of ps on Windows", () => {
+    test("tries PowerShell CIM before tasklist on Windows", () => {
         const calls: string[] = [];
         __setRpcIdentityTestHooks({
             platform: "win32",
             processListExecFileSync: ((file: string | URL) => {
                 calls.push(String(file));
+                if (String(file) === "powershell") throw new Error("powershell unavailable");
                 return tasklistOutput([
                     [process.pid, "pi.exe"],
                     [41001, "pi.exe"],
@@ -129,10 +174,197 @@ describe("discoverLivePiProcessIds", () => {
         });
 
         expect(inspectLivePiProcesses()).toEqual({
+            state: "inconclusive",
+            processIds: [],
+            inconclusivePids: [41001],
+        });
+        expect(calls).toEqual(["powershell", "tasklist"]);
+    });
+});
+
+describe("#411 Windows OMP/Pi live-process scan", () => {
+    test("(a) tasklist-only fallback skips a parent omp.exe as an ancestor", () => {
+        const calls: string[] = [];
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            processListExecFileSync: windowsProcessListExec((file) => {
+                calls.push(file);
+                if (file === "powershell") {
+                    throw new Error("powershell unavailable");
+                }
+                return tasklistOutput([
+                    [process.ppid, "omp.exe"],
+                    [WINDOWS_FOREIGN_PID, "notepad.exe"],
+                ]);
+            }),
+        });
+
+        const discovery = inspectLivePiProcesses();
+        expect(discovery.processIds).not.toContain(process.ppid);
+        expect(discovery.skippedAncestorPids).toContain(process.ppid);
+        expect(calls[0]).toBe("powershell");
+        expect(calls).toContain("tasklist");
+    });
+
+    test("(a) CIM parent omp.exe with a Pi arc is skipped as an ancestor", () => {
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            nowMs: () => PLUGIN_BUILD_MS,
+            processListExecFileSync: windowsProcessListExec((file) => {
+                if (file !== "powershell") {
+                    throw new Error(`${file} must not run when CIM succeeds`);
+                }
+                return cimOutput([
+                    {
+                        ProcessId: process.pid,
+                        ParentProcessId: WINDOWS_LAUNCHER_PID,
+                        CommandLine: BUN_PI_CHILD_COMMAND,
+                        CreationDate: wmiCreationDate(PLUGIN_BUILD_MS),
+                    },
+                    {
+                        ProcessId: WINDOWS_LAUNCHER_PID,
+                        ParentProcessId: 4,
+                        CommandLine: OMP_PI_ARC_COMMAND,
+                        CreationDate: wmiCreationDate(OLDER_THAN_PLUGIN_MS),
+                    },
+                ]);
+            }),
+        });
+
+        const discovery = inspectLivePiProcesses();
+        expect(discovery.processIds).not.toContain(WINDOWS_LAUNCHER_PID);
+        expect(discovery.processIds).not.toContain(process.pid);
+        expect(discovery.skippedAncestorPids).toContain(WINDOWS_LAUNCHER_PID);
+        expect(discovery.state).toBe("known");
+    });
+
+    test("(b) CIM unrelated omp.exe with a Pi arc and older CreationDate is a verified blocker", () => {
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            nowMs: () => PLUGIN_BUILD_MS,
+            processListExecFileSync: windowsProcessListExec((file) => {
+                if (file !== "powershell") {
+                    throw new Error(`${file} must not run when CIM succeeds`);
+                }
+                return cimOutput([
+                    {
+                        ProcessId: process.pid,
+                        ParentProcessId: process.ppid,
+                        CommandLine: BUN_PI_CHILD_COMMAND,
+                        CreationDate: wmiCreationDate(PLUGIN_BUILD_MS),
+                    },
+                    {
+                        ProcessId: WINDOWS_FOREIGN_PID,
+                        ParentProcessId: 8,
+                        CommandLine: OMP_PI_ARC_COMMAND,
+                        CreationDate: wmiCreationDate(OLDER_THAN_PLUGIN_MS, 60),
+                    },
+                ]);
+            }),
+        });
+
+        const discovery = inspectLivePiProcesses();
+        expect(discovery.state).toBe("known");
+        expect(discovery.processIds).toEqual([WINDOWS_FOREIGN_PID]);
+        expect(readProcessProbeEvidence(WINDOWS_FOREIGN_PID)).toEqual({
+            startTime: OLDER_THAN_PLUGIN_MS,
+            commandLine: OMP_PI_ARC_COMMAND,
+        });
+    });
+
+    test("(c) CIM omp.exe with no Pi arc is inconclusive", () => {
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            processListExecFileSync: windowsProcessListExec((file) => {
+                if (file !== "powershell") {
+                    throw new Error(`${file} must not run when CIM succeeds`);
+                }
+                return cimOutput([
+                    {
+                        ProcessId: WINDOWS_FOREIGN_PID,
+                        ParentProcessId: 8,
+                        CommandLine: BARE_OMP_COMMAND,
+                        CreationDate: wmiCreationDate(OLDER_THAN_PLUGIN_MS),
+                    },
+                ]);
+            }),
+        });
+
+        const discovery = inspectLivePiProcesses();
+        expect(discovery.state).toBe("inconclusive");
+        expect(discovery.processIds).toEqual([]);
+        expect(discovery.inconclusivePids).toEqual([WINDOWS_FOREIGN_PID]);
+    });
+
+    test("(d) PowerShell unavailable falls back to tasklist as inconclusive", () => {
+        const calls: string[] = [];
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            processListExecFileSync: windowsProcessListExec((file) => {
+                calls.push(file);
+                if (file === "powershell") {
+                    throw new Error("powershell unavailable");
+                }
+                return tasklistOutput([
+                    [WINDOWS_FOREIGN_PID, "omp.exe"],
+                    [41002, "opencode.exe"],
+                ]);
+            }),
+        });
+
+        const discovery = inspectLivePiProcesses();
+        expect(discovery.state).toBe("inconclusive");
+        expect(discovery.processIds).toEqual([]);
+        expect(discovery.inconclusivePids).toEqual([WINDOWS_FOREIGN_PID]);
+        expect(calls).toEqual(["powershell", "tasklist"]);
+    });
+
+    test("(e) POSIX ancestor exclusion skips the parent Pi harness", () => {
+        __setRpcIdentityTestHooks({
+            platform: "darwin",
+            processListExecFileSync: windowsProcessListExec((file, args) => {
+                if (file === "ps" && args.includes("ppid=")) {
+                    const pidIndex = args.indexOf("-p");
+                    const pid = Number(args[pidIndex + 1]);
+                    if (pid === process.pid) return ` ${process.ppid}\n`;
+                    if (pid === process.ppid) return " 1\n";
+                    return " 1\n";
+                }
+                return [
+                    ` ${process.pid} bun /opt/node_modules/@oh-my-pi/pi-coding-agent/dist/cli.js`,
+                    ` ${process.ppid} bun /opt/node_modules/@oh-my-pi/pi-coding-agent/dist/cli.js`,
+                    " 41001 bun /opt/node_modules/@oh-my-pi/pi-coding-agent/dist/cli.js",
+                ].join("\n");
+            }),
+        });
+
+        const discovery = inspectLivePiProcesses();
+        expect(discovery.processIds).toEqual([41001]);
+        expect(discovery.skippedAncestorPids).toContain(process.ppid);
+    });
+
+    test("(f) CIM single-object JSON shape parses", () => {
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            processListExecFileSync: windowsProcessListExec((file) => {
+                if (file !== "powershell") {
+                    throw new Error(`${file} must not run when CIM succeeds`);
+                }
+                return cimOutput([
+                    {
+                        ProcessId: WINDOWS_FOREIGN_PID,
+                        ParentProcessId: 8,
+                        CommandLine: OMP_PI_ARC_COMMAND,
+                        CreationDate: wmiCreationDate(OLDER_THAN_PLUGIN_MS),
+                    },
+                ]);
+            }),
+        });
+
+        expect(inspectLivePiProcesses()).toMatchObject({
             state: "known",
-            processIds: [41001],
+            processIds: [WINDOWS_FOREIGN_PID],
         });
-        expect(calls).toEqual(["tasklist"]);
     });
 });
 
@@ -369,6 +601,15 @@ describe("isPidIdentityPlausible", () => {
 
         calls.length = 0;
         expect(isPidIdentityPlausible(record(NOW_MS))).toBe("inconclusive");
-        expect(calls).toEqual([]);
+        expect(calls).toEqual([
+            {
+                file: "powershell",
+                args: [
+                    "-NoProfile",
+                    "-Command",
+                    "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine,CreationDate | ConvertTo-Json -Compress",
+                ],
+            },
+        ]);
     });
 });