@uniqbit/mate-core 0.18.1-canary.0 → 0.18.1-canary.2

package/src/cli/launch-selector.tsx

@@ -1,320 +1,2 @@
-import { Box, Text, render as inkRender } from "ink";
-import React, { useEffect } from "react";
-import { SelectMenu, type SelectMenuItem } from "../lib/components/select-menu";
-import { WizardFooter } from "../lib/components/wizard-footer";
-import { WizardHeader } from "../lib/components/wizard-header";
-
 export const LAUNCH_TARGETS = ["claude", "opencode"] as const;
 export type LaunchTarget = (typeof LAUNCH_TARGETS)[number];
-
-export interface LaunchPreviewData {
-  repositoryId: string;
-  repositoryPath: string;
-  companionPath: string;
-}
-
-export interface LaunchWizardResult {
-  target: LaunchTarget;
-  preview: LaunchPreviewData;
-}
-
-type WizardStep = "target" | "review";
-type PreviewState =
-  | { status: "idle" }
-  | { status: "loading" }
-  | { status: "ready"; data: LaunchPreviewData }
-  | { status: "error"; message: string };
-
-interface LaunchWizardAppProps {
-  activeIndex: number;
-  hasPreselectedTarget: boolean;
-  items: SelectMenuItem[];
-  previewState: PreviewState;
-  selectedTarget: LaunchTarget | null;
-  step: WizardStep;
-  totalSteps: number;
-  onMounted?: () => void;
-}
-
-export interface LaunchWizardOptions {
-  stdin?: NodeJS.ReadStream;
-  stdout?: NodeJS.WriteStream;
-  stderr?: NodeJS.WriteStream;
-  allowedTargets?: Set<string>;
-  preselectedTarget?: LaunchTarget;
-  resolvePreview(target: LaunchTarget): Promise<LaunchPreviewData>;
-}
-
-const launchSelectorDeps = {
-  render: inkRender,
-};
-
-const TARGET_ITEMS: SelectMenuItem[] = [
-  { key: "claude", label: "claude" },
-  { key: "opencode", label: "opencode" },
-];
-
-function parseLaunchSelectorInput(
-  input: string,
-): "submit" | "cancel" | "up" | "down" | "back" | null {
-  if (input === "\r" || input === "\n") return "submit";
-  if (input === "\x1b[A" || input === "[A") return "up";
-  if (input === "\x1b[B" || input === "[B") return "down";
-  if (input === "\x7f" || input === "\b") return "back";
-  if (input === "\x1b" || input.toLowerCase() === "q") return "cancel";
-  return null;
-}
-
-function ReviewPanel({
-  previewState,
-  selectedTarget,
-}: {
-  previewState: PreviewState;
-  selectedTarget: LaunchTarget | null;
-}) {
-  if (previewState.status === "loading" || previewState.status === "idle") {
-    return <Text dimColor>Resolving launch preview…</Text>;
-  }
-
-  if (previewState.status === "error") {
-    return <Text color="red">{previewState.message}</Text>;
-  }
-
-  return (
-    <Box flexDirection="column">
-      <Text>Target: {selectedTarget}</Text>
-      <Text>Repository: {previewState.data.repositoryId}</Text>
-      <Text dimColor>{previewState.data.repositoryPath}</Text>
-      <Text>Companion:</Text>
-      <Text dimColor>{previewState.data.companionPath}</Text>
-    </Box>
-  );
-}
-
-function LaunchWizardApp({
-  activeIndex,
-  hasPreselectedTarget,
-  items,
-  previewState,
-  selectedTarget,
-  step,
-  totalSteps,
-  onMounted,
-}: LaunchWizardAppProps): React.JSX.Element {
-  useEffect(() => {
-    onMounted?.();
-  }, [onMounted]);
-
-  const stepNumber = hasPreselectedTarget ? 0 : step === "target" ? 0 : totalSteps - 1;
-  const title = step === "target" ? "Select launch target" : "Review launch";
-  const hint =
-    step === "target"
-      ? "↑↓ navigate · enter continue · q cancel"
-      : previewState.status === "error"
-        ? "enter retry · backspace previous · q cancel"
-        : previewState.status === "ready"
-          ? "enter launch · backspace previous · q cancel"
-          : "backspace previous · q cancel";
-
-  return (
-    <Box flexDirection="column" width="100%">
-      <WizardHeader title={title} step={stepNumber} totalSteps={totalSteps} />
-      <Box marginTop={1} flexDirection="column">
-        {step === "target" ? <SelectMenu items={items} activeIndex={activeIndex} /> : null}
-        {step === "review" ? (
-          <ReviewPanel previewState={previewState} selectedTarget={selectedTarget} />
-        ) : null}
-      </Box>
-      <WizardFooter hint={hint} />
-    </Box>
-  );
-}
-
-export async function runLaunchWizard(
-  options: LaunchWizardOptions,
-): Promise<LaunchWizardResult | null> {
-  const stdin = options.stdin ?? process.stdin;
-  const stdout = options.stdout ?? process.stdout;
-  const stderr = options.stderr ?? process.stderr;
-  if (!stdin.isTTY || !stdout.isTTY) {
-    throw new Error("Launch wizard requires a TTY.");
-  }
-
-  const allowedTargets = options.allowedTargets;
-  const preselectedTarget = options.preselectedTarget ?? null;
-  const items: SelectMenuItem[] = TARGET_ITEMS.map((item) => ({
-    ...item,
-    dimColor: allowedTargets ? !allowedTargets.has(item.key) : false,
-  }));
-  const firstEnabledIndex = items.findIndex((item) => !item.dimColor);
-  let activeIndex = preselectedTarget ? 0 : firstEnabledIndex < 0 ? 0 : firstEnabledIndex;
-  let step: WizardStep = preselectedTarget ? "review" : "target";
-  let selectedTarget: LaunchTarget | null = preselectedTarget;
-  let previewState: PreviewState = { status: "idle" };
-  let previewRequestId = 0;
-  let finalResult: LaunchWizardResult | null = null;
-  let resolved = false;
-  let rendered: ReturnType<typeof launchSelectorDeps.render> | undefined;
-
-  const totalSteps = preselectedTarget ? 1 : 2;
-
-  stdin.resume();
-  (stdin as NodeJS.ReadStream & { ref?: () => void }).ref?.();
-  const keepAlive = setInterval(() => {}, 1 << 30);
-
-  const cleanup = () => {
-    clearInterval(keepAlive);
-    stdin.off("data", onData);
-    stdin.pause();
-    stdin.setRawMode?.(false);
-    (stdin as NodeJS.ReadStream & { unref?: () => void }).unref?.();
-  };
-
-  const currentTarget = () => LAUNCH_TARGETS[activeIndex];
-  const isEnabled = (index: number) => !items[index]?.dimColor;
-  const nextEnabledIndex = (start: number, direction: 1 | -1): number => {
-    if (!items.some((item) => !item.dimColor)) return start;
-    let index = start;
-    for (let i = 0; i < items.length; i += 1) {
-      index = (index + direction + items.length) % items.length;
-      if (isEnabled(index)) return index;
-    }
-    return start;
-  };
-
-  const rerender = () => {
-    rendered?.rerender(
-      <LaunchWizardApp
-        activeIndex={activeIndex}
-        hasPreselectedTarget={!!preselectedTarget}
-        items={items}
-        previewState={previewState}
-        selectedTarget={selectedTarget}
-        step={step}
-        totalSteps={totalSteps}
-        onMounted={onMounted}
-      />,
-    );
-  };
-
-  const settle = (
-    value: LaunchWizardResult | null,
-    resolve: (value: LaunchWizardResult | null) => void,
-  ) => {
-    if (resolved) return;
-    resolved = true;
-    cleanup();
-    resolve(value);
-  };
-
-  const loadPreview = () => {
-    if (!selectedTarget) return;
-    const requestId = ++previewRequestId;
-    previewState = { status: "loading" };
-    rerender();
-
-    options
-      .resolvePreview(selectedTarget)
-      .then((preview) => {
-        if (requestId !== previewRequestId || resolved) return;
-        previewState = { status: "ready", data: preview };
-        rerender();
-      })
-      .catch((error: unknown) => {
-        if (requestId !== previewRequestId || resolved) return;
-        previewState = {
-          status: "error",
-          message: error instanceof Error ? error.message : String(error),
-        };
-        rerender();
-      });
-  };
-
-  const enterReview = () => {
-    step = "review";
-    loadPreview();
-  };
-
-  const onMounted = () => {
-    const buffered = stdin.read();
-    if (buffered) {
-      // Discard buffered input before the wizard becomes interactive.
-    }
-    stdin.on("data", onData);
-    if (step === "review") {
-      loadPreview();
-    }
-  };
-
-  const onData = (chunk: string) => {
-    const action = parseLaunchSelectorInput(chunk);
-    if (!action) return;
-    if (action === "cancel") {
-      finalResult = null;
-      rendered?.unmount();
-      return;
-    }
-    if (action === "back") {
-      if (step === "review") {
-        if (preselectedTarget) {
-          finalResult = null;
-          rendered?.unmount();
-        } else {
-          step = "target";
-          previewState = { status: "idle" };
-          rerender();
-        }
-        return;
-      }
-      return;
-    }
-    if (step === "review") {
-      if (action !== "submit") return;
-      if (previewState.status === "error") {
-        loadPreview();
-        return;
-      }
-      if (previewState.status !== "ready" || !selectedTarget) return;
-      finalResult = {
-        target: selectedTarget,
-        preview: previewState.data,
-      };
-      rendered?.unmount();
-      return;
-    }
-    if (action === "up" || action === "down") {
-      activeIndex = nextEnabledIndex(activeIndex, action === "up" ? -1 : 1);
-      rerender();
-      return;
-    }
-    if (action !== "submit") return;
-    if (!isEnabled(activeIndex)) return;
-    selectedTarget = currentTarget();
-    enterReview();
-  };
-
-  stdin.setEncoding("utf8");
-  stdin.setRawMode?.(true);
-
-  return new Promise<LaunchWizardResult | null>((resolve) => {
-    rendered = launchSelectorDeps.render(
-      <LaunchWizardApp
-        activeIndex={activeIndex}
-        hasPreselectedTarget={!!preselectedTarget}
-        items={items}
-        previewState={previewState}
-        selectedTarget={selectedTarget}
-        step={step}
-        totalSteps={totalSteps}
-        onMounted={onMounted}
-      />,
-      { stdin, stdout, stderr },
-    );
-
-    const finish = (value: LaunchWizardResult | null) => settle(value, resolve);
-
-    rendered.waitUntilExit().then(() => {
-      finish(finalResult);
-    });
-  });
-}

package/src/cli/main.ts

@@ -200,12 +200,6 @@ export async function main(argv = process.argv, deps: MainDeps = mainDeps): Prom
         case "prepare":
           if (!(await gate({ updateGuard: true }))) return;
           break;
-        // Hub commands establish and operate on a local hub root directly;
-        // they must not require a linked working repository or installation —
-        // but companions are never hubs.
-        case "hub":
-          if (!(await gate({ updateGuard: true, notCompanionRoot: true }))) return;
-          break;
         // open/tui/sync/update consume a companion context.
         case "open":
         case "tui":
@@ -252,29 +246,6 @@ export async function main(argv = process.argv, deps: MainDeps = mainDeps): Prom
         return;
       await runLaunchOpenCodeCommand(argv.slice(3), { directPassthrough: true });
       return;
-    case "launch": {
-      const launchArgs = argv.slice(4);
-      const companion = parseDirectLaunchArgs(launchArgs).scope === "companion";
-      if (subcommand !== "claude" && subcommand !== "opencode") {
-        console.error(`${FRAMEWORK_NAME}: expected launch claude or launch opencode.`);
-        process.exitCode = 1;
-        return;
-      }
-
-      const launchCommand =
-        subcommand === "claude" ? runLaunchClaudeCommand : runLaunchOpenCodeCommand;
-      if (
-        !(await gate({
-          updateGuard: true,
-          companion: companion ? { persistSelection: false } : true,
-          install: true,
-        }))
-      )
-        return;
-
-      await launchCommand(launchArgs, { directPassthrough: true });
-      return;
-    }
     case "report":
       if (!(await gate({ updateGuard: true, install: true }))) return;
       await runReportCommand(argv.slice(3));

package/src/cli/setup-selector.tsx

@@ -1,5 +1,5 @@
 import { Box, Text, render as inkRender } from "ink";
-import React, { useEffect } from "react";
+import { useEffect } from "react";
 
 import { SelectMenu, type SelectMenuItem } from "../lib/components/select-menu";
 import { WizardFooter } from "../lib/components/wizard-footer";

package/src/cli/usage.ts

@@ -42,7 +42,6 @@ export function usage(): string {
     ` ${n} cap graphify <subcommand> [args...]`,
     ` ${n} cap index [--graphify] [--tokensave]`,
     ` ${n} plugin install <package>[@version]`,
-    ` ${n} plugin verify`,
     ...pluginCliCommandLines(),
     ` ${n} update`,
     ` ${n} update --check`,

package/src/hooks/session-banner.ts

@@ -30,12 +30,12 @@ export const PROJECTED_BANNER_FLAG = "--projected";
  * With `mate doctor` out of scope this is one of only two surfaces where a
  * drifted wrap becomes visible, so staleness is reported, never suppressed.
  */
-export function buildBanner(
+export async function buildBanner(
   env: HookEnv,
   cwd: string = process.cwd(),
   argv: readonly string[] = [],
   syncOptions: UnattendedSyncOptions = {},
-): BannerOutcome {
+): Promise<BannerOutcome> {
   if (argv.includes(PROJECTED_BANNER_FLAG) && hasLaunchEnvironment(env)) {
     return { exitCode: 0, stdout: "" };
   }
@@ -52,7 +52,9 @@ export function buildBanner(
    */
   const gitNotes = hasLaunchEnvironment(env)
     ? []
-    : unattendedSyncStalenessLines(syncCompanionUnattended(context.companionPath, syncOptions));
+    : unattendedSyncStalenessLines(
+        await syncCompanionUnattended(context.companionPath, syncOptions),
+      );
 
   const lines = [
     `mate v${env.MATE_VERSION || mateVersion()}`,
@@ -71,8 +73,8 @@ export function buildBanner(
 }
 
 // Plugin-shim entry.
-export function run(argv: readonly string[] = process.argv.slice(2)): number {
-  const outcome = buildBanner(process.env, process.cwd(), argv);
+export async function run(argv: readonly string[] = process.argv.slice(2)): Promise<number> {
+  const outcome = await buildBanner(process.env, process.cwd(), argv);
   if (outcome.stdout) process.stdout.write(outcome.stdout);
   return outcome.exitCode;
 }

package/src/hooks/validate-artifact-path.ts

@@ -12,6 +12,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
+import { gitEnvironment } from "../runtime/companion-git";
 import { companionForkRefusal } from "../runtime/companion-sync";
 import { readCompanionRuntimeContext } from "../runtime/env";
 import { companionLinkPath } from "../runtime/repo-local";
@@ -143,6 +144,7 @@ function isGitignored(target: string, ctx: GuardContext): boolean {
   const relPath = path.relative(root, target);
   const result = spawnSync("git", ["-C", root, "check-ignore", "--no-index", "-q", "--", relPath], {
     stdio: "ignore",
+    env: gitEnvironment(),
   });
   return result.status === 0;
 }
@@ -156,6 +158,7 @@ function isGitTracked(target: string, ctx: GuardContext): boolean {
   const relPath = path.relative(root, target);
   const result = spawnSync("git", ["-C", root, "ls-files", "--error-unmatch", "--", relPath], {
     stdio: "ignore",
+    env: gitEnvironment(),
   });
   return result.status === 0;
 }
@@ -226,11 +229,14 @@ function checkFilePath(
  * gated on the absence of a launch environment, and the path refusal keeps its
  * input-only verdict and its double-load tolerance untouched.
  */
-function checkForkedCompanion(filePath: string, ctx: GuardContext): HookOutcome | null {
+async function checkForkedCompanion(
+  filePath: string,
+  ctx: GuardContext,
+): Promise<HookOutcome | null> {
   if (!filePath || !artifactLikePath(filePath)) return null;
   if (!isCompanionPath(normalizePath(filePath, ctx), ctx)) return null;
 
-  const refusal = companionForkRefusal(ctx.env, ctx.companion);
+  const refusal = await companionForkRefusal(ctx.env, ctx.companion);
   return refusal ? { exitCode: 2, stderr: `${refusal}\n` } : null;
 }
 
@@ -250,7 +256,11 @@ export function commandMatches(command: string): string[] {
  * Fails open only when no Mate context resolves from either source; in a
  * wrapped Working Repository the guard runs without a launch.
  */
-export function evaluate(payload: unknown, env: HookEnv, cwd: string = process.cwd()): HookOutcome {
+export async function evaluate(
+  payload: unknown,
+  env: HookEnv,
+  cwd: string = process.cwd(),
+): Promise<HookOutcome> {
   const allow: HookOutcome = { exitCode: 0, stderr: "" };
 
   const ctx = guardContext(env, cwd);
@@ -267,7 +277,7 @@ export function evaluate(payload: unknown, env: HookEnv, cwd: string = process.c
     const filePath = String(toolInput.file_path ?? "");
     /** The path refusal wins when both apply: its message is not replaced. */
     const outcome = checkFilePath(filePath, ctx, toolName === "Edit" || toolName === "MultiEdit");
-    return outcome ?? checkForkedCompanion(filePath, ctx) ?? allow;
+    return outcome ?? (await checkForkedCompanion(filePath, ctx)) ?? allow;
   }
 
   if (toolName === "Bash") {
@@ -278,7 +288,8 @@ export function evaluate(payload: unknown, env: HookEnv, cwd: string = process.c
       if (outcome) return outcome;
     }
     for (const target of targets) {
-      const outcome = checkForkedCompanion(target, ctx);
+      // oxlint-disable-next-line no-await-in-loop -- the first refusal wins
+      const outcome = await checkForkedCompanion(target, ctx);
       if (outcome) return outcome;
     }
     return allow;
@@ -303,7 +314,7 @@ export async function run(): Promise<number> {
   } catch {
     payload = {};
   }
-  const outcome = evaluate(payload, process.env);
+  const outcome = await evaluate(payload, process.env);
   if (outcome.stderr) process.stderr.write(outcome.stderr);
   return outcome.exitCode;
 }

package/src/lib/opencode-plugin-package.ts

@@ -5,24 +5,18 @@ import path from "node:path";
 
 import { isPreinstalledPluginPath } from "./preinstalled-plugins";
 import { PUBLIC_NPM_REGISTRY } from "./public-npm";
-import { getCurrentVersion } from "./update-checker";
 
-export const OPENCODE_PLUGIN_PACKAGE_NAME = "@uniqbit/mate-opencode-plugin";
+/** The retired plugin package, bundled into mate-core as `opencode-plugin/`. */
+const OPENCODE_PLUGIN_PACKAGE_NAME = "@uniqbit/mate-opencode-plugin";
 
 /**
- * The plugin package reference configured for OpenCode. All public Mate
- * packages are released in lockstep with synchronized versions, so the pinned
- * plugin version is derived from the CLI's own version instead of a separate
- * compatibility range.
+ * Matches a reference to the retired plugin package: the published spec,
+ * a versioned spec, or a path bound to an installed copy. Only for stripping
+ * entries older releases wrote into committed config.
  */
-export function getOpenCodePluginPackageReference(version: string = getCurrentVersion()): string {
-  return `${OPENCODE_PLUGIN_PACKAGE_NAME}@${version}`;
-}
-
-/** Matches the published reference and a reference bound to an installed copy alike. */
-export function isMateOpenCodePluginReference(value: unknown): boolean {
+export function isLegacyMateOpenCodePluginReference(value: unknown): boolean {
   if (typeof value === "object" && value !== null && !Array.isArray(value) && "package" in value) {
-    return isMateOpenCodePluginReference(value.package);
+    return isLegacyMateOpenCodePluginReference(value.package);
   }
   if (typeof value !== "string") return false;
   if (
@@ -85,18 +79,3 @@ export async function warmOpenCodePackageCache(
     return { ok: false, detail: (error as Error).message };
   }
 }
-
-/**
- * Pre-fetch the pinned plugin package into OpenCode's npm plugin environment
- * (`<cache>/packages/<spec>/`), mirroring OpenCode's own on-demand install
- * layout, so the first managed launch after a setup or update does not depend
- * on registry access. Best effort: failures are reported, never thrown.
- */
-export async function warmOpenCodePluginCache(
-  version: string = getCurrentVersion(),
-  env: NodeJS.ProcessEnv = process.env,
-  registry = PUBLIC_NPM_REGISTRY,
-): Promise<WarmPluginCacheResult> {
-  const reference = getOpenCodePluginPackageReference(version);
-  return warmOpenCodePackageCache(OPENCODE_PLUGIN_PACKAGE_NAME, reference, env, registry);
-}

package/src/lib/orchestrator/adapters/opencode.ts

@@ -7,14 +7,8 @@ const path = await import("node:path");
 import { MATE_ENV } from "../../../runtime/env";
 import { validateGuidanceData, type MateGuidanceFile } from "../../../runtime/guidance";
 
+import { getOpenCodePluginRoot, validateOpenCodePluginAssets } from "../../package-paths";
 import {
-  getOpenCodePluginPackageReference,
-  isMateOpenCodePluginReference,
-  OPENCODE_PLUGIN_PACKAGE_NAME,
-} from "../../opencode-plugin-package";
-import { installedVersionAt, isPreinstalledPluginPath } from "../../preinstalled-plugins";
-import {
-  getOpenCodePluginReferences,
   mergeOpenCodeConfigContent,
   readOpenCodeConfig,
 } from "../../../tools/setup/providers/opencode-format";
@@ -86,6 +80,7 @@ export class OpenCodeAdapter extends LaunchAdapter {
       OPENCODE_CONFIG_CONTENT: mergeOpenCodeConfigContent(
         {
           permissions: renderCompanionExternalDirectoryPermissions(context.companionPath),
+          plugins: [getOpenCodePluginRoot()],
           references: {
             mate: context.companionPath,
           },
@@ -130,75 +125,41 @@ export class OpenCodeAdapter extends LaunchAdapter {
       );
     }
 
-    const expectedPluginReference = getOpenCodePluginPackageReference();
-    const errors: string[] = [
-      ...(await this.validatePluginReference(
-        context,
-        path.join(".opencode", "opencode.json"),
-        expectedPluginReference,
-      )),
+    /** Asset errors carry their own reinstall hint; only companion errors are repaired by setup. */
+    const assetErrors = this.validatePluginAssets();
+    const companionErrors = [
+      ...(await this.validateConfigReadable(context)),
       ...this.validateGuidance(context),
     ];
-    if (errors.length > 0) {
-      throw new LaunchPreflightError(
-        [
-          "OpenCode companion runtime is invalid.",
-          ...errors.map((error) => `- ${error}`),
-          `Expected Mate plugin package: ${expectedPluginReference}`,
-          "Repair the companion runtime by re-running `mate companion setup` in the companion repository or `mate opencode` from the working repository.",
-        ].join("\n"),
+    const errors = [...assetErrors, ...companionErrors];
+    if (errors.length === 0) return;
+
+    const lines = [
+      "OpenCode companion runtime is invalid.",
+      ...errors.map((error) => `- ${error}`),
+    ];
+    if (companionErrors.length > 0) {
+      lines.push(
+        "Repair the companion runtime by re-running `mate companion setup` in the companion repository or `mate opencode` from the working repository.",
       );
     }
+    throw new LaunchPreflightError(lines.join("\n"));
   }
 
-  private async validatePluginReference(
-    context: AdapterContext,
-    configFile: string,
-    expectedPluginReference: string,
-  ): Promise<string[]> {
-    const configPath = path.join(context.companionPath, configFile);
-
-    const { present, config } = await readOpenCodeConfig(configPath);
-    if (!present) {
-      return [`Unreadable OpenCode configuration: ${configPath}`];
-    }
-
-    const mateReferences = getOpenCodePluginReferences(config).filter(
-      isMateOpenCodePluginReference,
-    ) as string[];
+  /** Launch-time sync leaves unparseable user config untouched; OpenCode would fail on it at startup. */
+  private async validateConfigReadable(context: AdapterContext): Promise<string[]> {
+    const configPath = path.join(context.companionPath, ".opencode", "opencode.json");
+    const { present } = await readOpenCodeConfig(configPath);
+    return present ? [] : [`Unreadable OpenCode configuration: ${configPath}`];
+  }
 
-    if (mateReferences.includes(expectedPluginReference)) {
+  private validatePluginAssets(): string[] {
+    try {
+      validateOpenCodePluginAssets();
       return [];
+    } catch (error) {
+      return [(error as Error).message];
     }
-
-    // Setup writes one of two spellings, and both are current: the published
-    // spec on an ordinary workstation, and an absolute path into the
-    // machine-local workspace where the distribution supplied an installed
-    // copy. Comparing only against the spec would refuse the launch on exactly
-    // the deployments preinstalled binding exists for.
-    //
-    // A bound reference carries its version in the package it points at rather
-    // than in the string, so staleness is read off disk. It is still caught,
-    // and now names the version actually installed.
-    const expectedVersion = expectedPluginReference.slice(OPENCODE_PLUGIN_PACKAGE_NAME.length + 1);
-    const bound = mateReferences.find((reference) =>
-      isPreinstalledPluginPath(reference, OPENCODE_PLUGIN_PACKAGE_NAME),
-    );
-    if (bound !== undefined) {
-      const version = await installedVersionAt(bound);
-      if (version === expectedVersion) return [];
-      return [
-        `Stale Mate plugin package reference in ${configFile}: it points at ${bound}, which is ${version ?? "not installed"} rather than ${expectedVersion}.`,
-      ];
-    }
-
-    if (mateReferences.length > 0) {
-      return [
-        `Stale Mate plugin package reference in ${configFile}: found ${mateReferences.join(", ")}.`,
-      ];
-    }
-
-    return [`Missing Mate plugin package reference in ${configFile}.`];
   }
 
   // Self-check the guidance payload this launch is about to inject so a