@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/src/shared/harness-provider-map.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, it } from "bun:test";
+import {
+    canonicalModelIdentity,
+    modelRefLookupOrder,
+    ompModelRefToCanonical,
+    piModelRefToCanonical,
+    resolveModelRefForOmp,
+    resolveModelRefForPi,
+} from "./harness-provider-map";
+
+describe("harness-provider-map", () => {
+    describe("canonicalModelIdentity", () => {
+        it("collapses Astra route aliases without changing unrelated Copilot models", () => {
+            for (const ref of [
+                "openai/gpt-6-astra",
+                "openai-codex/gpt-6-astra",
+                "github-copilot/gpt-6-astra",
+            ]) {
+                expect(canonicalModelIdentity(ref)).toBe("openai/gpt-6-astra");
+            }
+            expect(canonicalModelIdentity("github-copilot/claude-opus-5")).toBe(
+                "github-copilot/claude-opus-5",
+            );
+        });
+    });
+
+    describe("resolveModelRefForPi (canonical -> Pi, used when spawning)", () => {
+        it("maps the diverging auth-plugin providers, preserving the model id", () => {
+            expect(resolveModelRefForPi("openai/gpt-5.5")).toBe("openai-codex/gpt-5.5");
+            expect(resolveModelRefForPi("google/antigravity-gemini-3.5-flash")).toBe(
+                "google-antigravity/antigravity-gemini-3.5-flash",
+            );
+        });
+
+        it("leaves anthropic and every other provider unchanged", () => {
+            expect(resolveModelRefForPi("anthropic/claude-opus-4-8")).toBe(
+                "anthropic/claude-opus-4-8",
+            );
+            expect(resolveModelRefForPi("cerebras/gpt-oss-120b")).toBe("cerebras/gpt-oss-120b");
+            expect(resolveModelRefForPi("openrouter/openai/gpt-5.5")).toBe(
+                "openrouter/openai/gpt-5.5",
+            );
+        });
+
+        it("is idempotent: a config already in Pi form still resolves to Pi form", () => {
+            expect(resolveModelRefForPi("openai-codex/gpt-5.5")).toBe("openai-codex/gpt-5.5");
+            expect(resolveModelRefForPi("google-antigravity/antigravity-gemini-3.1-pro")).toBe(
+                "google-antigravity/antigravity-gemini-3.1-pro",
+            );
+        });
+
+        it("preserves model ids that themselves contain slashes", () => {
+            expect(resolveModelRefForPi("openai/some/nested/id")).toBe(
+                "openai-codex/some/nested/id",
+            );
+        });
+
+        it("passes through malformed refs (no slash, empty provider) unchanged", () => {
+            expect(resolveModelRefForPi("gpt-5.5")).toBe("gpt-5.5");
+            expect(resolveModelRefForPi("/gpt-5.5")).toBe("/gpt-5.5");
+            expect(resolveModelRefForPi("")).toBe("");
+        });
+    });
+
+    describe("piModelRefToCanonical (Pi -> canonical, used by Pi setup write)", () => {
+        it("normalizes Pi-native provider ids to the OpenCode form", () => {
+            expect(piModelRefToCanonical("openai-codex/gpt-5.5")).toBe("openai/gpt-5.5");
+            expect(piModelRefToCanonical("google-antigravity/antigravity-gemini-3.5-flash")).toBe(
+                "google/antigravity-gemini-3.5-flash",
+            );
+        });
+
+        it("leaves already-canonical and unmapped providers unchanged", () => {
+            expect(piModelRefToCanonical("anthropic/claude-opus-4-8")).toBe(
+                "anthropic/claude-opus-4-8",
+            );
+            expect(piModelRefToCanonical("openai/gpt-5.5")).toBe("openai/gpt-5.5");
+        });
+
+        it("round-trips with resolveModelRefForPi", () => {
+            const piForm = "openai-codex/gpt-5.5";
+            expect(resolveModelRefForPi(piModelRefToCanonical(piForm))).toBe(piForm);
+        });
+
+        describe("modelRefLookupOrder (config read edge)", () => {
+            it("tries canonical before the Pi-native spelling", () => {
+                expect(modelRefLookupOrder("openai-codex/gpt-5.6-sol")).toEqual([
+                    "openai/gpt-5.6-sol",
+                    "openai-codex/gpt-5.6-sol",
+                ]);
+                expect(modelRefLookupOrder("openai/gpt-5.6-sol")).toEqual([
+                    "openai/gpt-5.6-sol",
+                    "openai-codex/gpt-5.6-sol",
+                ]);
+            });
+
+            it("keeps unknown provider prefixes as a single passthrough key", () => {
+                expect(modelRefLookupOrder("custom-provider/model")).toEqual([
+                    "custom-provider/model",
+                ]);
+            });
+        });
+    });
+});
+
+describe("OMP provider boundary", () => {
+    const representativeRefs = [
+        ["openai/gpt-5.5", "openai-codex/gpt-5.5"],
+        ["google/antigravity/gemini-3.5-flash", "google-antigravity/antigravity/gemini-3.5-flash"],
+        ["anthropic/claude-opus-4-8", "anthropic/claude-opus-4-8"],
+        ["@scope/provider/nested/model", "@scope/provider/nested/model"],
+    ] as const;
+
+    it.each(
+        representativeRefs,
+    )("round-trips canonical %s through OMP selector %s", (canonical, omp) => {
+        expect(resolveModelRefForOmp(canonical)).toBe(omp);
+        expect(ompModelRefToCanonical(omp)).toBe(canonical);
+    });
+
+    it("normalizes an already-native OMP selector idempotently", () => {
+        const selector = "openai-codex/team/nested/gpt-5.5";
+        expect(resolveModelRefForOmp(selector)).toBe(selector);
+        expect(resolveModelRefForOmp(ompModelRefToCanonical(selector))).toBe(selector);
+    });
+
+    it("translates the OpenCode Zen gateway (opencode) to OMP's opencode-zen spelling", () => {
+        expect(resolveModelRefForOmp("opencode/deepseek-v4-flash-free")).toBe(
+            "opencode-zen/deepseek-v4-flash-free",
+        );
+        expect(ompModelRefToCanonical("opencode-zen/deepseek-v4-flash-free")).toBe(
+            "opencode/deepseek-v4-flash-free",
+        );
+    });
+
+    it("resolves an opencode/ shared ref on OMP via modelRefLookupOrder", () => {
+        expect(modelRefLookupOrder("opencode/deepseek-v4-flash-free")).toEqual([
+            "opencode/deepseek-v4-flash-free",
+            "opencode-zen/deepseek-v4-flash-free",
+        ]);
+        expect(modelRefLookupOrder("opencode-zen/deepseek-v4-flash-free")).toEqual([
+            "opencode/deepseek-v4-flash-free",
+            "opencode-zen/deepseek-v4-flash-free",
+        ]);
+    });
+
+    it("leaves the OpenCode Zen gateway unchanged on plain Pi (Pi uses opencode)", () => {
+        expect(resolveModelRefForPi("opencode/deepseek-v4-flash-free")).toBe(
+            "opencode/deepseek-v4-flash-free",
+        );
+        expect(piModelRefToCanonical("opencode/deepseek-v4-flash-free")).toBe(
+            "opencode/deepseek-v4-flash-free",
+        );
+    });
+
+    it("keeps opencode-go unmapped on both harnesses (distinct gateway)", () => {
+        expect(resolveModelRefForOmp("opencode-go/kimi-k2.6")).toBe("opencode-go/kimi-k2.6");
+        expect(ompModelRefToCanonical("opencode-go/kimi-k2.6")).toBe("opencode-go/kimi-k2.6");
+        expect(resolveModelRefForPi("opencode-go/kimi-k2.6")).toBe("opencode-go/kimi-k2.6");
+        expect(piModelRefToCanonical("opencode-go/kimi-k2.6")).toBe("opencode-go/kimi-k2.6");
+    });
+
+    it("passes through provider ids that collide with Object.prototype members", () => {
+        for (const ref of [
+            "constructor/model",
+            "toString/model",
+            "__proto__/model",
+            "hasOwnProperty/model",
+        ]) {
+            expect(resolveModelRefForOmp(ref)).toBe(ref);
+            expect(ompModelRefToCanonical(ref)).toBe(ref);
+            expect(resolveModelRefForPi(ref)).toBe(ref);
+            expect(piModelRefToCanonical(ref)).toBe(ref);
+        }
+    });
+});

package/src/shared/harness-provider-map.ts

@@ -0,0 +1,130 @@
+/**
+ * Provider-id translation between the canonical (OpenCode) form stored in the
+ * shared magic-context config and Pi's harness-native provider ids.
+ *
+ * Provider IDs are a harness boundary, not a database identity. Shared config
+ * always stores the canonical OpenCode form. Each non-OpenCode harness owns an
+ * explicit pair of edge transforms:
+ *
+ *   canonical (OpenCode)   Pi / OMP selector
+ *   --------------------   -----------------
+ *   openai/<model>         openai-codex/<model>
+ *   google/<model>         google-antigravity/<model>
+ *   anthropic/<model>      anthropic/<model> (same; every other provider too)
+ *
+ * Pi and OMP currently expose the same two subscription-provider aliases, but
+ * their exported functions remain distinct deliberately. A future OMP catalog
+ * rename must not silently change plain-Pi behavior (or vice versa).
+ *
+ * The OpenCode Zen gateway is the one place the two harnesses diverge: OpenCode
+ * and plain Pi both name it `opencode`, while OMP exposes the same gateway as
+ * `opencode-zen`. Only the OMP map carries that pair; plain Pi keeps `opencode`
+ * as an identity. `opencode-go` is a distinct gateway (the "go" variant at
+ * opencode.ai/zen/go) and stays unmapped on both harnesses.
+ *
+ * The mapping is intentionally not a one-to-one provider identity. Both
+ * harnesses also expose plain `openai` and `google` providers for direct API
+ * keys, while the canonical prefix does not record whether a subscription or
+ * API-key backend should win. The runtime starts with the preferred
+ * subscription form and subagent-runner may retry once with the untranslated
+ * canonical form when that form reports missing credentials.
+ *
+ * Only the provider prefix before the first slash is translated. Model IDs,
+ * including nested IDs containing more slashes, are preserved byte-for-byte.
+ * Scoped or otherwise unknown provider prefixes are identities.
+ *
+ * OpenCode needs no translation because canonical is its native form.
+ */
+
+const CANONICAL_TO_PI_PROVIDER: Readonly<Record<string, string>> = {
+    openai: "openai-codex",
+    google: "google-antigravity",
+};
+
+const PI_TO_CANONICAL_PROVIDER: Readonly<Record<string, string>> = {
+    "openai-codex": "openai",
+    "google-antigravity": "google",
+};
+
+const CANONICAL_TO_OMP_PROVIDER: Readonly<Record<string, string>> = {
+    openai: "openai-codex",
+    google: "google-antigravity",
+    opencode: "opencode-zen",
+};
+
+const OMP_TO_CANONICAL_PROVIDER: Readonly<Record<string, string>> = {
+    "openai-codex": "openai",
+    "google-antigravity": "google",
+    "opencode-zen": "opencode",
+};
+
+const CANONICAL_MODEL_IDENTITY_ALIASES: Readonly<Record<string, string>> = {
+    "github-copilot/gpt-6-astra": "openai/gpt-6-astra",
+};
+
+/** Remap only the provider prefix (text before the first "/"), preserving the
+ *  model id verbatim. No "/", empty provider, or unmapped provider -> unchanged.
+ *  Lookups are own-property only, so provider ids that collide with
+ *  `Object.prototype` members (`constructor/model`, `toString/model`) stay
+ *  identities instead of becoming garbage prefixes. */
+function remapProviderPrefix(ref: string, map: Readonly<Record<string, string>>): string {
+    if (typeof ref !== "string") return ref;
+    const slash = ref.indexOf("/");
+    if (slash <= 0) return ref;
+    const provider = ref.slice(0, slash);
+    if (!Object.hasOwn(map, provider)) return ref;
+    return `${map[provider]}${ref.slice(slash)}`;
+}
+
+/**
+ * Canonicalize only for identity comparisons and cache policy; callers must not
+ * use the result as a provider spawn route. Provider-wide Pi/OMP aliases are
+ * normalized first; model-specific aliases stay explicit because GitHub Copilot
+ * also serves non-OpenAI model families.
+ */
+export function canonicalModelIdentity(ref: string): string {
+    const harnessCanonical = piModelRefToCanonical(ompModelRefToCanonical(ref));
+    return CANONICAL_MODEL_IDENTITY_ALIASES[harnessCanonical.toLowerCase()] ?? harnessCanonical;
+}
+
+/** Pi-native `provider/model` -> canonical (OpenCode). Identity when unmapped.
+ *  Used by the Pi setup wizard so configs it writes stay OpenCode-readable. */
+export function piModelRefToCanonical(ref: string): string {
+    return remapProviderPrefix(ref, PI_TO_CANONICAL_PROVIDER);
+}
+
+/** Canonical (OpenCode) `provider/model` -> Pi-native, for spawning a model on
+ *  Pi. Idempotent: normalizes any Pi-form prefix back to canonical first, so it
+ *  is safe on a config that already holds Pi-form ids (hand-edited or pre-fix). */
+export function resolveModelRefForPi(ref: string): string {
+    return remapProviderPrefix(piModelRefToCanonical(ref), CANONICAL_TO_PI_PROVIDER);
+}
+
+/**
+ * Return every known spelling of a model reference with the canonical shared
+ * form first. The raw input remains the first fallback, so a single config file
+ * works on every harness: canonical wins when both spellings are present, while
+ * Pi/OMP-native provider ids are still accepted at the read edge. Unknown
+ * providers pass through unchanged and therefore produce one candidate.
+ */
+export function modelRefLookupOrder(ref: string): string[] {
+    const canonical = piModelRefToCanonical(ompModelRefToCanonical(ref));
+    return [
+        ...new Set([
+            canonical,
+            ref,
+            resolveModelRefForPi(canonical),
+            resolveModelRefForOmp(canonical),
+        ]),
+    ];
+}
+
+/** OMP-native selector -> canonical shared-config model reference. */
+export function ompModelRefToCanonical(ref: string): string {
+    return remapProviderPrefix(ref, OMP_TO_CANONICAL_PROVIDER);
+}
+
+/** Canonical shared-config model reference -> OMP-native selector. */
+export function resolveModelRefForOmp(ref: string): string {
+    return remapProviderPrefix(ompModelRefToCanonical(ref), CANONICAL_TO_OMP_PROVIDER);
+}

package/src/shared/harness.ts

@@ -0,0 +1,76 @@
+/**
+ * Identifier for the host harness this plugin is running inside.
+ *
+ * Magic Context's SQLite database lives at a vendor-scoped path
+ * (`~/.local/share/mmc/`) so OpenCode and Pi can share
+ * project memories, embedding cache, and other project-scoped
+ * state. Session-scoped tables carry a `harness` column populated from this
+ * module so we can disambiguate which harness wrote each session row,
+ * filter by harness in the dashboard, and (eventually) migrate sessions
+ * between harnesses.
+ *
+ * Each plugin entry point sets this once at boot, before any DB write
+ * happens:
+ * - OpenCode plugin: relies on the default ("opencode") — no setHarness call
+ *   needed
+ * - OpenCode 2 plugin: calls `setHarness("opencode2")` before opening the database
+ * - Pi-compatible plugin: resolves the host and calls `setHarness("pi")` before opening the database
+ *
+ * NEVER read this from configuration or session state — it is a
+ * boot-time constant per plugin instance. Cross-harness leakage is a
+ * correctness bug, not a feature.
+ */
+export type HarnessId = "opencode" | "opencode2" | "pi";
+
+let currentHarness: HarnessId = "opencode";
+let harnessLocked = false;
+
+/**
+ * Set the harness identifier for this plugin instance. Must be called once
+ * at boot before any DB write happens. Subsequent calls with a different
+ * value throw to prevent accidental mid-session swaps that would corrupt
+ * the harness column and break per-harness session scoping.
+ *
+ * Calling with the same value as the current is a no-op (safe to call
+ * defensively).
+ */
+export function setHarness(value: HarnessId): void {
+    if (harnessLocked && currentHarness !== value) {
+        throw new Error(
+            `Magic Context: harness already locked to "${currentHarness}"; cannot change to "${value}"`,
+        );
+    }
+    currentHarness = value;
+    harnessLocked = true;
+}
+
+/**
+ * Get the current harness identifier. Used by storage modules when
+ * INSERTing session-scoped rows so each row is correctly attributed.
+ */
+export function getHarness(): HarnessId {
+    return currentHarness;
+}
+
+/**
+ * Whether this process may read OpenCode's own session store (opencode.db).
+ *
+ * Only the OpenCode plugins own that store. A Pi process keeps its history in
+ * Pi JSONL sessions and shares only Magic Context's context.db with OpenCode.
+ * Any history read in a Pi process for a session with no Pi provider used to
+ * fall through to opencode.db, which let background work load another project's
+ * OpenCode sessions into Pi's heap. Pi therefore treats the OpenCode store as
+ * absent, the same as on a Pi-only install.
+ */
+export function harnessOwnsOpenCodeStore(harness: HarnessId = currentHarness): boolean {
+    return harness === "opencode" || harness === "opencode2";
+}
+
+/**
+ * Test-only helper to reset harness state between test cases. Do NOT call
+ * from production code paths.
+ */
+export function _resetHarnessForTesting(): void {
+    currentHarness = "opencode";
+    harnessLocked = false;
+}

package/src/shared/hidden-variant-warnings.ts

@@ -0,0 +1,21 @@
+const warnings = new Map<string, string>();
+
+/** Remember a host catalog mismatch until the process exits so status can show it once. */
+export function recordHiddenVariantWarning(
+    providerID: string,
+    modelID: string,
+    variant: string,
+): string {
+    const key = `${providerID}/${modelID}:${variant}`;
+    const message = `variant '${variant}' not offered by ${providerID}/${modelID} on this host; running without it`;
+    warnings.set(key, message);
+    return message;
+}
+
+export function listHiddenVariantWarnings(): string[] {
+    return [...warnings.values()];
+}
+
+export function clearHiddenVariantWarningsForTest(): void {
+    warnings.clear();
+}

package/src/shared/historian-tool-defaults.json

@@ -0,0 +1,13 @@
+{
+  "todowrite": "Todos (${input.todos.count}): ${input.todos.each(\"${status}: ${content}\")}",
+  "question": "Asked user: ${input.questions[*].question.join(\" / \")} → ${output}",
+  "task": "Task ${input.subagent_type}: ${input.prompt} → ${output.truncate(200)}",
+  "ask": "Asked: ${input.question.truncate(250)} [options: ${input.options.join(\" / \")}] ${input.resolution} → ${output.truncate(300)}",
+  "peer_send": "PM to ${input.agent}${input.agent_id}: ${input.message.truncate(400)}",
+  "board": "Board ${input.verb}: ${input.ops.each(\"${op} ${item}${lane.title} ${state}${lane.status}${props.text} ${lane.items[*].text}\")}",
+  "room": "Room ${input.action} ${input.room_id}: ${input.text.truncate(400)}",
+  "work": "Work ${input.action} ${input.id}: ${input.prompt_file}${input.prompt.truncate(200)}${input.notes.truncate(200)} → ${output.truncate(160)}",
+  "knowhow": "Looked up how-to: ${input.query}${input.id}",
+  "mmc_note": "Note ${input.action} ${input.note_ids}: ${input.content} → ${output.truncate(160)}",
+  "mmc_memory": "Memory ${input.action} ${input.category} ${input.ids}: ${input.content} → ${output.truncate(160)}"
+}

package/src/shared/historian-tool-expansions.ts

@@ -0,0 +1,18 @@
+import defaults from "./historian-tool-defaults.json";
+import { renderToolTemplate, type ToolExpansionMap } from "./historian-tool-template";
+
+export { defaults as DEFAULT_TOOL_EXPANSIONS };
+export function expandToolPart(part: unknown, overrides?: ToolExpansionMap): string | null {
+    if (!part || typeof part !== "object") return null;
+    const p = part as Record<string, unknown>;
+    if (p.type !== "tool" || typeof p.tool !== "string") return null;
+    const template =
+        overrides && Object.hasOwn(overrides, p.tool)
+            ? overrides[p.tool]
+            : Object.hasOwn(defaults, p.tool)
+              ? defaults[p.tool as keyof typeof defaults]
+              : undefined;
+    if (typeof template !== "string") return null;
+    const state = p.state as Record<string, unknown> | undefined;
+    return renderToolTemplate(template, state?.input, state?.output ?? state?.error);
+}