@retaw106/mmc-oc 0.0.0-stage → 1.2.2

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

@@ -0,0 +1,114 @@
+import { describe, expect, test } from "bun:test";
+
+import { modelBodyField, parseProviderModel, resolveFallbackChain } from "./resolve-fallbacks";
+
+describe("resolveFallbackChain", () => {
+    // Policy: user-config-only. There is NO builtin provider-agnostic chain —
+    // when the user configures no fallback_models the result is EMPTY, and the
+    // runner's session-model last resort (a model the user actually has) is the
+    // only fallback. A hardcoded chain named providers the user may not have and
+    // produced `Model not found` retry storms.
+    test("returns empty when user provides nothing (no builtin chain)", () => {
+        expect(resolveFallbackChain(undefined)).toEqual([]);
+    });
+
+    test("returns empty for empty string", () => {
+        expect(resolveFallbackChain("")).toEqual([]);
+    });
+
+    test("returns empty for empty array", () => {
+        expect(resolveFallbackChain([])).toEqual([]);
+    });
+
+    test("user-only when user provides valid fallback_models string", () => {
+        expect(resolveFallbackChain("anthropic/claude-sonnet-4-6")).toEqual([
+            "anthropic/claude-sonnet-4-6",
+        ]);
+    });
+
+    test("user-only when user provides valid fallback_models array", () => {
+        expect(
+            resolveFallbackChain(["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"]),
+        ).toEqual(["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"]);
+    });
+
+    test("dedupes user-provided list", () => {
+        expect(
+            resolveFallbackChain([
+                "anthropic/claude-sonnet-4-6",
+                "anthropic/claude-sonnet-4-6",
+                "google/gemini-3-flash",
+            ]),
+        ).toEqual(["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"]);
+    });
+
+    test("strips invalid 'provider/model' entries", () => {
+        expect(
+            resolveFallbackChain([
+                "anthropic/claude-sonnet-4-6",
+                "no-slash-here",
+                "/leading-slash",
+                "trailing-slash/",
+                "",
+                "  ",
+            ]),
+        ).toEqual(["anthropic/claude-sonnet-4-6"]);
+    });
+
+    test("trims whitespace in user entries", () => {
+        expect(
+            resolveFallbackChain(["  anthropic/claude-sonnet-4-6  ", "\tgoogle/gemini-3-flash\n"]),
+        ).toEqual(["anthropic/claude-sonnet-4-6", "google/gemini-3-flash"]);
+    });
+});
+
+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({
+            providerID: "anthropic",
+            modelID: "claude-sonnet-4-6",
+        });
+    });
+
+    test("handles model id with slashes (only splits on first slash)", () => {
+        expect(parseProviderModel("lemonade/GLM-4.7-Flash-GGUF/main")).toEqual({
+            providerID: "lemonade",
+            modelID: "GLM-4.7-Flash-GGUF/main",
+        });
+    });
+
+    test("trims whitespace", () => {
+        expect(parseProviderModel("  anthropic/claude-sonnet-4-6  ")).toEqual({
+            providerID: "anthropic",
+            modelID: "claude-sonnet-4-6",
+        });
+    });
+
+    test("returns null for no slash", () => {
+        expect(parseProviderModel("anthropic")).toBeNull();
+    });
+
+    test("returns null for leading slash", () => {
+        expect(parseProviderModel("/claude-sonnet-4-6")).toBeNull();
+    });
+
+    test("returns null for trailing slash", () => {
+        expect(parseProviderModel("anthropic/")).toBeNull();
+    });
+
+    test("returns null for empty string", () => {
+        expect(parseProviderModel("")).toBeNull();
+    });
+});

package/src/shared/resolve-fallbacks.ts

@@ -0,0 +1,95 @@
+import type { ModelInput, ResolvedModelEntry } from "./model-resolution";
+
+/**
+ * Resolve the fallback model list to attempt for a hidden-agent (historian /
+ * dreamer) call when its configured primary fails.
+ *
+ * Policy: ONLY the user's explicitly-configured `fallback_models` for this
+ * agent. There is NO builtin provider-agnostic chain — a hardcoded chain
+ * inevitably names providers the user doesn't have (e.g. a metapi-only user got
+ * a chain of google/github-copilot/opencode entries, every one a
+ * `Model not found` retry), which produced confusing errors and wasted
+ * attempts. If the user configured nothing, this returns an empty list and the
+ * runner's session-model last resort (the model the user is actually using) is
+ * the only fallback.
+ *
+ * The returned list does NOT include the primary model — it's the ordered list
+ * of *alternates* to try after the primary fails. Each entry is
+ * "provider/modelID" form. Duplicates and empty strings are filtered; entries
+ * that don't match the "provider/modelID" shape (a "/" with non-empty parts) are
+ * dropped as a defensive guard against malformed user config.
+ */
+export function resolveFallbackChain(
+    userFallbacks: readonly string[] | string | undefined,
+): string[] {
+    const userList = normalizeUserFallbacks(userFallbacks);
+    return dedupe(userList.filter(isValidModelSpec));
+}
+
+function normalizeUserFallbacks(userFallbacks: readonly string[] | string | undefined): string[] {
+    if (!userFallbacks) return [];
+    if (typeof userFallbacks === "string") {
+        const trimmed = userFallbacks.trim();
+        return trimmed ? [trimmed] : [];
+    }
+    return userFallbacks.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+
+function isValidModelSpec(spec: string): boolean {
+    const slash = spec.indexOf("/");
+    return slash > 0 && slash < spec.length - 1;
+}
+
+function dedupe(list: string[]): string[] {
+    const seen = new Set<string>();
+    const out: string[] = [];
+    for (const item of list) {
+        if (seen.has(item)) continue;
+        seen.add(item);
+        out.push(item);
+    }
+    return out;
+}
+
+/**
+ * Parse a "provider/modelID" string into the OpenCode `model` object shape.
+ * Returns null on invalid input.
+ *
+ * Note: only splits on the FIRST "/" — modelID can legitimately contain slashes
+ * (e.g. `lemonade/GLM-4.7-Flash-GGUF/main`).
+ */
+export function parseProviderModel(spec: string): { providerID: string; modelID: string } | null {
+    const slash = spec.indexOf("/");
+    if (slash < 1 || slash >= spec.length - 1) return null;
+    return {
+        providerID: spec.slice(0, slash).trim(),
+        modelID: spec.slice(slash + 1).trim(),
+    };
+}
+
+/**
+ * Build the `{ model: { providerID, modelID } }` fragment for an OpenCode prompt
+ * body from a `provider/model` spec string, or `{}` when the spec is absent or
+ * unparseable (the session falls back to its default model). Spread into a
+ * `client.session.prompt` body.
+ */
+export function modelBodyField(spec: ModelInput | undefined): {
+    model?: { providerID: string; modelID: string };
+    variant?: string;
+} {
+    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-async-probes.test.ts

@@ -0,0 +1,320 @@
+import { afterEach, expect, test } from "bun:test";
+import type { execFileSync } from "node:child_process";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+    __resetSchemaFenceStateForTests,
+    getMigrationOnOpenRefusal,
+    LATEST_SUPPORTED_VERSION,
+    openDatabaseAsync,
+} from "../features/magic-context/storage-db";
+import { createV2StorageGate, probeV2StorageAtBoot } from "../v2/hooks/storage-gate";
+import {
+    __resetRpcIdentityTestHooks,
+    __setAsyncProcessProbeForTests,
+    __setRpcIdentityTestHooks,
+    inspectProcessesAsync,
+} from "./rpc-utils";
+import { Database } from "./sqlite";
+import { createTestTempDirFromPath } from "./test-temp-dir";
+
+afterEach(() => {
+    __resetSchemaFenceStateForTests();
+    __resetRpcIdentityTestHooks();
+    __setAsyncProcessProbeForTests();
+});
+
+test("async Windows inspection bypasses slow synchronous probes and shares a bounded snapshot", async () => {
+    let synchronousCalls = 0;
+    const slow = (() => {
+        synchronousCalls++;
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5000);
+        return "";
+    }) as typeof execFileSync;
+    __setRpcIdentityTestHooks({
+        platform: "win32",
+        execFileSync: slow,
+        processListExecFileSync: slow,
+    });
+    let release!: (value: string) => void;
+    let calls = 0;
+    __setAsyncProcessProbeForTests(async (file, _args, timeout) => {
+        expect(file).toBe("powershell");
+        expect(timeout).toBe(5000);
+        calls++;
+        return new Promise<string>((resolve) => {
+            release = resolve;
+        });
+    });
+    const first = inspectProcessesAsync();
+    const second = inspectProcessesAsync();
+    expect(second).toBe(first);
+    const heartbeat = await Promise.race([
+        first.then(() => "probe"),
+        new Promise<string>((resolve) => setTimeout(() => resolve("heartbeat"), 10)),
+    ]);
+    expect(heartbeat).toBe("heartbeat");
+    release(
+        JSON.stringify([
+            {
+                ProcessId: 12345,
+                ParentProcessId: 1,
+                CommandLine: "opencode serve",
+                CreationDate: "2026-09-28T00:00:00Z",
+            },
+        ]),
+    );
+    const result = await first;
+    expect(result.liveness(12345)).toBe("alive");
+    expect(result.evidence(12345).commandLine).toBe("opencode serve");
+    expect(result.liveness(12346)).toBe("dead");
+    expect(await inspectProcessesAsync()).toBe(result);
+    expect(calls).toBe(1);
+    expect(synchronousCalls).toBe(0);
+});
+
+test("offline process inspection can bypass a cached snapshot", async () => {
+    __setRpcIdentityTestHooks({ platform: "win32" });
+    let calls = 0;
+    __setAsyncProcessProbeForTests(async () => {
+        calls++;
+        return JSON.stringify([
+            {
+                ProcessId: calls + 100,
+                ParentProcessId: 1,
+                Name: "opencode.exe",
+                CommandLine: null,
+                CreationDate: "2026-09-28T00:00:00Z",
+            },
+        ]);
+    });
+    const cached = await inspectProcessesAsync();
+    expect((await inspectProcessesAsync()).processSnapshot).toBe(cached.processSnapshot);
+    const fresh = await inspectProcessesAsync(true);
+    expect(fresh.processSnapshot?.source).toBe("cim");
+    expect(fresh.processSnapshot?.facts).toContainEqual(
+        expect.objectContaining({ pid: 102, imageName: "opencode.exe", commandLine: null }),
+    );
+    expect(calls).toBe(2);
+});
+
+test("async Windows inspection bounds CIM and tasklist fallback and caches failure", async () => {
+    __setRpcIdentityTestHooks({ platform: "win32" });
+    const calls: Array<[string, number]> = [];
+    __setAsyncProcessProbeForTests(async (file, _args, timeout) => {
+        calls.push([file, timeout]);
+        throw new Error("probe timed out");
+    });
+    const result = await inspectProcessesAsync();
+    expect(result.pi.state).toBe("unreadable");
+    expect(result.liveness(123)).toBe("inconclusive");
+    expect(result.evidence(123)).toEqual({ startTime: null, commandLine: null });
+    await inspectProcessesAsync();
+    expect(calls).toEqual([
+        ["powershell", 5000],
+        ["tasklist", 1000],
+    ]);
+});
+
+test("boot storage wait stays responsive with a locked v90 store and slow Windows probes", async () => {
+    const root = createTestTempDirFromPath(join(tmpdir(), "async-storage-guard-"));
+    const dbPath = join(root, "context.db");
+    const seeded = new Database(dbPath);
+    seeded.exec(
+        `CREATE TABLE schema_migrations(version INTEGER PRIMARY KEY); INSERT INTO schema_migrations VALUES(${LATEST_SUPPORTED_VERSION - 1})`,
+    );
+    seeded.exec("BEGIN IMMEDIATE");
+    mkdirSync(join(root, "rpc", "blocker"), { recursive: true });
+    writeFileSync(
+        join(root, "rpc", "blocker", "port-12345.json"),
+        JSON.stringify({
+            pid: 12345,
+            port: 43123,
+            started_at: Date.now(),
+            kind: "OpenCode server",
+        }),
+    );
+    let syncCalls = 0;
+    const slow = (() => {
+        syncCalls++;
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5000);
+        return "";
+    }) as typeof execFileSync;
+    __setRpcIdentityTestHooks({
+        platform: "win32",
+        execFileSync: slow,
+        processListExecFileSync: slow,
+    });
+    let release!: (value: string) => void;
+    __setAsyncProcessProbeForTests(
+        () =>
+            new Promise<string>((resolve) => {
+                release = resolve;
+            }),
+    );
+    try {
+        const gate = createV2StorageGate({
+            open: () => openDatabaseAsync({ dbPath, busyTimeoutMs: 0 }),
+        });
+        const started = performance.now();
+        const boot = probeV2StorageAtBoot(gate);
+        const opening = gate.probe();
+        expect(
+            await Promise.race([
+                opening.then(() => "opened"),
+                new Promise<string>((resolve) => setTimeout(() => resolve("responsive"), 10)),
+            ]),
+        ).toBe("responsive");
+        expect(performance.now() - started).toBeLessThan(300);
+        expect(gate.current()).toBeUndefined();
+        release(
+            JSON.stringify([
+                {
+                    ProcessId: 12345,
+                    ParentProcessId: 1,
+                    CommandLine: "opencode serve",
+                    CreationDate: "2026-01-01T00:00:00Z",
+                },
+            ]),
+        );
+        expect(await opening).toBeUndefined();
+        expect(await boot).toBeUndefined();
+        expect(gate.reason()?.kind).toBe("migration_guard");
+        expect(getMigrationOnOpenRefusal()?.serverPids).toEqual([12345]);
+        expect(syncCalls).toBe(0);
+        const checked = new Database(dbPath);
+        expect(
+            checked.prepare("SELECT MAX(version) AS version FROM schema_migrations").get(),
+        ).toEqual({ version: LATEST_SUPPORTED_VERSION - 1 });
+        checked.close();
+    } finally {
+        seeded.close();
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+/**
+ * The shape of the Windows 11 report behind issue 584: an older OpenCode server
+ * was live, the process list came from tasklist (image names, no start times),
+ * and the boot guard logged the live PID as "not confirmed" and migrated the
+ * shared store underneath it.
+ */
+function seedOlderStoreWithLiveServer(pid: number): { root: string; dbPath: string } {
+    const root = createTestTempDirFromPath(join(tmpdir(), "async-storage-tasklist-"));
+    const dbPath = join(root, "context.db");
+    const seeded = new Database(dbPath);
+    seeded.exec(
+        `CREATE TABLE schema_migrations(version INTEGER PRIMARY KEY, description TEXT NOT NULL DEFAULT '', applied_at INTEGER NOT NULL DEFAULT 0); INSERT INTO schema_migrations VALUES(${LATEST_SUPPORTED_VERSION - 1}, '', 0)`,
+    );
+    seeded.close();
+    mkdirSync(join(root, "rpc", "project"), { recursive: true });
+    writeFileSync(
+        join(root, "rpc", "project", `port-${pid}-older.json`),
+        JSON.stringify({
+            pid,
+            port: 52206,
+            started_at: Date.now() - 60_000,
+            kind: "OpenCode server",
+        }),
+    );
+    return { root, dbPath };
+}
+
+/**
+ * Upstream (9dfc0c722) replaced the fallback that read a tasklist image as a
+ * confirmed host with proof-based identity: an unreadable start time plus an
+ * image that could still be a host stays "inconclusive", so the boot guard
+ * logs a warning and continues the migration instead of refusing it.
+ */
+test("Windows boot migrates with a warning when a tasklist-only opencode image stays unconfirmed", async () => {
+    const pid = 10376;
+    const { root, dbPath } = seedOlderStoreWithLiveServer(pid);
+    __setRpcIdentityTestHooks({ platform: "win32" });
+    const probes: string[] = [];
+    __setAsyncProcessProbeForTests(async (file) => {
+        probes.push(file);
+        if (file === "powershell") throw new Error("powershell unavailable");
+        return `"opencode.exe","${pid}","Console","1","412,000 K"\r\n"explorer.exe","4242","Console","1","90,000 K"\r\n`;
+    });
+    try {
+        const db = await openDatabaseAsync({ dbPath, busyTimeoutMs: 0 });
+        expect(db).not.toBeNull();
+        db?.close();
+        expect(probes).toEqual(["powershell", "tasklist"]);
+        expect(getMigrationOnOpenRefusal()).toBeNull();
+        const checked = new Database(dbPath);
+        expect(
+            checked.prepare("SELECT MAX(version) AS version FROM schema_migrations").get(),
+        ).toEqual({ version: LATEST_SUPPORTED_VERSION });
+        checked.close();
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test("Windows PowerShell 5.1 wrapped creation dates still prove a holder's identity", async () => {
+    __setRpcIdentityTestHooks({ platform: "win32" });
+    __setAsyncProcessProbeForTests(async () =>
+        JSON.stringify([
+            {
+                ProcessId: 10376,
+                ParentProcessId: 1,
+                Name: "opencode.exe",
+                CommandLine: "opencode.exe",
+                CreationDate: {
+                    value: "/Date(1790763300123)/",
+                    DisplayHint: 2,
+                    DateTime: "Wednesday, September 30, 2026 12:15:00 PM",
+                },
+            },
+            {
+                ProcessId: 10377,
+                ParentProcessId: 1,
+                Name: "opencode.exe",
+                CommandLine: "opencode.exe",
+                CreationDate: "2026-09-30T10:15:00.1234567Z",
+            },
+        ]),
+    );
+    const result = await inspectProcessesAsync();
+    expect(result.evidence(10376).startTime).toBe(1790763300123);
+    expect(result.evidence(10377).startTime).toBe(1790763300123);
+});
+
+test("a timed-out refresh retains confirmed blockers until a successful process scan", async () => {
+    let now = 1000;
+    __setRpcIdentityTestHooks({ platform: "win32", nowMs: () => now });
+    let fail = false;
+    let calls = 0;
+    let pid = 12345;
+    __setAsyncProcessProbeForTests(async () => {
+        calls++;
+        if (fail) throw new Error("timeout");
+        return JSON.stringify([
+            {
+                ProcessId: pid,
+                ParentProcessId: 1,
+                CommandLine: "opencode serve",
+                CreationDate: "2026-01-01T00:00:00Z",
+            },
+        ]);
+    });
+    const first = await inspectProcessesAsync();
+    now += 1999;
+    expect(await inspectProcessesAsync()).toBe(first);
+    expect(calls).toBe(1);
+    now++;
+    fail = true;
+    const failed = await inspectProcessesAsync();
+    expect(calls).toBe(3);
+    expect(failed.liveness(12345)).toBe("alive");
+    expect(failed.liveness(54321)).toBe("inconclusive");
+    expect(failed.evidence(12345)).toEqual(first.evidence(12345));
+    now += 2000;
+    fail = false;
+    pid = 54321;
+    const refreshed = await inspectProcessesAsync();
+    expect(calls).toBe(4);
+    expect(refreshed.liveness(12345)).toBe("dead");
+});