@cortexkit/opencode-magic-context 0.36.1 → 0.38.0

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

@@ -47,6 +47,44 @@ describe("prompt-surface resolution", () => {
         }
     });
 
+    it("resolves Pi-native and canonical model keys with canonical precedence", () => {
+        const nativeKey = "openai-codex/gpt-5.6-sol";
+        const canonicalKey = "openai/gpt-5.6-sol";
+
+        expect(resolveCacheTtl({ default: "5m", [nativeKey]: "60m" }, canonicalKey)).toBe("60m");
+        expect(
+            resolvePromptSurface(
+                { default: "full", models: { [nativeKey]: "light" } },
+                canonicalKey,
+            ),
+        ).toEqual({ preset: "light", source: "exact" });
+        expect(
+            resolveCacheTtl(
+                { default: "5m", [nativeKey]: "60m", [canonicalKey]: "30m" },
+                nativeKey,
+            ),
+        ).toBe("30m");
+        expect(
+            resolvePromptSurface(
+                { default: "full", models: { [nativeKey]: "light", [canonicalKey]: "full" } },
+                nativeKey,
+            ),
+        ).toEqual({ preset: "full", source: "exact" });
+    });
+
+    it("leaves unknown provider keys unchanged", () => {
+        expect(
+            resolveCacheTtl(
+                { default: "5m", "custom-provider/model": "1m" },
+                "custom-provider/model",
+            ),
+        ).toBe("1m");
+        expect(modelKeyLookupOrder("custom-provider/model")[0]).toEqual({
+            key: "custom-provider/model",
+            source: "exact",
+        });
+    });
+
     it("derives a stable config identity independent of object key order", () => {
         const left = promptSurfaceConfigIdentity({
             default: "full",

package/src/shared/prompt-surface.ts

@@ -1,3 +1,5 @@
+import { modelRefLookupOrder } from "./harness-provider-map";
+
 /** The built-in prompt-surface variants. */
 export type PromptSurfacePreset = "full" | "light";
 
@@ -69,6 +71,8 @@ export interface ModelKeyCandidate {
  * provider/model boundary is the first slash; the rest of the string remains
  * the model ID, including additional slashes. Candidates are case-sensitive.
  *
+ * Known harness provider aliases are checked canonical-first at each specificity,
+ * so one shared config works on every harness and canonical wins on collisions.
  * Provider wildcards are checked after progressively less-specific model keys,
  * but before the caller's default. That keeps an exact or base-model override
  * authoritative while still allowing `provider/*` to cover otherwise-unlisted
@@ -82,10 +86,15 @@ export function modelKeyLookupOrder(modelKey: string | undefined): ModelKeyCandi
 
     const provider = modelKey.slice(0, slash);
     let modelID = modelKey.slice(slash + 1);
+    const providerRefs = modelRefLookupOrder(`${provider}/${modelID}`);
     const candidates: ModelKeyCandidate[] = [];
 
     while (modelID.length > 0) {
-        candidates.push({ key: `${provider}/${modelID}`, source: "exact" });
+        for (const providerRef of providerRefs) {
+            const providerSlash = providerRef.indexOf("/");
+            const providerPrefix = providerRef.slice(0, providerSlash);
+            candidates.push({ key: `${providerPrefix}/${modelID}`, source: "exact" });
+        }
         candidates.push({ key: modelID, source: "bare" });
 
         const lastDash = modelID.lastIndexOf("-");
@@ -93,7 +102,11 @@ export function modelKeyLookupOrder(modelKey: string | undefined): ModelKeyCandi
         modelID = modelID.slice(0, lastDash);
     }
 
-    candidates.push({ key: `${provider}/*`, source: "wildcard" });
+    for (const providerRef of providerRefs) {
+        const providerSlash = providerRef.indexOf("/");
+        const providerPrefix = providerRef.slice(0, providerSlash);
+        candidates.push({ key: `${providerPrefix}/*`, source: "wildcard" });
+    }
 
     const seen = new Set<string>();
     return candidates.filter((candidate) => {

package/src/shared/rpc-client.ts

@@ -149,7 +149,9 @@ export class MagicContextRpcClient {
             for (const entry of readdirSync(this.portDir)) {
                 if (!entry.startsWith("port-") || !entry.endsWith(".json")) continue;
                 const record = parseRpcPortFile(readFileSync(join(this.portDir, entry), "utf-8"));
-                if (!record || !isPidAlive(record.pid)) continue;
+                // A denied liveness probe still leaves this as a candidate; the
+                // mandatory health check below confirms whether its RPC server is reachable.
+                if (!record || isPidAlive(record.pid) === "dead") continue;
                 records.push(record);
             }
         } catch {
@@ -158,7 +160,7 @@ export class MagicContextRpcClient {
 
         try {
             const legacy = parseRpcPortFile(readFileSync(this.legacyPortFilePath, "utf-8"));
-            if (legacy && (!legacy.pid || isPidAlive(legacy.pid))) records.push(legacy);
+            if (legacy && (!legacy.pid || isPidAlive(legacy.pid) !== "dead")) records.push(legacy);
         } catch {
             // Legacy discovery is optional.
         }

package/src/shared/rpc-server.ts

@@ -185,6 +185,7 @@ export class MagicContextRpcServer {
                     port: this.port,
                     pid: process.pid,
                     started_at: this.startedAt,
+                    kind: "OpenCode server",
                     token: this.token,
                     instance_id: this.instanceId,
                 }),

package/src/shared/rpc-types.ts

@@ -7,6 +7,21 @@ import type {
     DreamTaskBacklogMap,
     DreamTaskProgress,
 } from "../features/magic-context/dreamer/task-registry";
+import type { LoggerDiagnostics } from "./logger";
+
+export interface TailHygieneStatus {
+    /** Tokens in active, non-protected tail content that the agent can reclaim. */
+    u: number;
+    /** Tokens in rendered-tail content eligible for hygiene accounting in the same scan. */
+    t: number;
+    /** Reclaimable-to-eligible token ratio, clamped to 0–1 and shared by both nudge mechanisms. */
+    severity: number;
+    /** False until a fresh scan runs after existing tail content changes, preventing stale measurements. */
+    evaluable: boolean;
+    generationInvalidated: boolean;
+    baselineGeneration: number;
+    computedAt: number;
+}
 
 export interface SidebarSnapshot {
     sessionId: string;
@@ -77,6 +92,8 @@ export interface SidebarSnapshot {
      * shows this as "Tool Definitions".
      */
     toolDefinitionTokens: number;
+    /** Persisted reclaimable (U) and eligible (T) token counts used by both nudge mechanisms. */
+    tailHygiene?: TailHygieneStatus;
     /**
      * Effective execute-threshold percentage for this session's active model,
      * after per-model resolution and the tokens→percentage conversion (when
@@ -135,6 +152,17 @@ export interface StatusDetail extends SidebarSnapshot {
     isSubagent: boolean;
     pendingOps: Array<{ tagId: number; operation: string }>;
     contextLimit: number;
+    windowGeometry?: {
+        usableSoft: number;
+        usableHard: number;
+        geometry: "shared_upfront" | "shared_truncating" | "separate";
+        derivation: {
+            window: number;
+            reserve: number;
+            reserveSource: "output_catalog" | "output_config" | "wall_margin" | "none";
+            geometry: "shared_upfront" | "shared_truncating" | "separate";
+        };
+    };
     /**
      * Parsed cache TTL in ms. -1 = never expires (cacheTtl "never"; Infinity
      * cannot ride JSON-RPC and 0 would be indistinguishable from unset). The
@@ -170,6 +198,8 @@ export interface StatusDetail extends SidebarSnapshot {
     toastDurationMs: number;
     /** One-line status data for the experimental memory mural. */
     mural?: { present: boolean; ageMs: number | null };
+    /** Runtime logger write failures observed by this plugin process. */
+    loggerDiagnostics: LoggerDiagnostics;
     /**
      * Stable storage-version probe: "which schema is the DB at, which fence does
      * this binary carry". Field names are deliberately snake_case, mirroring the

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

@@ -6,8 +6,10 @@ import type { readFileSync } from "node:fs";
 import {
     __resetRpcIdentityTestHooks,
     __setRpcIdentityTestHooks,
+    classifyProcessKind,
     discoverLivePiProcessIds,
     inspectLivePiProcesses,
+    isPidAlive,
     isPidIdentityPlausible,
     type RpcPortFileRecord,
 } from "./rpc-utils";
@@ -42,10 +44,41 @@ function psOutput(output: string | Error): typeof execFileSync {
     }) as typeof execFileSync;
 }
 
+function tasklistOutput(entries: Array<[number, string]>): string {
+    return [
+        '"Image Name","PID","Session Name","Session#","Mem Usage"',
+        ...entries.map(([pid, command]) => `"${command}","${pid}","Console","1","10,000 K"`),
+    ].join("\r\n");
+}
+
 afterEach(() => {
     __resetRpcIdentityTestHooks();
 });
 
+describe("classifyProcessKind", () => {
+    test("classifies OpenCode server, OpenCode instance, Pi, and unknown commands", () => {
+        expect(classifyProcessKind("/usr/local/bin/opencode serve --hostname 127.0.0.1")).toBe(
+            "OpenCode server",
+        );
+        expect(classifyProcessKind("node /opt/opencode/bin/opencode --continue")).toBe(
+            "OpenCode instance (TUI/CLI)",
+        );
+        expect(
+            classifyProcessKind(
+                "bun /workspace/node_modules/@mariozechner/pi-coding-agent/dist/cli.js",
+            ),
+        ).toBe("Pi");
+        expect(classifyProcessKind("/usr/bin/other --flag")).toBe("process");
+        expect(classifyProcessKind(null)).toBe("process");
+    });
+
+    test("recognizes serve flags and Windows-style executable paths", () => {
+        expect(classifyProcessKind("opencode --serve=true")).toBe("OpenCode server");
+        expect(classifyProcessKind("C:\\Tools\\opencode.exe")).toBe("OpenCode instance (TUI/CLI)");
+        expect(classifyProcessKind("pi.cmd --model test")).toBe("Pi");
+    });
+});
+
 describe("discoverLivePiProcessIds", () => {
     test("finds Pi-family harness commands while excluding the current process", () => {
         __setRpcIdentityTestHooks({
@@ -78,6 +111,103 @@ describe("discoverLivePiProcessIds", () => {
             error: "ps unavailable",
         });
     });
+
+    test("uses tasklist instead of ps on Windows", () => {
+        const calls: string[] = [];
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            processListExecFileSync: ((file: string | URL) => {
+                calls.push(String(file));
+                return tasklistOutput([
+                    [process.pid, "pi.exe"],
+                    [41001, "pi.exe"],
+                    [41002, "opencode.exe"],
+                ]);
+            }) as typeof execFileSync,
+        });
+
+        expect(inspectLivePiProcesses()).toEqual({
+            state: "known",
+            processIds: [41001],
+        });
+        expect(calls).toEqual(["tasklist"]);
+    });
+});
+
+describe("isPidAlive", () => {
+    test("distinguishes confirmed, dead, and inaccessible PID probes", () => {
+        const probeFailure = (code: string): NodeJS.ErrnoException => {
+            const error = new Error(`kill failed: ${code}`) as NodeJS.ErrnoException;
+            error.code = code;
+            return error;
+        };
+
+        __setRpcIdentityTestHooks({
+            processKill: (() => true) as typeof process.kill,
+        });
+        expect(isPidAlive(PID)).toBe("alive");
+
+        __setRpcIdentityTestHooks({
+            processKill: (() => {
+                throw probeFailure("ESRCH");
+            }) as typeof process.kill,
+        });
+        expect(isPidAlive(PID)).toBe("dead");
+
+        __setRpcIdentityTestHooks({
+            processKill: (() => {
+                throw probeFailure("EPERM");
+            }) as typeof process.kill,
+        });
+        expect(isPidAlive(PID)).toBe("inconclusive");
+    });
+
+    test("uses tasklist for Windows liveness and captures probe stderr", () => {
+        const calls: Array<{ file: string; args: readonly string[]; stdio: unknown }> = [];
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            execFileSync: ((
+                file: string | URL,
+                args: readonly string[] = [],
+                options: { stdio?: unknown } = {},
+            ) => {
+                calls.push({ file: String(file), args, stdio: options.stdio });
+                if (String(file) === "ps") throw new Error("ps must not run on Windows");
+                return tasklistOutput([[PID, "OpenCode.exe"]]);
+            }) as typeof execFileSync,
+        });
+
+        expect(isPidAlive(PID)).toBe("alive");
+        expect(calls).toEqual([
+            {
+                file: "tasklist",
+                args: ["/FO", "CSV", "/FI", `PID eq ${PID}`],
+                stdio: ["ignore", "pipe", "pipe"],
+            },
+        ]);
+    });
+
+    test("treats a successful tasklist no-match response as dead", () => {
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            execFileSync: (() =>
+                "INFO: No tasks are running which match the specified criteria.") as typeof execFileSync,
+        });
+
+        expect(isPidAlive(PID)).toBe("dead");
+    });
+
+    test("returns inconclusive when the Windows tasklist probe cannot spawn", () => {
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            execFileSync: (() => {
+                throw new Error("tasklist unavailable");
+            }) as typeof execFileSync,
+        });
+
+        expect(isPidAlive(PID)).toBe("inconclusive");
+        expect(isPidIdentityPlausible(record(0))).toBe("inconclusive");
+    });
 });
 
 describe("isPidIdentityPlausible", () => {
@@ -99,7 +229,7 @@ describe("isPidIdentityPlausible", () => {
             }) as typeof execFileSync,
         });
 
-        expect(isPidIdentityPlausible(record(500_000))).toBe(false);
+        expect(isPidIdentityPlausible(record(500_000))).toBe("implausible");
         expect(readPaths).toEqual([`/proc/${PID}/stat`, "/proc/uptime"]);
     });
 
@@ -115,10 +245,10 @@ describe("isPidIdentityPlausible", () => {
 
         // The mocked process start is 1,100,000ms. The 120s tolerance is part of
         // the contract because port-file creation follows process startup.
-        expect(isPidIdentityPlausible(record(1_000_000))).toBe(true);
+        expect(isPidIdentityPlausible(record(1_000_000))).toBe("plausible");
     });
 
-    test("treats an unreadable Linux start-time probe as live", () => {
+    test("reports an unreadable Linux start-time probe as inconclusive", () => {
         __setRpcIdentityTestHooks({
             platform: "linux",
             readFileSync: linuxFiles({
@@ -126,17 +256,17 @@ describe("isPidIdentityPlausible", () => {
             }),
         });
 
-        expect(isPidIdentityPlausible(record(500_000))).toBe(true);
+        expect(isPidIdentityPlausible(record(500_000))).toBe("inconclusive");
     });
 
-    test("uses the legacy Linux command fallback and fails closed on probe errors", () => {
+    test("uses the legacy Linux command fallback and distinguishes probe errors", () => {
         __setRpcIdentityTestHooks({
             platform: "linux",
             readFileSync: linuxFiles({
                 [`/proc/${PID}/cmdline`]: "/usr/sbin/opendkim --config /etc/opendkim.conf",
             }),
         });
-        expect(isPidIdentityPlausible(record(0))).toBe(false);
+        expect(isPidIdentityPlausible(record(0))).toBe("implausible");
 
         __setRpcIdentityTestHooks({
             platform: "linux",
@@ -144,7 +274,7 @@ describe("isPidIdentityPlausible", () => {
                 [`/proc/${PID}/cmdline`]: "/usr/local/bin/opencode serve",
             }),
         });
-        expect(isPidIdentityPlausible(record(0))).toBe(true);
+        expect(isPidIdentityPlausible(record(0))).toBe("plausible");
 
         __setRpcIdentityTestHooks({
             platform: "linux",
@@ -152,7 +282,7 @@ describe("isPidIdentityPlausible", () => {
                 [`/proc/${PID}/cmdline`]: new Error("procfs unavailable"),
             }),
         });
-        expect(isPidIdentityPlausible(record(0))).toBe(true);
+        expect(isPidIdentityPlausible(record(0))).toBe("inconclusive");
     });
 
     test("uses ps start time and command probes on non-Linux platforms", () => {
@@ -162,7 +292,7 @@ describe("isPidIdentityPlausible", () => {
         });
         expect(
             isPidIdentityPlausible(record(Date.parse("Mon Aug  7 00:00:00 1970") - 121_000)),
-        ).toBe(false);
+        ).toBe("implausible");
 
         __setRpcIdentityTestHooks({
             platform: "darwin",
@@ -170,24 +300,43 @@ describe("isPidIdentityPlausible", () => {
         });
         expect(
             isPidIdentityPlausible(record(Date.parse("Mon Aug  7 00:00:00 1970") - 120_000)),
-        ).toBe(true);
+        ).toBe("plausible");
 
         __setRpcIdentityTestHooks({
             platform: "darwin",
             execFileSync: psOutput("/usr/sbin/opendkim -f"),
         });
-        expect(isPidIdentityPlausible(record(0))).toBe(false);
+        expect(isPidIdentityPlausible(record(0))).toBe("implausible");
 
         __setRpcIdentityTestHooks({
             platform: "darwin",
             execFileSync: psOutput("/Applications/OpenCode.app/Contents/MacOS/opencode"),
         });
-        expect(isPidIdentityPlausible(record(0))).toBe(true);
+        expect(isPidIdentityPlausible(record(0))).toBe("plausible");
 
         __setRpcIdentityTestHooks({
             platform: "darwin",
             execFileSync: psOutput(new Error("ps unavailable")),
         });
-        expect(isPidIdentityPlausible(record(0))).toBe(true);
+        expect(isPidIdentityPlausible(record(0))).toBe("inconclusive");
+    });
+
+    test("uses tasklist for the Windows command fallback and skips unavailable start time", () => {
+        const calls: Array<{ file: string; args: readonly string[] }> = [];
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            execFileSync: ((file: string | URL, args: readonly string[] = []) => {
+                calls.push({ file: String(file), args });
+                if (String(file) === "ps") throw new Error("ps must not run on Windows");
+                return tasklistOutput([[PID, "OpenCode.exe"]]);
+            }) as typeof execFileSync,
+        });
+
+        expect(isPidIdentityPlausible(record(0))).toBe("plausible");
+        expect(calls).toEqual([{ file: "tasklist", args: ["/FO", "CSV", "/FI", `PID eq ${PID}`] }]);
+
+        calls.length = 0;
+        expect(isPidIdentityPlausible(record(NOW_MS))).toBe("inconclusive");
+        expect(calls).toEqual([]);
     });
 });