@cortexkit/opencode-magic-context 0.38.1 → 0.40.0

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

@@ -0,0 +1,170 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+    normalizeModelEntry,
+    resolveDreamerTaskModel,
+    resolveFallbackEntries,
+    resolveHistorianModel,
+} from "./model-resolution";
+
+describe("model-resolution", () => {
+    test("normalizes string and object entries to the same model identity", () => {
+        expect(normalizeModelEntry("anthropic/sonnet", "opencode")).toEqual({
+            model: "anthropic/sonnet",
+        });
+        expect(
+            normalizeModelEntry({ model: "anthropic/sonnet", variant: "high" }, "opencode"),
+        ).toEqual({ model: "anthropic/sonnet", qualifier: "high" });
+    });
+
+    test("keeps ordered qualifier-distinct fallbacks and removes exact duplicates", () => {
+        expect(
+            resolveFallbackEntries(
+                [
+                    { model: "anthropic/sonnet", variant: "low" },
+                    { model: "anthropic/sonnet", variant: "high" },
+                    { model: "anthropic/sonnet", variant: "low" },
+                    "google/flash",
+                    "google/flash",
+                ],
+                "opencode",
+            ),
+        ).toEqual([
+            { model: "anthropic/sonnet", qualifier: "low" },
+            { model: "anthropic/sonnet", qualifier: "high" },
+            { model: "google/flash" },
+        ]);
+    });
+
+    test("does not inherit a block qualifier into unqualified fallbacks", () => {
+        const config = {
+            historian: {
+                opencode: {
+                    model: "open/primary",
+                    fallback_models: ["open/fallback"],
+                    variant: "primary-only",
+                },
+                pi: {
+                    model: "pi/primary",
+                    fallback_models: ["pi/fallback"],
+                    thinking_level: "high",
+                },
+            },
+        };
+
+        // Inheritance is deliberately absent because a fallback model may not support the
+        // qualifier selected for the primary model.
+        expect(resolveHistorianModel(config, "opencode")).toEqual({
+            primary: { model: "open/primary", qualifier: "primary-only" },
+            fallbacks: [{ model: "open/fallback" }],
+        });
+        expect(resolveHistorianModel(config, "pi")).toEqual({
+            primary: { model: "pi/primary", qualifier: "high" },
+            fallbacks: [{ model: "pi/fallback" }],
+        });
+    });
+
+    test("reads historian attempts only from the requested harness", () => {
+        const config = {
+            historian: {
+                model: "flat/ignored",
+                opencode: {
+                    model: { model: "open/code", variant: "oc-primary" },
+                    fallback_models: [{ model: "open/fallback", variant: "oc-fallback" }],
+                },
+                pi: {
+                    model: { model: "pi/model", thinking_level: "high" },
+                    fallback_models: [{ model: "pi/fallback", thinking_level: "max" }],
+                },
+            },
+        };
+
+        expect(resolveHistorianModel(config, "opencode")).toEqual({
+            primary: { model: "open/code", qualifier: "oc-primary" },
+            fallbacks: [{ model: "open/fallback", qualifier: "oc-fallback" }],
+        });
+        expect(resolveHistorianModel(config, "pi")).toEqual({
+            primary: { model: "pi/model", qualifier: "high" },
+            fallbacks: [{ model: "pi/fallback", qualifier: "max" }],
+        });
+    });
+
+    test("resolves ordinary task model and scheduling without crossing harnesses", () => {
+        const config = {
+            dreamer: {
+                tasks: {
+                    curate: { schedule: "0 4 * * *", promotion_threshold: 3 },
+                },
+                opencode: {
+                    model: { model: "open/default", variant: "default-variant" },
+                    tasks: {
+                        curate: {
+                            model: { model: "open/task", variant: "task-variant" },
+                            fallback_models: [
+                                "open/bare",
+                                { model: "open/qualified", variant: "fb" },
+                            ],
+                            timeout_minutes: 12,
+                        },
+                    },
+                },
+                pi: {
+                    model: { model: "pi/default", thinking_level: "high" },
+                    tasks: {
+                        curate: {
+                            model: { model: "pi/task", thinking_level: "max" },
+                            fallback_models: [{ model: "pi/fallback", thinking_level: "minimal" }],
+                        },
+                    },
+                },
+            },
+        };
+
+        expect(resolveDreamerTaskModel({ config, harness: "opencode", task: "curate" })).toEqual({
+            primary: { model: "open/task", qualifier: "task-variant" },
+            fallbacks: [{ model: "open/bare" }, { model: "open/qualified", qualifier: "fb" }],
+            schedule: "0 4 * * *",
+            timeoutMinutes: 12,
+            promotionThreshold: 3,
+        });
+    });
+
+    test("uses mural model between compress-cues task and harness default", () => {
+        const config = {
+            dreamer: {
+                tasks: { "compress-cues": { schedule: "0 4 * * *" } },
+                opencode: {
+                    model: { model: "open/default", variant: "default-variant" },
+                    tasks: { "compress-cues": { variant: "task-local-must-not-leak" } },
+                },
+                pi: {
+                    model: { model: "pi/default", thinking_level: "high" },
+                    tasks: { "compress-cues": {} },
+                },
+            },
+        };
+
+        expect(
+            resolveDreamerTaskModel({
+                config,
+                harness: "opencode",
+                task: "compress-cues",
+                muralModel: "mural/model",
+            }),
+        ).toMatchObject({
+            primary: { model: "mural/model", qualifier: "default-variant" },
+            fallbacks: [],
+        });
+        expect(
+            resolveDreamerTaskModel({
+                config,
+                harness: "pi",
+                task: "compress-cues",
+                muralModel: "mural/model",
+            }),
+        ).toMatchObject({
+            primary: { model: "mural/model", qualifier: "high" },
+            fallbacks: [],
+        });
+    });
+});

package/src/shared/model-resolution.ts

@@ -0,0 +1,227 @@
+export type ModelHarness = "opencode" | "pi";
+
+export interface ResolvedModelEntry {
+    /** Canonical provider/model reference used for identity and model selection. */
+    model: string;
+    /** OpenCode variant or Pi thinking level, selected for the active entry only. */
+    qualifier?: string;
+}
+
+export type ModelInput = string | ResolvedModelEntry;
+
+type ConfigRecord = Record<string, unknown>;
+
+function asRecord(value: unknown): ConfigRecord | undefined {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? (value as ConfigRecord)
+        : undefined;
+}
+
+function readString(value: unknown): string | undefined {
+    if (typeof value !== "string") return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function hasOwn(record: ConfigRecord, key: string): boolean {
+    return Object.hasOwn(record, key);
+}
+
+/**
+ * Collapses the string and object spellings of a harness model entry into the
+ * same model identity. Qualifiers stay separate because they alter an attempt,
+ * not the configured model identity.
+ */
+export function normalizeModelEntry(
+    entry: unknown,
+    harness: ModelHarness,
+): ResolvedModelEntry | undefined {
+    if (typeof entry === "string") {
+        const model = readString(entry);
+        return model ? { model } : undefined;
+    }
+
+    const objectEntry = asRecord(entry);
+    if (!objectEntry) return undefined;
+    const model = readString(objectEntry.model);
+    if (!model) return undefined;
+
+    const qualifier = readString(
+        objectEntry[harness === "opencode" ? "variant" : "thinking_level"],
+    );
+    return qualifier ? { model, qualifier } : { model };
+}
+
+function isValidModelReference(entry: ResolvedModelEntry): boolean {
+    const slash = entry.model.indexOf("/");
+    return slash > 0 && slash < entry.model.length - 1;
+}
+
+function sameAttempt(a: ResolvedModelEntry, b: ResolvedModelEntry): boolean {
+    return a.model === b.model && a.qualifier === b.qualifier;
+}
+
+/**
+ * Resolves a configured fallback list in declaration order. Attempts are
+ * deduplicated by model plus qualifier: the same model with distinct
+ * qualifiers remains two intentional attempts.
+ */
+export function resolveFallbackEntries(
+    value: unknown,
+    harness: ModelHarness,
+): ResolvedModelEntry[] {
+    const values = Array.isArray(value) ? value : value === undefined ? [] : [value];
+    const resolved: ResolvedModelEntry[] = [];
+    for (const value of values) {
+        const entry = normalizeModelEntry(value, harness);
+        if (!entry || !isValidModelReference(entry)) continue;
+        if (resolved.some((candidate) => sameAttempt(candidate, entry))) continue;
+        resolved.push(entry);
+    }
+    return resolved;
+}
+
+function resolvePrimaryEntry(args: {
+    entry: unknown;
+    defaultQualifier: unknown;
+    harness: ModelHarness;
+}): ResolvedModelEntry | undefined {
+    const entry = normalizeModelEntry(args.entry, args.harness);
+    if (!entry) return undefined;
+    const qualifier = entry.qualifier ?? readString(args.defaultQualifier);
+    return qualifier ? { ...entry, qualifier } : entry;
+}
+
+export interface ResolvedHistorianModel {
+    primary?: ResolvedModelEntry;
+    fallbacks: ResolvedModelEntry[];
+}
+
+/**
+ * Resolve historian model attempts from exactly one harness block. Flat keys
+ * and the other harness are deliberately never consulted after cutover.
+ */
+export function resolveHistorianModel(
+    config: unknown,
+    harness: ModelHarness,
+): ResolvedHistorianModel {
+    const historian = asRecord(asRecord(config)?.historian);
+    const block = asRecord(historian?.[harness]);
+    if (!block) return { fallbacks: [] };
+
+    return {
+        primary: resolvePrimaryEntry({
+            entry: block.model,
+            defaultQualifier: block[harness === "opencode" ? "variant" : "thinking_level"],
+            harness,
+        }),
+        fallbacks: resolveFallbackEntries(block.fallback_models, harness),
+    };
+}
+
+export interface ResolvedDreamerTaskModel {
+    primary?: ResolvedModelEntry;
+    fallbacks: ResolvedModelEntry[];
+    schedule?: string;
+    timeoutMinutes?: number;
+    promotionThreshold?: number;
+}
+
+/**
+ * Resolve a dreamer task from one harness subtree. Model selection is task →
+ * harness default, except compress-cues inserts its harness-independent mural
+ * string between those two rungs. Scheduling remains at dreamer.tasks.<task>.
+ */
+export function resolveDreamerTaskModel(args: {
+    config: unknown;
+    harness: ModelHarness;
+    task: string;
+    muralModel?: unknown;
+}): ResolvedDreamerTaskModel {
+    const dreamer = asRecord(asRecord(args.config)?.dreamer);
+    const harnessBlock = asRecord(dreamer?.[args.harness]);
+    const taskBlock = asRecord(asRecord(harnessBlock?.tasks)?.[args.task]);
+    const schedulingTask = asRecord(asRecord(dreamer?.tasks)?.[args.task]);
+    if (!harnessBlock) {
+        return {
+            fallbacks: [],
+            schedule: readString(schedulingTask?.schedule),
+            timeoutMinutes:
+                typeof taskBlock?.timeout_minutes === "number"
+                    ? taskBlock.timeout_minutes
+                    : undefined,
+            promotionThreshold:
+                typeof schedulingTask?.promotion_threshold === "number"
+                    ? schedulingTask.promotion_threshold
+                    : undefined,
+        };
+    }
+
+    const taskQualifier = taskBlock?.[args.harness === "opencode" ? "variant" : "thinking_level"];
+    // A mural string borrows the harness default's qualifier whether that
+    // qualifier is written beside `model` or inside the default entry object.
+    const harnessQualifier =
+        harnessBlock[args.harness === "opencode" ? "variant" : "thinking_level"] ??
+        normalizeModelEntry(harnessBlock.model, args.harness)?.qualifier;
+    const taskHasModel = taskBlock !== undefined && hasOwn(taskBlock, "model");
+    const usesMuralModel =
+        !taskHasModel && args.task === "compress-cues" && Boolean(readString(args.muralModel));
+    const primarySource = taskHasModel
+        ? taskBlock?.model
+        : usesMuralModel
+          ? args.muralModel
+          : harnessBlock.model;
+    const fallbackSource =
+        taskBlock !== undefined && hasOwn(taskBlock, "fallback_models")
+            ? taskBlock.fallback_models
+            : harnessBlock.fallback_models;
+
+    return {
+        primary: resolvePrimaryEntry({
+            entry: primarySource,
+            // mural.model is a plain string, so its qualifier is always the
+            // executing harness default rather than a task-local default.
+            defaultQualifier: usesMuralModel
+                ? harnessQualifier
+                : (taskQualifier ?? harnessQualifier),
+            harness: args.harness,
+        }),
+        fallbacks: resolveFallbackEntries(fallbackSource, args.harness),
+        schedule: readString(schedulingTask?.schedule),
+        timeoutMinutes:
+            typeof taskBlock?.timeout_minutes === "number" ? taskBlock.timeout_minutes : undefined,
+        promotionThreshold:
+            typeof schedulingTask?.promotion_threshold === "number"
+                ? schedulingTask.promotion_threshold
+                : undefined,
+    };
+}
+
+/**
+ * Keep non-model agent settings at their original level while replacing only
+ * OpenCode's model-resolution fields with the executing harness's primary.
+ */
+export function resolveOpenCodeAgentOverrides(agent: unknown): Record<string, unknown> {
+    const source = asRecord(agent);
+    if (!source) return {};
+    const {
+        model: _model,
+        fallback_models: _fallbackModels,
+        variant: _variant,
+        thinking_level: _thinking,
+        opencode,
+        pi,
+        tasks,
+        ...rest
+    } = source;
+    const primary = resolvePrimaryEntry({
+        entry: asRecord(opencode)?.model,
+        defaultQualifier: asRecord(opencode)?.variant,
+        harness: "opencode",
+    });
+    return {
+        ...rest,
+        ...(primary ? { model: primary.model } : {}),
+        ...(primary?.qualifier ? { variant: primary.qualifier } : {}),
+    };
+}

package/src/shared/model-suggestion-retry.test.ts

@@ -56,6 +56,33 @@ describe("promptSyncWithModelSuggestionRetry", () => {
         expect(prompt).toHaveBeenCalledTimes(1);
     });
 
+    test("each active fallback sends only its own variant", async () => {
+        const prompt = mock(async () => {
+            if (prompt.mock.calls.length <= 2) throw new Error("attempt failed");
+            return {};
+        });
+        const client = createClient(prompt);
+
+        await promptSyncWithModelSuggestionRetry(
+            client,
+            {
+                path: { id: "ses-test" },
+                body: { model: { providerID: "anthropic", modelID: "primary" }, variant: "high" },
+            },
+            {
+                fallbackModels: [{ model: "anthropic/fallback", qualifier: "low" }, "google/bare"],
+            },
+        );
+
+        expect((prompt.mock.calls[1]?.[0] as PromptCall).body).toMatchObject({
+            model: { providerID: "anthropic", modelID: "fallback" },
+            variant: "low",
+        });
+        const bareFallbackBody = (prompt.mock.calls[2]?.[0] as PromptCall).body;
+        expect(bareFallbackBody.model).toEqual({ providerID: "google", modelID: "bare" });
+        expect(bareFallbackBody.variant).toBeUndefined();
+    });
+
     test("primary fails, fallback[0] succeeds", async () => {
         const prompt = mock(async () => {
             if (prompt.mock.calls.length === 1) throw new Error("primary failed");

package/src/shared/model-suggestion-retry.ts

@@ -2,7 +2,8 @@ import type { createOpencodeClient } from "@opencode-ai/sdk";
 
 import { detectOverflow } from "../features/magic-context/overflow-detection";
 import { log } from "./logger";
-import { parseProviderModel } from "./resolve-fallbacks";
+import type { ModelInput } from "./model-resolution";
+import { parseProviderModel, toModelEntry } from "./resolve-fallbacks";
 
 type Client = ReturnType<typeof createOpencodeClient>;
 
@@ -13,6 +14,8 @@ const ABORT_CALL_TIMEOUT_MS = 3000;
 
 export type PromptBody = {
     model?: { providerID: string; modelID: string };
+    /** OpenCode variant; Pi's facade also uses it as the active thinking level. */
+    variant?: string;
     [key: string]: unknown;
 };
 
@@ -64,7 +67,7 @@ export interface PromptRetryOptions {
      *   - On all-failed, the LAST error is thrown (matches legacy behavior when
      *     `fallbackModels` is empty).
      */
-    fallbackModels?: readonly string[];
+    fallbackModels?: readonly ModelInput[];
     /**
      * Identifier for structured logging (e.g. "dreamer:consolidate",
      * "historian", "compressor", "sidekick"). Helps correlate fallback
@@ -394,16 +397,19 @@ export async function promptSyncWithModelSuggestionRetry(
 
     // Iterate fallbacks.
     for (let i = 0; i < fallbacks.length; i += 1) {
-        const parsed = parseProviderModel(fallbacks[i]);
+        const fallback = toModelEntry(fallbacks[i]);
+        const parsed = fallback ? parseProviderModel(fallback.model) : null;
         if (!parsed) {
-            log(`[${callContext}] skipping invalid fallback spec: ${fallbacks[i]}`);
+            log(`[${callContext}] skipping invalid fallback spec: ${String(fallbacks[i])}`);
             continue;
         }
 
         const label = `${parsed.providerID}/${parsed.modelID}`;
+        const { variant: _primaryVariant, ...bodyWithoutPrimaryVariant } = baseBody;
         const attemptArgs = copyPromptArgs(baseArgs, {
-            ...baseBody,
+            ...bodyWithoutPrimaryVariant,
             model: parsed,
+            ...(fallback?.qualifier ? { variant: fallback.qualifier } : {}),
         });
 
         try {
@@ -429,7 +435,7 @@ export async function promptSyncWithModelSuggestionRetry(
     // caller's report (e.g. /ctx-dream tasks_json) still surfaces a real
     // diagnostic.
     log(
-        `[${callContext}] all models exhausted; tried: ${[explicitPrimaryLabel, ...fallbacks].join(", ")}; last error: ${shortErr(lastError)}`,
+        `[${callContext}] all models exhausted; tried: ${[explicitPrimaryLabel, ...fallbacks.map((fallback) => toModelEntry(fallback)?.model ?? String(fallback))].join(", ")}; last error: ${shortErr(lastError)}`,
     );
     throw lastError ?? new Error("All fallback models failed");
 }
@@ -515,16 +521,19 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
     }
 
     for (let i = 0; i < fallbacks.length; i += 1) {
-        const parsed = parseProviderModel(fallbacks[i]);
+        const fallback = toModelEntry(fallbacks[i]);
+        const parsed = fallback ? parseProviderModel(fallback.model) : null;
         if (!parsed) {
-            log(`[${callContext}] skipping invalid fallback spec: ${fallbacks[i]}`);
+            log(`[${callContext}] skipping invalid fallback spec: ${String(fallbacks[i])}`);
             continue;
         }
 
         const label = `${parsed.providerID}/${parsed.modelID}`;
+        const { variant: _primaryVariant, ...bodyWithoutPrimaryVariant } = baseBody;
         const attemptArgs = copyPromptArgs(baseArgs, {
-            ...baseBody,
+            ...bodyWithoutPrimaryVariant,
             model: parsed,
+            ...(fallback?.qualifier ? { variant: fallback.qualifier } : {}),
         });
         const attempt: PromptAttemptInfo = {
             label,
@@ -563,7 +572,7 @@ export async function promptSyncWithValidatedOutputRetry<TOutput, TValidated = T
     }
 
     log(
-        `[${callContext}] all models exhausted; tried: ${[explicitPrimaryLabel, ...fallbacks].join(", ")}; original error: ${shortErr(firstError)}; last error: ${shortErr(lastError)}`,
+        `[${callContext}] all models exhausted; tried: ${[explicitPrimaryLabel, ...fallbacks.map((fallback) => toModelEntry(fallback)?.model ?? String(fallback))].join(", ")}; original error: ${shortErr(firstError)}; last error: ${shortErr(lastError)}`,
     );
     throw firstError ?? lastError ?? new Error("All fallback models failed validation");
 }

package/src/shared/resolve-fallbacks.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { parseProviderModel, resolveFallbackChain } from "./resolve-fallbacks";
+import { modelBodyField, parseProviderModel, resolveFallbackChain } from "./resolve-fallbacks";
 
 describe("resolveFallbackChain", () => {
     // Policy: user-config-only. There is NO builtin provider-agnostic chain —
@@ -62,6 +62,18 @@ describe("resolveFallbackChain", () => {
     });
 });
 
+describe("modelBodyField", () => {
+    test("sends the active entry variant and leaves a bare entry unqualified", () => {
+        expect(modelBodyField({ model: "anthropic/claude-sonnet", qualifier: "high" })).toEqual({
+            model: { providerID: "anthropic", modelID: "claude-sonnet" },
+            variant: "high",
+        });
+        expect(modelBodyField("google/gemini-flash")).toEqual({
+            model: { providerID: "google", modelID: "gemini-flash" },
+        });
+    });
+});
+
 describe("parseProviderModel", () => {
     test("parses standard provider/model", () => {
         expect(parseProviderModel("anthropic/claude-sonnet-4-6")).toEqual({

package/src/shared/resolve-fallbacks.ts

@@ -1,3 +1,5 @@
+import type { ModelInput, ResolvedModelEntry } from "./model-resolution";
+
 /**
  * Resolve the fallback model list to attempt for a hidden-agent (historian /
  * dreamer / sidekick) call when its configured primary fails.
@@ -71,10 +73,23 @@ export function parseProviderModel(spec: string): { providerID: string; modelID:
  * unparseable (the session falls back to its default model). Spread into a
  * `client.session.prompt` body.
  */
-export function modelBodyField(spec: string | undefined): {
+export function modelBodyField(spec: ModelInput | undefined): {
     model?: { providerID: string; modelID: string };
+    variant?: string;
 } {
-    if (!spec) return {};
-    const parsed = parseProviderModel(spec);
-    return parsed ? { model: parsed } : {};
+    const entry = toModelEntry(spec);
+    if (!entry) return {};
+    const parsed = parseProviderModel(entry.model);
+    return parsed
+        ? { model: parsed, ...(entry.qualifier ? { variant: entry.qualifier } : {}) }
+        : {};
+}
+
+/** Convert legacy string call sites and resolved entries into one active attempt shape. */
+export function toModelEntry(spec: ModelInput | undefined): ResolvedModelEntry | undefined {
+    if (typeof spec === "string") {
+        const model = spec.trim();
+        return model ? { model } : undefined;
+    }
+    return spec;
 }

package/src/shared/rpc-types.ts

@@ -141,6 +141,8 @@ export interface SidebarSnapshot {
 }
 
 export interface StatusDetail extends SidebarSnapshot {
+    /** User-owned model profile selected for this project, or null for the base config. */
+    activeProfile: string | null;
     tagCounter: number;
     activeTags: number;
     droppedTags: number;

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

@@ -3,6 +3,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import type { execFileSync } from "node:child_process";
 import type { readFileSync } from "node:fs";
+
 import {
     __resetRpcIdentityTestHooks,
     __setRpcIdentityTestHooks,
@@ -12,6 +13,7 @@ import {
     isPidAlive,
     isPidIdentityPlausible,
     type RpcPortFileRecord,
+    readProcessProbeEvidence,
 } from "./rpc-utils";
 
 const PID = 1234;
@@ -210,6 +212,36 @@ describe("isPidAlive", () => {
     });
 });
 
+describe("readProcessProbeEvidence", () => {
+    test("captures the same Linux start-time and command probes used by the guard", () => {
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            nowMs: () => NOW_MS,
+            readFileSync: linuxFiles({
+                [`/proc/${PID}/stat`]: procStat(10_000),
+                "/proc/uptime": `${UPTIME_SECONDS}.0 0.0`,
+                [`/proc/${PID}/cmdline`]:
+                    "/usr/local/bin/opencode\u0000--directory\u0000/home/alice/project",
+            }),
+        });
+
+        expect(readProcessProbeEvidence(PID)).toEqual({
+            startTime: 1_100_000,
+            commandLine: "/usr/local/bin/opencode\u0000--directory\u0000/home/alice/project",
+        });
+    });
+
+    test("returns unavailable fields instead of throwing when probes fail", () => {
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            readFileSync: linuxFiles({}),
+        });
+
+        expect(() => readProcessProbeEvidence(PID)).not.toThrow();
+        expect(readProcessProbeEvidence(PID)).toEqual({ startTime: null, commandLine: null });
+    });
+});
+
 describe("isPidIdentityPlausible", () => {
     test("rejects a reused Linux PID when proc start time is substantially newer", () => {
         const readPaths: string[] = [];