claudeup 6.7.1 → 6.8.0

package/src/__tests__/models-presets-marketplace.test.ts

@@ -1,5 +1,6 @@
 /**
- * The agent tier table is keyed by agent id, and nothing else checks those ids.
+ * The agent tier table and the workflow list are keyed by agent id, and nothing else
+ * checks those ids.
  *
  * `DEFAULT_AGENT_GRADES` in `data/models-presets.ts` names
  * agents as `plugin:name`. A rename in the marketplace (`code-search:analyze` →
@@ -17,7 +18,11 @@
 import { describe, expect, test } from "bun:test";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { DEFAULT_AGENT_GRADES, VISION_AGENTS } from "../data/models-presets.js";
+import {
+	DEFAULT_AGENT_GRADES,
+	VISION_AGENTS,
+	WORKFLOWS,
+} from "../data/models-presets.js";
 import { PREDEFINED_PROFILES } from "../data/predefined-profiles.js";
 
 const REPO = resolve(import.meta.dir, "..", "..", "..", "..");
@@ -100,6 +105,28 @@ describe.skipIf(!inMagusSrc)(
 			expect(dead).toEqual([]);
 		});
 
+		/**
+		 * (c) `WORKFLOWS` names agent ids too, and until now nothing checked them.
+		 *
+		 * These ids drive the per-workflow spread graphic. A stale one matches no agent, so
+		 * its segment silently vanishes and the chart goes on drawing a confident answer
+		 * about a workflow it has mis-measured — the same silent-drift failure (a) exists to
+		 * catch, one array over. Measured: the 13.0.0 `code-analysis` → `code-search` rename
+		 * reached this array through a rebase conflict rather than through this gate.
+		 *
+		 * Deliberately NOT folded into `presetKeys`. Being named in a workflow is not a
+		 * routing classification, so counting it in (b) would let a workflow mention excuse
+		 * an agent from ever being given a tier.
+		 */
+		test("(c) every workflow agent names an existing agent or a built-in", () => {
+			const workflowKeys = WORKFLOWS.flatMap((w) => [
+				...w.agents,
+				...w.external.map((step) => step.agent),
+			]);
+			const dead = workflowKeys.filter((k) => !BUILT_IN.has(k) && !ids.has(k));
+			expect(dead).toEqual([]);
+		});
+
 		test("(b) every marketplace agent is classified somewhere", () => {
 			const classified = new Set<string>([
 				...presetKeys,

package/src/__tests__/models-screen-state.test.ts

@@ -24,6 +24,11 @@ function snapshot(over: Partial<ModelsSnapshot> = {}): ModelsSnapshot {
 	};
 }
 
+/** Drop `//` line comments and block comments, so a source guard matches code only. */
+function stripComments(source: string): string {
+	return source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+}
+
 /** Navigating away and back is what unmounts the screen. */
 const roundTrip: AppAction[] = [
 	{ type: "NAVIGATE", route: { screen: "plugins" } },
@@ -36,6 +41,9 @@ describe("models screen initial state", () => {
 		expect(initialState.models.searchQuery).toBe("");
 		expect(initialState.models.status).toBeNull();
 		expect(initialState.models.isApplying).toBe(false);
+		// The mate slots are not drawn until something says they can be served. Starting
+		// true would put three rows on screen before anything had been asked.
+		expect(initialState.models.matesAvailable).toBe(false);
 	});
 
 	test("the models route is reachable and NAVIGATE keeps the screen's state", () => {
@@ -194,6 +202,44 @@ describe("apply-in-flight state", () => {
 	});
 });
 
+describe("the mate slots' availability", () => {
+	test("survives the screen unmounting, so the lookup happens once a session", () => {
+		// Unlike the two file reads this screen does on mount, this answer costs a
+		// marketplace resolution with network timeouts behind it. Held locally it would die
+		// on every tab switch and be paid for again on every return — for something that
+		// cannot change while the TUI is open.
+		const available = run([
+			{ type: "MODELS_MATES_AVAILABLE", available: true },
+		]);
+		expect(available.models.matesAvailable).toBe(true);
+		expect(run(roundTrip, available).models.matesAvailable).toBe(true);
+	});
+
+	test("a false answer is recorded, not treated as no answer", () => {
+		// "Not installed" and "never asked" render the same, and that is deliberate — but
+		// the reducer still has to hold the difference, or a later dispatch could not undo it.
+		const state = run([
+			{ type: "MODELS_MATES_AVAILABLE", available: true },
+			{ type: "MODELS_MATES_AVAILABLE", available: false },
+		]);
+		expect(state.models.matesAvailable).toBe(false);
+	});
+
+	test("it touches no other part of the models state", () => {
+		const before = run([
+			{ type: "MODELS_SELECT", index: 2 },
+			{ type: "MODELS_DATA_SUCCESS", snapshot: snapshot() },
+		]);
+		const after = run(
+			[{ type: "MODELS_MATES_AVAILABLE", available: true }],
+			before,
+		);
+		expect(after.models.selectedIndex).toBe(2);
+		expect(after.models.data).toBe(before.models.data);
+		expect(after.styles).toBe(before.styles);
+	});
+});
+
 describe("selection state", () => {
 	test("select records the index verbatim", () => {
 		expect(
@@ -253,7 +299,17 @@ describe("ModelsScreen keybindings", () => {
 	test("screen state is held in the reducer, never in useState", async () => {
 		// The rule the two "survives unmounting" tests above enforce at runtime,
 		// pinned at the source so a new piece of state cannot quietly opt out.
-		const src = await fs.readFile(SCREEN, "utf8");
+		//
+		// Comments are stripped first, the way hook-import-policy.test.ts does it. The rule
+		// is about CODE, and this screen documents why each piece of its state lives in the
+		// reducer — naming the hook it is deliberately not using is the clearest way to say
+		// that, and a guard reading the prose would forbid the explanation along with the
+		// thing explained.
+		const src = stripComments(await fs.readFile(SCREEN, "utf8"));
 		expect(src).not.toContain("useState");
+		// Negative control: stripping must not have eaten the code being guarded. A guard
+		// over an empty string passes forever.
+		expect(src).toContain("useEffect");
+		expect(src).toContain("useCallback");
 	});
 });

package/src/cli/doctor.ts

@@ -21,7 +21,6 @@ import { readManifest } from "../services/manifest.js";
 import {
 	readModelsConfig,
 	readModelsStatus,
-	reapplyModels,
 } from "../services/models-manager.js";
 import { resolveAllProfiles } from "../services/resolver.js";
 import { activeProfile, profileDir } from "../services/symlink-manager.js";
@@ -172,19 +171,15 @@ async function checkModels(projectPath: string, fix: boolean): Promise<number> {
 		);
 	}
 
+	// No drift check. Settings differing from the config is what a CUSTOM config is, and
+	// `doctor` reports problems — a project running models no shipped preset names has none.
+	// So `doctor --fix` no longer reapplies anything: `invalid` returns early above (those
+	// are choices, not damage) and `unhooked` is repaired by registering the hook. Writing
+	// settings back from the config is `claudeup models use <preset>`, which is a decision
+	// the user makes, not a repair.
 	const status = await readModelsStatus(projectPath);
-	if (status.state === "stale") {
-		console.log("  ✗ settings have drifted from the config:");
-		for (const line of status.drift) console.log(`      ${line}`);
-		if (fix) {
-			await reapplyModels(projectPath);
-			console.log("    Re-applied the config (fixed).");
-		} else {
-			console.log("    Fix: claudeup doctor --fix");
-			problems++;
-		}
-	} else if (status.state === "on") {
-		console.log(`  ✓ preset "${status.preset}" applied, no drift.`);
+	if (status.state === "on") {
+		console.log("  ✓ routing is applied.");
 	}
 
 	for (const warning of status.warnings) console.log(`  ⚠ ${warning}`);

package/src/cli/models.ts

@@ -18,10 +18,20 @@ import {
 	presetLabel,
 	presetNames,
 } from "../data/models-presets.js";
+import {
+	loadMateCatalog,
+	stalenessNote,
+	unknownBindings,
+} from "../services/mate-catalog.js";
 import {
 	GRADES,
 	type ModelsConfig,
 	type ModelsState,
+	boundModel,
+	isMate,
+	mateEffort,
+	matesInUse,
+	sameRouting,
 } from "../services/models-core.js";
 import {
 	applyModelPreset,
@@ -35,13 +45,34 @@ import { ensureManifest } from "./bootstrap.js";
 const HEADLINE: Record<ModelsState, string> = {
 	off: "off — no .claude/models.json, subagents inherit the session model",
 	on: "on",
-	stale: "stale — settings no longer match the config",
 	invalid: "invalid — nothing is routed",
 	unhooked: "unhooked — the config is there, but nothing runs it",
 };
 
-/** `opus (medium)`, or `opus` when no effort is set. */
-function describeSpec(spec: { model: string; effort?: string }): string {
+/**
+ * `opus (medium)`, or `opus` when no effort is set.
+ *
+ * A mate prints the SLOT and what it is bound to — `mate1 → grok-4.6` — because both are
+ * answers to different questions the reader has: which role this tier plays, and which model
+ * plays it. The slot alone was all that could be printed before the `mates` block existed,
+ * and a bare `kangaroo` in a column of `opus (xhigh)` read as a model id nobody recognises.
+ *
+ * An effort on a mate is qualified `(declared)`, for the reason spelled out at
+ * `DECLARED_SUFFIX`: claudeup writes it for claudish and nothing applies it yet, so printing
+ * a bare `(high)` beside a tier where `(high)` IS in force would claim they do the same
+ * thing.
+ */
+function describeSpec(
+	config: ModelsConfig,
+	spec: { model: string; effort?: string },
+): string {
+	if (isMate(spec.model)) {
+		const bound = boundModel(config, spec.model);
+		const effort = spec.effort ?? mateEffort(config, spec.model);
+		const target = bound ?? "unbound";
+		const note = effort ? `${effort} declared, via claudish` : "via claudish";
+		return `${spec.model} → ${target} (${note})`;
+	}
 	return spec.effort ? `${spec.model} (${spec.effort})` : spec.model;
 }
 
@@ -58,24 +89,82 @@ function printPreset(preset: ModelsConfig, active: boolean): void {
 	console.log(
 		`${mark} ${presetLabel(preset.preset)}  —  ${preset.preset}${isDefault}`,
 	);
-	console.log(`    main       ${describeSpec(preset.main)}`);
+	console.log(`    main       ${describeSpec(preset, preset.main)}`);
 	for (const grade of GRADES) {
 		console.log(
-			`    ${grade.padEnd(10)} ${describeSpec(preset.grades[grade])}`,
+			`    ${grade.padEnd(10)} ${describeSpec(preset, preset.grades[grade])}`,
 		);
 	}
 }
 
 async function runList(projectPath: string): Promise<number> {
 	const { config } = await readModelsConfig(projectPath);
+
+	// Has the project diverged from the built-in it NAMES?
+	//
+	// The test used to be "does it name a preset the built-ins do not", which misses the
+	// ordinary case: `claudeup models use opus-lead` writes that name, and every hand edit
+	// afterwards leaves it in place. So a config with a `mates` block was reported as the
+	// built-in `opus-lead`, and the `●` sat on a preset that is not what runs. Compared by
+	// CONTENT, shared with the TUI through `sameRouting` so the two cannot disagree about
+	// which routing is in force.
+	const builtInNamed = BUILT_IN_PRESETS.find(
+		(preset) => preset.preset === config?.preset,
+	);
+	const diverged =
+		config !== null && (!builtInNamed || !sameRouting(config, builtInNamed));
+
 	console.log("\nModel tiers:\n");
 	for (const preset of BUILT_IN_PRESETS) {
-		printPreset(preset, config?.preset === preset.preset);
+		printPreset(preset, !diverged && config?.preset === preset.preset);
 		console.log();
 	}
-	if (config && !presetNames().includes(config.preset)) {
-		console.log(`● ${config.preset}  (this project's own, not a built-in)\n`);
+	if (config && diverged) {
+		// The project's own config gets its tiers PRINTED, not just its name.
+		//
+		// It is the routing actually in force, and it is the only config here that can name a
+		// mate — no built-in does — so printing the name alone hid the one line a reader came
+		// for. The built-ins above are shown in full; showing the active one in less detail
+		// than the ones it replaced was backwards.
+		printPreset(config, true);
+		console.log("    (this project's own, not a built-in)\n");
 	}
+
+	// Which agents leave Claude Code entirely.
+	//
+	// `models list` prints tiers, never agents, so a mate assigned per-agent — the ordinary
+	// way to use one — appears nowhere else in this command's output. It is also the one
+	// routing decision here that claudeup does not carry out itself, which makes it exactly
+	// the thing worth naming rather than leaving to be discovered in the file.
+	const mated = Object.entries(config?.agents ?? {}).filter(
+		([, assignment]) =>
+			typeof assignment !== "string" && isMate(assignment.model),
+	);
+	if (config && mated.length > 0) {
+		console.log("Routed outside Claude Code, through claudish:\n");
+		for (const [agent, assignment] of mated) {
+			const slot =
+				typeof assignment === "string" ? assignment : assignment.model;
+			// The SLOT and the model it names. The slot is what the file says and what the
+			// reader greps for; the bound id is what actually runs. Printing only the slot was
+			// the CLI's version of the screen's `mate1 mate1 —` — a role where a model belongs.
+			const bound = isMate(slot) ? boundModel(config, slot) : null;
+			const target = bound ?? "unbound — add it to the mates block";
+			console.log(`    ${agent.padEnd(28)} ${slot.padEnd(10)} ${target}`);
+		}
+		console.log();
+
+		// The staleness advisory, on the same terms as everywhere else: ADVISORY, and silent
+		// when the catalogue could not be read. `unknownBindings` returns nothing for an empty
+		// catalogue, so a machine without claudish prints no note rather than flagging every
+		// binding it cannot check.
+		const bound = matesInUse(config)
+			.map((mate) => boundModel(config, mate))
+			.filter((id): id is string => id !== null);
+		const note = stalenessNote(unknownBindings(bound, await loadMateCatalog()));
+		if (note) console.log(`⚠ ${note}\n`);
+	}
+
 	console.log(
 		"Tiers name what a subagent is FOR: `smart` takes the judgement calls, `cheap`",
 	);
@@ -97,11 +186,6 @@ async function runStatus(projectPath: string): Promise<number> {
 	if (status.drift.length > 0) {
 		console.log(status.state === "invalid" ? "\nErrors:" : "\nDrift:");
 		for (const line of status.drift) console.log(`  ✗ ${line}`);
-		if (status.state === "stale") {
-			console.log(
-				"\n  Fix: claudeup models use <preset>  (or claudeup doctor --fix)",
-			);
-		}
 		if (status.state === "unhooked")
 			console.log("\n  Fix: claudeup doctor --fix");
 	}

package/src/data/models-presets.ts

@@ -13,7 +13,7 @@
  * `medium`) rather than a harder-working one. What holds everywhere is the other half: the
  * thread dispatching the work is never strictly the biggest spend in the preset.
  */
-import type { Grade, ModelsConfig } from "../services/models-core.js";
+import type { Effort, Grade, ModelsConfig } from "../services/models-core.js";
 
 /**
  * Which tier each subagent gets, shared by every preset.
@@ -70,8 +70,43 @@ export const DEFAULT_AGENT_GRADES: Record<string, Grade> = {
  * Read out of `plugins/dev/commands/{dev,debug,investigate}.md` — agents only. Those files
  * also name skills (`dev:context-detection`, `code-search:investigate`) which are not
  * dispatched through the Agent tool and so are not routed at all.
+ *
+ * ## `external` — the steps that leave Claude Code, whatever the preset says
+ *
+ * A workflow's use of an outside model is a property of the WORKFLOW, not of the routing
+ * config. `/dev:dev` runs a multi-model plan review at Phase 3 and a multi-model code review
+ * at Phase 5 because its command file says so, and switching from `Sonnet` to `Opus main`
+ * does not change that. So these steps are declared here beside the agents and are drawn
+ * under every preset, rather than being read out of `config.agents` — where they would
+ * appear only for a project that happened to have hand-bound a slot.
+ *
+ * Read out of the same command files:
+ *   `plugins/dev/commands/dev.md:138`  Plan review (external models via claudish) → dev:architect
+ *   `plugins/dev/commands/dev.md:140`  Code review (external models via claudish) → dev:architect
+ *
+ * `debug.md` and `investigate.md` contain no claudish reference at all, so both are empty
+ * here — and that absence is worth drawing, because "this flow stays inside Claude Code" is
+ * exactly as useful to know as the opposite.
+ *
+ * A STEP, not an agent: `dev:architect` appears in `agents` above as well, because the same
+ * agent does the Phase 3 planning on a Claude model. Marking the agent external would be
+ * wrong in both directions — it would move the planning outside and merge the two reviews
+ * into it.
  */
-export const WORKFLOWS: { name: string; agents: string[] }[] = [
+export interface WorkflowStep {
+	/** What the phase is called in the command file, for the reader who goes looking. */
+	step: string;
+	/** The agent the step dispatches. Recorded for provenance; routing is claudish's. */
+	agent: string;
+}
+
+export interface Workflow {
+	name: string;
+	agents: string[];
+	external: WorkflowStep[];
+}
+
+export const WORKFLOWS: Workflow[] = [
 	{
 		name: "dev",
 		agents: [
@@ -81,6 +116,10 @@ export const WORKFLOWS: { name: string; agents: string[] }[] = [
 			"dev:qa-engineer",
 			"dev:reviewer",
 		],
+		external: [
+			{ step: "plan review", agent: "dev:architect" },
+			{ step: "code review", agent: "dev:architect" },
+		],
 	},
 	{
 		name: "debug",
@@ -90,10 +129,12 @@ export const WORKFLOWS: { name: string; agents: string[] }[] = [
 			"dev:debugger",
 			"dev:developer",
 		],
+		external: [],
 	},
 	{
 		name: "investigate",
 		agents: ["code-search:analyze", "dev:researcher"],
+		external: [],
 	},
 ];
 
@@ -113,10 +154,25 @@ export const WORKFLOWS: { name: string; agents: string[] }[] = [
  */
 export const VISION_AGENTS = ["designer:review", "designer:ui"] as const;
 
+/**
+ * The effort the external slots run at, per preset.
+ *
+ * A preset cannot say WHICH model serves a mate — a catalogue id shipped in this repo goes
+ * stale, which is the whole reason bindings live in a project's own `mates` block. It can say
+ * how hard that work should try, and that half does not depend on which model answers.
+ *
+ * `xhigh` almost everywhere: a slot is reached for the judgement calls — plan review, code
+ * review — and those are the calls worth spending on whichever model takes them. `Sonnet` is
+ * the exception because it is the economy preset, and a preset whose whole point is to spend
+ * less would be lying if the work it sent outside ignored that.
+ */
+const MATE_EFFORT_DEFAULT: Effort = "xhigh";
+
 function preset(
 	name: string,
 	main: ModelsConfig["main"],
 	grades: ModelsConfig["grades"],
+	mateEffort: Effort = MATE_EFFORT_DEFAULT,
 ): ModelsConfig {
 	return {
 		version: 1,
@@ -125,6 +181,7 @@ function preset(
 		grades,
 		agents: { ...DEFAULT_AGENT_GRADES },
 		fallback: "normal",
+		mateEffort,
 	};
 }
 
@@ -247,6 +304,8 @@ export const BUILT_IN_PRESETS: ModelsConfig[] = [
 	// effort is not throttled on top of it. Every routed agent runs sonnet at `xhigh`,
 	// including `cheap` — so the hook still pins the model (a session started on opus does
 	// not leak into its subagents) while the tier table itself makes no distinction.
+	// The one preset whose mates run at `medium` rather than `xhigh`: an economy preset that
+	// spent freely the moment work left Claude Code would not be one.
 	preset(
 		"sonnet-economy",
 		{ model: "sonnet", effort: "xhigh" },
@@ -255,6 +314,7 @@ export const BUILT_IN_PRESETS: ModelsConfig[] = [
 			normal: { model: "sonnet", effort: "xhigh" },
 			cheap: { model: "sonnet", effort: "xhigh" },
 		},
+		"medium",
 	),
 ];
 

package/src/services/mate-availability.ts

@@ -0,0 +1,133 @@
+/**
+ * Is there anything on this machine that could serve a mate?
+ *
+ * A mate (`mate1`, `mate2`, `kangaroo`) names a third-party model reached through claudish,
+ * and claudish is reached through the `multimodel@magus` plugin. Without it, drawing the
+ * three slots on the Models screen advertises routing that cannot happen — so the renderers
+ * take this as a boolean and draw them only when it is true.
+ *
+ * ## Three things this module deliberately is NOT
+ *
+ * It is not in `models-core.ts`. That module is pure — no fs, no process, no network — and
+ * has to stay that way: Claude Code runs the hook on every single Agent call, and the hook
+ * imports the core.
+ *
+ * It is not in the renderers either. Answering the question needs the plugin registry, which
+ * is the adapter layer's to read, and a renderer that reached for it could not be tested
+ * without a machine to read.
+ *
+ * And it is not part of VALIDATION. A committed `models.json` naming `mate1` is valid
+ * everywhere, whether or not the plugin is installed — see `validateModelsConfig`. Gating
+ * validity on a local install would make one file valid on one teammate's laptop and invalid
+ * on the next one's.
+ *
+ * ## Why the registry is read through `plugin-manager`
+ *
+ * `installed_plugins.json`, `enabledPlugins` and `installedPluginVersions` are Claude Code's
+ * to own, and the last of those is maintained by nothing but claudeup, so it goes stale
+ * silently. `getAvailablePlugins` resolves all three scopes and hands back both facts per
+ * scope, which is all this module takes from it.
+ *
+ * The test on those facts is `servesAMate`, below, and it is deliberately NOT
+ * `plugin-manager`'s `isInstalledInScope` — that one answers a narrower question. See the
+ * comment on the predicate for why the two must not share a helper.
+ */
+
+import {
+	type PluginInfo,
+	type ScopeStatus,
+	getAvailablePlugins,
+} from "./plugin-manager.js";
+
+/** The plugin that puts claudish's model tools in reach. */
+export const MATE_PLUGIN_ID = "multimodel@magus";
+
+/** How the plugins are listed. A seam, for the reason below. */
+export type PluginLister = (projectPath?: string) => Promise<PluginInfo[]>;
+
+/** The env var that forces the slots on, and the values it accepts. */
+export const MATE_FORCE_ENV = "CLAUDEUP_MATES";
+const FORCE_ON = new Set(["1", "true", "on", "yes"]);
+
+/**
+ * Draw the slots regardless of what is installed: `CLAUDEUP_MATES=1 claudeup`.
+ *
+ * The three rows ARE the feature, and on a machine without `multimodel@magus` there is no way
+ * to put them on screen — which leaves the one part of this layout that cannot be checked by
+ * eye being the one most likely to be wrong, since `kangaroo` is eight cells and every column
+ * here was sized for six.
+ *
+ * Read at CALL time, never captured at module load. Bun loads a cwd `.env` before user code
+ * runs, so a value read at import is a snapshot of whichever directory the process started in
+ * — and this process is a TUI a user starts from anywhere.
+ *
+ * It forces the ANSWER and nothing else. No plugin appears because a flag was set, so a mate
+ * still passes straight through the hook and the agent still runs on whatever it would have
+ * run on. The flag moves pixels, not routing.
+ */
+export function matesForced(env: NodeJS.ProcessEnv = process.env): boolean {
+	const raw = env[MATE_FORCE_ENV];
+	return raw !== undefined && FORCE_ON.has(raw.trim().toLowerCase());
+}
+
+/**
+ * True when `multimodel@magus` is installed in ANY scope.
+ *
+ * Any scope, because a mate is served by whatever Claude Code has loaded when the agent is
+ * spawned, and that is the union of the three — a user-scope install serves a project that
+ * enables nothing of its own.
+ *
+ * FAILS CLOSED. This reaches the marketplace resolution path, which does network work and can
+ * time out; a failure means "we do not know", and the honest rendering of not knowing is the
+ * screen exactly as it was before mates existed. Returning true on a failure would put three
+ * rows on screen on the strength of an error.
+ *
+ * `listPlugins` is injected the same way `buildSettingsPatch` takes its `resolveFullId`: the
+ * DECISION here — which scopes count, what an enabled-but-not-installed plugin means, what a
+ * thrown error means — is the part worth testing, and it cannot be tested through a function
+ * that reaches the network and a real machine's registry. The default is the real one, so no
+ * caller has to know the seam exists.
+ */
+/**
+ * Can this scope actually serve a mate? Both facts, not either one.
+ *
+ * Deliberately NOT `isInstalledInScope`, which asks a narrower question: that one means the
+ * files are on disk, and says so — it dropped `enabled` from its test on purpose, so the
+ * plugin list would stop offering to install what was already there.
+ *
+ * Presence on disk is not what this module needs. A plugin the user has switched off is not
+ * loaded, so claudish is not reachable through it, so the routing a mate row advertises
+ * cannot happen — which is the one thing these rows must never claim. The other half matters
+ * for the mirror-image state: a settings flag with no registry version is the broken
+ * enabled-but-not-installed case, and a row drawn on the strength of it promises a plugin
+ * that never loaded.
+ *
+ * So both, and locally, rather than reaching for a shared helper whose meaning is owned by a
+ * different question.
+ */
+function servesAMate(scope: ScopeStatus | undefined): boolean {
+	return !!scope?.enabled && !!scope.version;
+}
+
+export async function areMatesAvailable(
+	projectPath?: string,
+	listPlugins: PluginLister = getAvailablePlugins,
+): Promise<boolean> {
+	// Before the registry, so the flag also skips the network work behind it. Someone who
+	// set it has already said what answer they want; making them wait for a lookup whose
+	// result is discarded would be the slowest possible way to agree with them.
+	if (matesForced()) return true;
+	try {
+		const plugin = (await listPlugins(projectPath)).find(
+			(candidate) => candidate.id === MATE_PLUGIN_ID,
+		);
+		if (!plugin) return false;
+		return (
+			servesAMate(plugin.userScope) ||
+			servesAMate(plugin.projectScope) ||
+			servesAMate(plugin.localScope)
+		);
+	} catch {
+		return false;
+	}
+}