@cortexkit/opencode-magic-context 0.36.1 → 0.38.0

package/src/shared/rpc-utils.ts

@@ -3,10 +3,16 @@ import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
+export type ProcessKind = "OpenCode server" | "OpenCode instance (TUI/CLI)" | "Pi" | "process";
+
 export interface RpcPortFileRecord {
     port: number;
     pid: number;
     started_at: number;
+    /** Optional producer-provided kind; older records omit it. */
+    kind?: string;
+    /** Compatibility with discovery records that used the harness name. */
+    harness?: string;
     /**
      * Per-process bearer token. The server requires it on all non-health RPC
      * calls so a random local process or browser-origin script that merely
@@ -50,13 +56,22 @@ export function legacyRpcPortFilePath(storageDir: string, directory: string): st
     return join(rpcPortDir(storageDir, directory), "port");
 }
 
-export function isPidAlive(pid: number): boolean {
-    if (!Number.isInteger(pid) || pid <= 0) return false;
+export type PidLiveness = "alive" | "dead" | "inconclusive";
+
+/**
+ * Check whether the platform confirms a PID is live without treating a denied
+ * probe as confirmation. Windows uses tasklist because MSYS2/Cygwin ps does not
+ * support the options used by the Unix probe. Sandboxes commonly reject
+ * `kill(pid, 0)` with EPERM even when the PID does not exist outside their view.
+ */
+export function isPidAlive(pid: number): PidLiveness {
+    if (!Number.isInteger(pid) || pid <= 0) return "dead";
+    if (rpcIdentityPlatform === "win32") return readWindowsProcess(pid).state;
     try {
-        process.kill(pid, 0);
-        return true;
-    } catch (err) {
-        return (err as NodeJS.ErrnoException).code === "EPERM";
+        rpcIdentityProcessKill(pid, 0);
+        return "alive";
+    } catch (error) {
+        return (error as NodeJS.ErrnoException).code === "ESRCH" ? "dead" : "inconclusive";
     }
 }
 
@@ -64,9 +79,12 @@ const RPC_IDENTITY_SKEW_TOLERANCE_MS = 120_000;
 const LINUX_CLOCK_TICKS_PER_SECOND = 100;
 const PS_PROBE_TIMEOUT_MS = 1_000;
 const OPEN_CODE_COMMAND_MARKERS = ["opencode", "node", "bun", "electron"];
+const TASKLIST_NO_TASKS_PATTERN =
+    /^INFO:\s+No tasks are running which match the specified criteria\.?$/im;
 
 let rpcIdentityReadFileSync: typeof readFileSync = readFileSync;
 let rpcIdentityExecFileSync: typeof execFileSync = execFileSync;
+let rpcIdentityProcessKill: typeof process.kill = process.kill;
 let rpcProcessListExecFileSync: typeof execFileSync = execFileSync;
 let rpcProcessListTestOverride = false;
 let rpcIdentityPlatform: NodeJS.Platform = process.platform;
@@ -116,6 +134,7 @@ function readPsProcessStartTime(pid: number): number | null {
         const output = rpcIdentityExecFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
             encoding: "utf8",
             timeout: PS_PROBE_TIMEOUT_MS,
+            stdio: ["ignore", "pipe", "pipe"],
         });
         const processStartTime = Date.parse(String(output).trim());
         return Number.isFinite(processStartTime) ? processStartTime : null;
@@ -124,6 +143,72 @@ function readPsProcessStartTime(pid: number): number | null {
     }
 }
 
+interface ProcessListEntry {
+    pid: number;
+    command: string;
+}
+
+function parseCsvLine(line: string): string[] | null {
+    const fields: string[] = [];
+    let field = "";
+    let quoted = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const character = line[index];
+        if (character === '"') {
+            if (quoted && line[index + 1] === '"') {
+                field += '"';
+                index += 1;
+            } else {
+                quoted = !quoted;
+            }
+        } else if (character === "," && !quoted) {
+            fields.push(field);
+            field = "";
+        } else {
+            field += character;
+        }
+    }
+    if (quoted) return null;
+    fields.push(field);
+    return fields;
+}
+
+function parseTasklistOutput(output: string): ProcessListEntry[] | null {
+    const entries: ProcessListEntry[] = [];
+    let sawHeader = false;
+    for (const rawLine of output.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line) continue;
+        if (TASKLIST_NO_TASKS_PATTERN.test(line)) return [];
+        const fields = parseCsvLine(line);
+        if (!fields) continue;
+        if (fields[1]?.trim().toLowerCase() === "pid") {
+            sawHeader = true;
+            continue;
+        }
+        const pid = Number(fields[1]);
+        if (!Number.isInteger(pid) || pid <= 0 || !fields[0]) continue;
+        entries.push({ pid, command: fields[0] });
+    }
+    return entries.length > 0 || sawHeader ? entries : null;
+}
+
+function readWindowsProcess(pid: number): { state: PidLiveness; command?: string } {
+    try {
+        const output = rpcIdentityExecFileSync("tasklist", ["/FO", "CSV", "/FI", `PID eq ${pid}`], {
+            encoding: "utf8",
+            timeout: PS_PROBE_TIMEOUT_MS,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const entries = parseTasklistOutput(String(output));
+        if (entries === null) return { state: "inconclusive" };
+        const process = entries.find((entry) => entry.pid === pid);
+        return process ? { state: "alive", command: process.command } : { state: "dead" };
+    } catch {
+        return { state: "inconclusive" };
+    }
+}
+
 function readLinuxProcessCommand(pid: number): string | null {
     try {
         return String(rpcIdentityReadFileSync(`/proc/${pid}/cmdline`, "utf8"));
@@ -137,6 +222,7 @@ function readPsProcessCommand(pid: number): string | null {
         const output = rpcIdentityExecFileSync("ps", ["-p", String(pid), "-o", "command="], {
             encoding: "utf8",
             timeout: PS_PROBE_TIMEOUT_MS,
+            stdio: ["ignore", "pipe", "pipe"],
         });
         return String(output);
     } catch {
@@ -144,6 +230,78 @@ function readPsProcessCommand(pid: number): string | null {
     }
 }
 
+/** Reuse the platform-gated command probes used by PID identity checks. */
+export function readProcessCommand(pid: number): string | null {
+    if (!Number.isInteger(pid) || pid <= 0) return null;
+    return rpcIdentityPlatform === "linux"
+        ? readLinuxProcessCommand(pid)
+        : rpcIdentityPlatform === "win32"
+          ? (readWindowsProcess(pid).command ?? null)
+          : readPsProcessCommand(pid);
+}
+
+function executableName(token: string | undefined): string {
+    return (
+        (token ?? "")
+            .replace(/^['"]|['"]$/g, "")
+            .split("/")
+            .at(-1) ?? ""
+    );
+}
+
+function commandTokens(command: string): string[] {
+    return command
+        .toLowerCase()
+        .replaceAll("\\", "/")
+        .replaceAll("\u0000", " ")
+        .split(/\s+/)
+        .map((token) => token.replace(/^['"]|['"]$/g, ""))
+        .filter(Boolean);
+}
+
+function commandHasOpenCodeExecutable(tokens: readonly string[]): number {
+    return tokens.findIndex((token) => {
+        const executable = executableName(token).replace(/\.(?:exe|cmd)$/, "");
+        return executable === "opencode" || executable.endsWith("/opencode");
+    });
+}
+
+function commandHasPiExecutable(tokens: readonly string[]): boolean {
+    for (let index = 0; index < tokens.length; index += 1) {
+        const executable = executableName(tokens[index]).replace(/\.(?:exe|cmd)$/, "");
+        if (["pi", "omp", "oh-my-pi"].includes(executable)) return true;
+        if (["node", "bun", "deno"].includes(executable)) {
+            const script = executableName(tokens[index + 1]).replace(/\.(?:exe|cmd)$/, "");
+            if (
+                ["pi", "pi.js", "pi.mjs", "pi.cjs"].includes(script) ||
+                tokens[index + 1]?.includes("pi-coding-agent")
+            ) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+/** Classify a process command without changing the liveness decision. */
+export function classifyProcessKind(command: string | null | undefined): ProcessKind {
+    if (!command) return "process";
+    const tokens = commandTokens(command);
+    const openCodeIndex = commandHasOpenCodeExecutable(tokens);
+    if (openCodeIndex >= 0) {
+        const args = tokens.slice(openCodeIndex + 1);
+        if (
+            args.some(
+                (token) => token === "serve" || token === "--serve" || token.startsWith("--serve="),
+            )
+        ) {
+            return "OpenCode server";
+        }
+        return "OpenCode instance (TUI/CLI)";
+    }
+    return commandHasPiExecutable(tokens) ? "Pi" : "process";
+}
+
 function commandLooksLikeOpenCode(command: string): boolean {
     const normalized = command.toLowerCase();
     return OPEN_CODE_COMMAND_MARKERS.some((marker) => normalized.includes(marker));
@@ -153,40 +311,51 @@ function commandLooksLikeOpenCode(command: string): boolean {
  * Verify that a live PID still belongs to the process that wrote a port record.
  *
  * A PID can be reused after its original process exits. On Linux, procfs gives
- * us a process start time without spawning a helper; other platforms use `ps`
- * only on this cold database-open guard path. Legacy records without a start
- * time use a weaker command-name check, and every probe failure stays live so
- * this identity check cannot weaken the migration guard on uncertainty.
+ * us a process start time without spawning a helper; macOS and other Unix-like
+ * platforms use `ps`, while Windows uses `tasklist`, only on this cold
+ * database-open guard path. Legacy records without a start time use a weaker
+ * command-name check. A failed filesystem or process probe is inconclusive,
+ * not proof that this port record still belongs to OpenCode.
  */
-export function isPidIdentityPlausible(record: RpcPortFileRecord): boolean {
-    if (!Number.isInteger(record.pid) || record.pid <= 0) return false;
+export type PidIdentityPlausibility = "plausible" | "implausible" | "inconclusive";
+
+export function isPidIdentityPlausible(record: RpcPortFileRecord): PidIdentityPlausibility {
+    if (!Number.isInteger(record.pid) || record.pid <= 0) return "implausible";
 
     if (Number.isFinite(record.started_at) && record.started_at > 0) {
         const processStartTime =
             rpcIdentityPlatform === "linux"
                 ? readLinuxProcessStartTime(record.pid)
-                : readPsProcessStartTime(record.pid);
-        if (processStartTime === null) return true;
-        return processStartTime <= record.started_at + RPC_IDENTITY_SKEW_TOLERANCE_MS;
+                : rpcIdentityPlatform === "win32"
+                  ? null
+                  : readPsProcessStartTime(record.pid);
+        if (processStartTime === null) return "inconclusive";
+        return processStartTime <= record.started_at + RPC_IDENTITY_SKEW_TOLERANCE_MS
+            ? "plausible"
+            : "implausible";
     }
 
     const command =
         rpcIdentityPlatform === "linux"
             ? readLinuxProcessCommand(record.pid)
-            : readPsProcessCommand(record.pid);
-    if (command === null) return true;
-    return commandLooksLikeOpenCode(command);
+            : rpcIdentityPlatform === "win32"
+              ? (readWindowsProcess(record.pid).command ?? null)
+              : readPsProcessCommand(record.pid);
+    if (command === null) return "inconclusive";
+    return commandLooksLikeOpenCode(command) ? "plausible" : "implausible";
 }
 
 export function __setRpcIdentityTestHooks(hooks: {
     readFileSync?: typeof readFileSync;
     execFileSync?: typeof execFileSync;
+    processKill?: typeof process.kill;
     processListExecFileSync?: typeof execFileSync;
     platform?: NodeJS.Platform;
     nowMs?: () => number;
 }): void {
     rpcIdentityReadFileSync = hooks.readFileSync ?? readFileSync;
     rpcIdentityExecFileSync = hooks.execFileSync ?? execFileSync;
+    rpcIdentityProcessKill = hooks.processKill ?? process.kill;
     rpcProcessListExecFileSync = hooks.processListExecFileSync ?? execFileSync;
     rpcProcessListTestOverride = hooks.processListExecFileSync !== undefined;
     rpcIdentityPlatform = hooks.platform ?? process.platform;
@@ -196,6 +365,7 @@ export function __setRpcIdentityTestHooks(hooks: {
 export function __resetRpcIdentityTestHooks(): void {
     rpcIdentityReadFileSync = readFileSync;
     rpcIdentityExecFileSync = execFileSync;
+    rpcIdentityProcessKill = process.kill;
     rpcProcessListExecFileSync = execFileSync;
     rpcProcessListTestOverride = false;
     rpcIdentityPlatform = process.platform;
@@ -228,28 +398,49 @@ export interface PiProcessDiscovery {
 
 /**
  * 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().
+ * false evidence that no harness is running. Callers choose their own policy
+ * for the unreadable state: destructive maintenance can fail closed, while a
+ * migration guard can proceed after reporting that no live Pi process was confirmed.
  */
 export function inspectLivePiProcesses(): PiProcessDiscovery {
     if (process.env.NODE_ENV === "test" && !rpcProcessListTestOverride) {
         return { state: "known", processIds: [] };
     }
     try {
+        const isWindows = rpcIdentityPlatform === "win32";
         const output = String(
-            rpcProcessListExecFileSync("ps", ["-axo", "pid=,command="], {
-                encoding: "utf8",
-                timeout: PS_PROBE_TIMEOUT_MS,
-            }),
+            rpcProcessListExecFileSync(
+                isWindows ? "tasklist" : "ps",
+                isWindows ? ["/FO", "CSV"] : ["-axo", "pid=,command="],
+                {
+                    encoding: "utf8",
+                    timeout: PS_PROBE_TIMEOUT_MS,
+                    stdio: ["ignore", "pipe", "pipe"],
+                },
+            ),
         );
         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);
+        if (isWindows) {
+            const entries = parseTasklistOutput(output);
+            if (entries === null) {
+                return {
+                    state: "unreadable",
+                    processIds: [],
+                    error: "tasklist output unavailable",
+                };
+            }
+            for (const entry of entries) {
+                if (entry.pid === process.pid) continue;
+                if (commandLooksLikePi(entry.command)) pids.add(entry.pid);
+            }
+        } else {
+            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) {
@@ -281,6 +472,8 @@ export function parseRpcPortFile(content: string, fallbackPid = 0): RpcPortFileR
                 port,
                 pid,
                 started_at: Number.isFinite(startedAt) ? startedAt : 0,
+                kind: typeof parsed.kind === "string" ? parsed.kind : undefined,
+                harness: typeof parsed.harness === "string" ? parsed.harness : undefined,
                 token: typeof parsed.token === "string" ? parsed.token : undefined,
                 instance_id:
                     typeof parsed.instance_id === "string" ? parsed.instance_id : undefined,

package/src/shared/tail-hygiene-status.ts

@@ -0,0 +1,57 @@
+import type { Channel1State } from "../hooks/magic-context/ctx-reduce-nudge";
+import type { TailHygieneStatus } from "./rpc-types";
+
+export interface WireTailHygieneBaseline {
+    u?: number;
+    t?: number;
+    severity?: number;
+    evaluable?: boolean;
+    generation_invalidated?: boolean;
+    baseline_generation?: number;
+    computed_at_ms?: number;
+}
+
+function finiteNumber(value: unknown, fallback = 0): number {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+/** Normalize either renderer authority's persisted baseline without dropping valid zeros. */
+export function resolveTailHygieneStatus(
+    tsBaseline: Channel1State | undefined,
+    rustBaseline?: WireTailHygieneBaseline | null,
+): TailHygieneStatus | undefined {
+    if (rustBaseline !== undefined && rustBaseline !== null) {
+        const t = Math.max(0, finiteNumber(rustBaseline.t));
+        const u = Math.min(t, Math.max(0, finiteNumber(rustBaseline.u)));
+        return {
+            u,
+            t,
+            severity: Math.min(
+                1,
+                Math.max(0, finiteNumber(rustBaseline.severity, u / Math.max(t, 1))),
+            ),
+            evaluable: rustBaseline.evaluable === true,
+            generationInvalidated: rustBaseline.generation_invalidated === true,
+            baselineGeneration: Math.max(0, finiteNumber(rustBaseline.baseline_generation)),
+            computedAt: Math.max(0, finiteNumber(rustBaseline.computed_at_ms)),
+        };
+    }
+    if (tsBaseline === undefined) return undefined;
+    const t = Math.max(0, tsBaseline.baselineT + tsBaseline.turnDeltaT);
+    const u = Math.min(t, Math.max(0, tsBaseline.baselineU + tsBaseline.turnDeltaU));
+    return {
+        u,
+        t,
+        severity: Math.min(1, Math.max(0, u / Math.max(t, 1))),
+        evaluable: tsBaseline.evaluable && !tsBaseline.generationInvalidated,
+        generationInvalidated: tsBaseline.generationInvalidated,
+        baselineGeneration: Math.max(0, tsBaseline.baselineGeneration),
+        computedAt: Math.max(0, tsBaseline.computedAt),
+    };
+}
+
+export function formatTailHygiene(status: TailHygieneStatus): string {
+    const percentage = (status.severity * 100).toFixed(1);
+    const state = status.evaluable ? "" : " · held until baseline refresh";
+    return `${percentage}% · ${status.u.toLocaleString()} / ${status.t.toLocaleString()} tok${state}`;
+}