@cortexkit/opencode-magic-context 0.41.0 → 0.41.2

package/src/shared/logger.ts

@@ -9,6 +9,12 @@ let buffer: string[] = [];
 let flushTimer: ReturnType<typeof setTimeout> | null = null;
 const FLUSH_INTERVAL_MS = 500;
 const BUFFER_SIZE_LIMIT = 50;
+const MAX_LOG_FILE_BYTES = 32 * 1024 * 1024;
+const SIZE_CHECK_INTERVAL_FLUSHES = 64;
+
+let activeLogFile: string | null = null;
+let activeLogSize: number | null = null;
+let flushesSinceSizeCheck = 0;
 
 export interface LoggerDiagnostics {
     swallowedWriteCount: number;
@@ -36,19 +42,126 @@ function ensureDir(filePath: string): void {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
 }
 
+function isMissingFile(error: unknown): boolean {
+    return (
+        typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        (error as { code?: unknown }).code === "ENOENT"
+    );
+}
+
+function getCurrentLogSize(logFile: string): number {
+    if (
+        activeLogFile === logFile &&
+        activeLogSize !== null &&
+        flushesSinceSizeCheck < SIZE_CHECK_INTERVAL_FLUSHES
+    ) {
+        return activeLogSize;
+    }
+
+    try {
+        const stat = fs.statSync(logFile);
+        if (!stat.isFile()) {
+            throw new Error(`Magic Context log path is not a regular file: ${logFile}`);
+        }
+        // Logs can contain diagnostic context, so tighten files created by older
+        // versions before copying or appending any new content.
+        fs.chmodSync(logFile, 0o600);
+        activeLogFile = logFile;
+        activeLogSize = stat.size;
+        flushesSinceSizeCheck = 0;
+        return stat.size;
+    } catch (error) {
+        if (!isMissingFile(error)) throw error;
+        activeLogFile = logFile;
+        activeLogSize = 0;
+        flushesSinceSizeCheck = 0;
+        return 0;
+    }
+}
+
+function capLogData(data: string): string {
+    if (Buffer.byteLength(data) <= MAX_LOG_FILE_BYTES) return data;
+
+    // A single diagnostic payload must not defeat the on-disk bound. Cutting a
+    // Buffer can split UTF-8, so trim any replacement character expansion too.
+    let bounded = Buffer.from(data).subarray(0, MAX_LOG_FILE_BYTES).toString("utf8");
+    while (Buffer.byteLength(bounded) > MAX_LOG_FILE_BYTES) {
+        bounded = bounded.slice(0, -1);
+    }
+    return bounded;
+}
+
+function writeBoundedPredecessor(logFile: string, predecessorPath: string, size: number): void {
+    const predecessorFd = fs.openSync(predecessorPath, "w", 0o600);
+    try {
+        // `openSync(..., "w")` preserves an existing file's mode, so set it
+        // before any copied diagnostic text reaches the predecessor.
+        fs.fchmodSync(predecessorFd, 0o600);
+        const bytesToCopy = Math.min(size, MAX_LOG_FILE_BYTES);
+        const sourceFd = fs.openSync(logFile, "r");
+        try {
+            const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, bytesToCopy));
+            let remaining = bytesToCopy;
+            let position = Math.max(0, size - bytesToCopy);
+            while (remaining > 0) {
+                const bytesRead = fs.readSync(
+                    sourceFd,
+                    chunk,
+                    0,
+                    Math.min(chunk.length, remaining),
+                    position,
+                );
+                if (bytesRead === 0) break;
+                fs.writeSync(predecessorFd, chunk, 0, bytesRead);
+                remaining -= bytesRead;
+                position += bytesRead;
+            }
+        } finally {
+            fs.closeSync(sourceFd);
+        }
+    } finally {
+        fs.closeSync(predecessorFd);
+    }
+}
+
+function rotateLogFile(logFile: string, size: number): void {
+    const predecessorPath = `${logFile}.1`;
+    writeBoundedPredecessor(logFile, predecessorPath, size);
+    // Keep the current inode in place so diagnostic readers can observe a
+    // shorter log during rotation instead of seeing the path disappear.
+    fs.truncateSync(logFile, 0);
+    activeLogSize = 0;
+    flushesSinceSizeCheck = 0;
+}
+
 function flush(): void {
     if (flushTimer) {
         clearTimeout(flushTimer);
         flushTimer = null;
     }
     if (buffer.length === 0) return;
-    const data = buffer.join("");
+    const bufferedData = buffer.join("");
     buffer = [];
     try {
+        const data = capLogData(bufferedData);
         const logFile = getMagicContextLogPath();
         ensureDir(logFile);
-        fs.appendFileSync(logFile, data);
+        let currentSize = getCurrentLogSize(logFile);
+        const dataSize = Buffer.byteLength(data);
+        if (currentSize > 0 && currentSize + dataSize > MAX_LOG_FILE_BYTES) {
+            rotateLogFile(logFile, currentSize);
+            currentSize = 0;
+        }
+        fs.appendFileSync(logFile, data, { encoding: "utf8", mode: 0o600 });
+        activeLogFile = logFile;
+        activeLogSize = currentSize + dataSize;
+        flushesSinceSizeCheck++;
     } catch (error) {
+        activeLogFile = null;
+        activeLogSize = null;
+        flushesSinceSizeCheck = 0;
         recordSwallowedWrite(error);
     }
 }

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

@@ -9,23 +9,26 @@ import {
 } from "./model-resolution";
 
 describe("model-resolution", () => {
-    test("pins the historian calibration defaults while preserving explicit overrides", () => {
-        expect(resolveHistorianAgentOverrides(undefined)).toEqual({
-            temperature: 0.1,
-            maxTokens: 32_000,
-        });
-        expect(
-            resolveHistorianAgentOverrides({
-                temperature: 0.2,
+    test("keeps historian temperature opt-in while preserving explicit overrides", () => {
+        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", () => {
@@ -56,7 +59,7 @@ describe("model-resolution", () => {
         ]);
     });
 
-    test("applies the flash-calibrated historian generation triple while preserving overrides", () => {
+    test("keeps the flash calibration available only as an explicit override", () => {
         expect(
             resolveHistorianAgentOverrides({
                 opencode: { model: { model: "google/flash", variant: "fast" } },
@@ -64,15 +67,14 @@ describe("model-resolution", () => {
                 two_pass: true,
             }),
         ).toEqual({
-            temperature: 0.1,
             maxTokens: 32_000,
             two_pass: true,
             model: "google/flash",
             variant: "fast",
         });
         expect(
-            resolveHistorianAgentOverrides({ temperature: 0.2, maxTokens: 12_000 }),
-        ).toMatchObject({ temperature: 0.2, maxTokens: 12_000 });
+            resolveHistorianAgentOverrides({ temperature: 0.1, maxTokens: 12_000 }),
+        ).toMatchObject({ temperature: 0.1, maxTokens: 12_000 });
     });
 
     test("does not inherit a block qualifier into unqualified fallbacks", () => {

package/src/shared/model-resolution.ts

@@ -228,7 +228,6 @@ export function resolveOpenCodeAgentOverrides(agent: unknown): Record<string, un
 
 export function resolveHistorianAgentOverrides(agent: unknown): Record<string, unknown> {
     return {
-        temperature: 0.1,
         maxTokens: 32_000,
         ...resolveOpenCodeAgentOverrides(agent),
     };

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",
+                ],
+            },
+        ]);
     });
 });