@uniqbit/mate-core 0.15.3 → 0.15.4-canary.10

package/src/cli/commands/doctor.ts

@@ -1,17 +1,13 @@
-import fs from "node:fs/promises";
+import { execFileSync } from "node:child_process";
 import path from "node:path";
 
-import { FRAMEWORK_NAME, frameworkConfig } from "../../framework";
+import { FRAMEWORK_NAME } from "../../framework";
 import { getActiveDistribution } from "../../distribution";
-import { CompanionResolver } from "../../lib/orchestrator/companion-resolver";
-import { CompanionStore, resolvePolicyFromConfig } from "../../lib/orchestrator/companion-store";
-import { ConfigStore } from "../../lib/orchestrator/config-store";
 import { checkEngineRequirement } from "../../lib/orchestrator/engine-guard";
-import { GlobalConfigStore } from "../../lib/orchestrator/global-config-store";
-import { migrateConfigDir } from "../../lib/orchestrator/migration";
-import { findRepoLocalLinkedRepository } from "../../lib/orchestrator/repo-local-registry";
-import type { CapabilityConfig, FrameworkConfig } from "../../lib/orchestrator/types";
-import { WorkingRepoStore } from "../../lib/orchestrator/working-repo-store";
+import type { GlobalConfigStore } from "../../lib/orchestrator/global-config-store";
+import { pathIsDirectory } from "../../lib/orchestrator/repo-local-registry";
+import { resolveRootContext, type RootContext } from "../../lib/orchestrator/root-context";
+import type { CapabilityConfig, FrameworkConfig, HubMember } from "../../lib/orchestrator/types";
 import { getRequiredPluginDrift } from "../../tools/setup/policy";
 import { resolveCommandOnPath } from "../../tools/setup/utils";
 import { printSection, renderKeyValueTable, renderTable } from "./status";
@@ -20,11 +16,43 @@ interface DoctorDeps {
   globalConfigStore?: GlobalConfigStore;
   cwd?: string;
   pathValue?: string;
+  /** Returns a member checkout's HEAD commit, or null when unreadable. */
+  gitHead?: (memberPath: string) => string | null;
 }
 
-interface CompanionStores {
-  configStore: ConfigStore;
-  workingRepoStore: WorkingRepoStore;
+export type DoctorKind = "core" | "working" | "companion" | "hub";
+
+export interface DoctorToolInstallation {
+  tool: string;
+  source: string;
+  status: "ok" | "missing";
+  path: string | null;
+}
+
+export interface DoctorHubMember {
+  id: string;
+  source: "git" | "local";
+  path: string;
+  exists: boolean;
+  commitStatus: "ok" | "drifted" | "missing" | "unknown";
+  materializedCommit: string | null;
+  actualCommit: string | null;
+}
+
+export interface DoctorReport {
+  kind: DoctorKind;
+  cwd: string;
+  companionPath: string | null;
+  repositoryId: string | null;
+  multipleCompanions: Array<{ companionPath: string; repositoryId: string }>;
+  policy?: { allowedAgents: string[] };
+  policyError?: string;
+  capabilities?: string[];
+  toolInstallations?: DoctorToolInstallation[];
+  requiredPluginDrift?: Array<{ pluginId: string; kind: string; reason: string }>;
+  engineRequirement?: { range: string; ok: boolean; detail: string };
+  hub?: { members: DoctorHubMember[] };
+  resolutionFailures: Array<{ companionPath: string; message: string }>;
 }
 
 interface ToolCheck {
@@ -33,77 +61,26 @@ interface ToolCheck {
   source: string;
 }
 
-function storesForCompanion(companionPath: string): CompanionStores {
-  const configDir = path.join(companionPath, `.${FRAMEWORK_NAME}`, "config");
-  return {
-    configStore: new ConfigStore(path.join(configDir, "framework.yaml")),
-    workingRepoStore: new WorkingRepoStore(path.join(configDir, "registry.yaml")),
-  };
+/** Doctor's view of the shared root kind: registry/env resolution means cwd is a working repo. */
+function doctorKind(root: RootContext): DoctorKind {
+  if (root.kind === "core") return "core";
+  if (root.kind === "hub") return "hub";
+  if (root.origin === "env" || root.origin === "registry") return "working";
+  return root.kind;
 }
 
-async function hasLocalCompanionConfig(cwd: string): Promise<boolean> {
-  const localDir = path.join(cwd, `.${FRAMEWORK_NAME}`);
-  const localLegacyDirs = frameworkConfig.legacyNames.map((name) => path.join(cwd, `.${name}`));
-  await migrateConfigDir(localDir, localLegacyDirs);
-
+function defaultGitHead(memberPath: string): string | null {
   try {
-    await fs.access(path.join(localDir, "config", "framework.yaml"));
-    return true;
+    return execFileSync("git", ["-C", memberPath, "rev-parse", "HEAD"], {
+      stdio: ["ignore", "pipe", "ignore"],
+    })
+      .toString()
+      .trim();
   } catch {
-    return false;
+    return null;
   }
 }
 
-function renderList(items: string[], empty: string): string {
-  return items.length > 0 ? items.map((item) => `- ${item}`).join("\n") : empty;
-}
-
-function renderEngineRequirement(
-  config: FrameworkConfig,
-  distributionName: string,
-  currentVersion: string,
-): string {
-  const range = config.engines?.[distributionName];
-  const result = checkEngineRequirement(config, distributionName, currentVersion);
-  return result.ok
-    ? `engines.${distributionName}: satisfied (requires ${range}, running ${currentVersion})`
-    : `engines.${distributionName}: ${result.reason}`;
-}
-
-// Only the engines key matching the running distribution produces a
-// diagnostic; foreign distribution keys are ignored entirely.
-function printEngineRequirement(config: FrameworkConfig): void {
-  const distribution = getActiveDistribution().config;
-  if (!config.engines?.[distribution.name]) return;
-  printSection(
-    "Version Requirement",
-    renderEngineRequirement(config, distribution.name, distribution.version),
-  );
-}
-
-// Companions with no drift produce no section at all: required plugins are
-// silent when healthy.
-function printRequiredPluginDrift(config: FrameworkConfig): void {
-  const drift = getRequiredPluginDrift(config);
-  if (drift.length === 0) return;
-  printSection(
-    "Required Plugin Drift",
-    renderTable(
-      ["Plugin", "Kind", "Issue"],
-      drift.map((entry) => [entry.pluginId, entry.kind, entry.reason]),
-    ),
-  );
-}
-
-function renderCapabilities(capabilities: CapabilityConfig[]): string {
-  return capabilities.length > 0
-    ? renderTable(
-        ["Capability"],
-        capabilities.map((capability) => [capability.name]),
-      )
-    : "No capabilities configured.";
-}
-
 function getSelectedToolChecks(config: {
   capabilities?: CapabilityConfig[];
   packageManagers?: string[];
@@ -139,76 +116,183 @@ function getSelectedToolChecks(config: {
   return checks;
 }
 
-function renderToolInstallations(
-  config: {
-    capabilities?: CapabilityConfig[];
-    packageManagers?: string[];
-  },
+function collectToolInstallations(
+  config: FrameworkConfig,
   pathValue: string,
-): string {
-  const checks = getSelectedToolChecks(config);
-  if (checks.length === 0) {
-    return "No selected capabilities or package managers require command checks.";
+): DoctorToolInstallation[] {
+  return getSelectedToolChecks(config).map((check) => {
+    const resolved = resolveCommandOnPath(check.command, pathValue);
+    return {
+      tool: check.name,
+      source: check.source,
+      status: resolved ? "ok" : "missing",
+      path: resolved ?? null,
+    };
+  });
+}
+
+// Only the engines key matching the running distribution produces a
+// diagnostic; foreign distribution keys are ignored entirely.
+function collectEngineRequirement(
+  config: FrameworkConfig,
+): DoctorReport["engineRequirement"] | undefined {
+  const range = config.engines?.[FRAMEWORK_NAME];
+  if (!range) return undefined;
+  const currentVersion = getActiveDistribution().config.version;
+  const result = checkEngineRequirement(config, FRAMEWORK_NAME, currentVersion);
+  return {
+    range,
+    ok: result.ok,
+    detail: result.ok
+      ? `engines.${FRAMEWORK_NAME}: satisfied (requires ${range}, running ${currentVersion})`
+      : `engines.${FRAMEWORK_NAME}: ${result.reason}`,
+  };
+}
+
+async function collectHubMember(
+  hubPath: string,
+  member: HubMember,
+  gitHead: (memberPath: string) => string | null,
+): Promise<DoctorHubMember> {
+  const memberPath = path.resolve(hubPath, member.path);
+  const base = {
+    id: member.id,
+    source: member.source.kind,
+    path: memberPath,
+    materializedCommit: member.materializedCommit ?? null,
+  };
+  if (!(await pathIsDirectory(memberPath))) {
+    return { ...base, exists: false, commitStatus: "missing", actualCommit: null };
+  }
+  if (!member.materializedCommit) {
+    return { ...base, exists: true, commitStatus: "ok", actualCommit: null };
   }
+  const actualCommit = gitHead(memberPath);
+  return {
+    ...base,
+    exists: true,
+    commitStatus:
+      actualCommit === null
+        ? "unknown"
+        : actualCommit === member.materializedCommit
+          ? "ok"
+          : "drifted",
+    actualCommit,
+  };
+}
 
-  return renderTable(
-    ["Tool", "Source", "Status", "Path"],
-    checks.map((check) => {
-      const resolved = resolveCommandOnPath(check.command, pathValue);
-      return [check.name, check.source, resolved ? "ok" : "missing", resolved ?? ""];
-    }),
-  );
+async function collectWorkingSections(
+  report: DoctorReport,
+  root: RootContext,
+  pathValue: string,
+): Promise<void> {
+  if (!root.rootPath || !root.repositoryId || !root.config) {
+    report.policyError = "No repository ID was provided for the resolved companion.";
+    return;
+  }
+
+  report.policy = { allowedAgents: root.config.allowedAgents ?? [] };
+  collectConfiguredRootSections(report, root.config, pathValue);
 }
 
-/**
- * @command mate doctor
- * @description Reports whether the current directory resolves as a linked
- * working repository, a companion repository, or neither. For linked working
- * repositories it also prints the effective policy and enabled capabilities.
- */
-export async function runDoctorCommand(_argv: string[] = [], deps: DoctorDeps = {}): Promise<void> {
-  const cwd = deps.cwd ?? process.cwd();
+function collectConfiguredRootSections(
+  report: DoctorReport,
+  config: FrameworkConfig,
+  pathValue: string,
+): void {
+  report.capabilities = (config.capabilities ?? []).map((capability) => capability.name);
+  report.toolInstallations = collectToolInstallations(config, pathValue);
+  report.requiredPluginDrift = getRequiredPluginDrift(config);
+  report.engineRequirement = collectEngineRequirement(config);
+}
+
+export async function collectDoctorReport(deps: DoctorDeps = {}): Promise<DoctorReport> {
+  const cwd = path.resolve(deps.cwd ?? process.cwd());
   const pathValue = deps.pathValue ?? process.env.PATH ?? "";
-  const envCompanionPath = process.env.MATE_ARTIFACT_PATH;
-  const globalConfigStore = deps.globalConfigStore ?? new GlobalConfigStore();
-  const resolver = new CompanionResolver(globalConfigStore);
+  const gitHead = deps.gitHead ?? defaultGitHead;
+  const root = await resolveRootContext(cwd, deps);
+  const kind = doctorKind(root);
 
-  let state: "linked-working-repository" | "companion-repository" | "not-linked";
-  let companionPath = "";
-  let repositoryId = "";
-  let repository = await findRepoLocalLinkedRepository(cwd);
-  const resolution = envCompanionPath
-    ? { match: null, failures: [], ambiguousMatches: [] }
-    : await resolver.resolveWithDiagnostics(cwd);
+  const report: DoctorReport = {
+    kind,
+    cwd,
+    companionPath: root.rootPath ?? null,
+    repositoryId: root.repositoryId ?? null,
+    multipleCompanions:
+      root.resolution.ambiguousMatches.length > 1 ? root.resolution.ambiguousMatches : [],
+    resolutionFailures: root.resolution.failures,
+  };
 
-  if (envCompanionPath) {
-    state = "linked-working-repository";
-    companionPath = path.resolve(envCompanionPath);
-    repositoryId = process.env.MATE_REPO_ID ?? repository?.id ?? "";
-  } else if (resolution.match) {
-    state = "linked-working-repository";
-    companionPath = resolution.match.companionPath;
-    repositoryId = repository?.id ?? resolution.match.repositoryId;
-  } else if (await hasLocalCompanionConfig(cwd)) {
-    state = "companion-repository";
-    companionPath = cwd;
-  } else {
-    state = "not-linked";
+  if (kind === "working") {
+    await collectWorkingSections(report, root, pathValue);
+  } else if (kind === "companion" && root.config) {
+    collectConfiguredRootSections(report, root.config, pathValue);
+  } else if (kind === "hub" && root.rootPath && root.config) {
+    report.hub = {
+      members: await Promise.all(
+        (root.config.hub?.companions ?? []).map((member) =>
+          collectHubMember(root.rootPath!, member, gitHead),
+        ),
+      ),
+    };
+    report.requiredPluginDrift = getRequiredPluginDrift(root.config);
+    report.engineRequirement = collectEngineRequirement(root.config);
   }
 
+  return report;
+}
+
+function renderList(items: string[], empty: string): string {
+  return items.length > 0 ? items.map((item) => `- ${item}`).join("\n") : empty;
+}
+
+function renderCapabilities(capabilities: string[]): string {
+  return capabilities.length > 0
+    ? renderTable(
+        ["Capability"],
+        capabilities.map((capability) => [capability]),
+      )
+    : "No capabilities configured.";
+}
+
+function renderToolInstallations(installations: DoctorToolInstallation[]): string {
+  if (installations.length === 0) {
+    return "No selected capabilities or package managers require command checks.";
+  }
+  return renderTable(
+    ["Tool", "Source", "Status", "Path"],
+    installations.map((item) => [item.tool, item.source, item.status, item.path ?? ""]),
+  );
+}
+
+function renderHubMembers(members: DoctorHubMember[]): string {
+  if (members.length === 0) return "No hub members configured.";
+  return renderTable(
+    ["Member", "Source", "Path", "Exists", "Commit"],
+    members.map((member) => [
+      member.id,
+      member.source,
+      member.path,
+      member.exists ? "yes" : "no",
+      member.commitStatus,
+    ]),
+  );
+}
+
+function renderHumanReport(report: DoctorReport): void {
   console.log("Mate Doctor");
   console.log("");
   printSection(
     "Context",
     renderKeyValueTable([
-      ["State", state],
-      ["Current Working Directory", cwd],
-      ["Companion Path", companionPath || "none"],
-      ["Repository ID", repositoryId || "none"],
+      ["State", report.kind],
+      ["Current Working Directory", report.cwd],
+      ["Companion Path", report.companionPath ?? "none"],
+      ["Repository ID", report.repositoryId ?? "none"],
     ]),
   );
 
-  if (resolution.ambiguousMatches.length > 1) {
+  if (report.multipleCompanions.length > 1) {
     printSection(
       "Multiple Companions",
       [
@@ -218,63 +302,63 @@ export async function runDoctorCommand(_argv: string[] = [], deps: DoctorDeps =
         "",
         renderTable(
           ["Companion Path", "Repository ID"],
-          resolution.ambiguousMatches.map((match) => [match.companionPath, match.repositoryId]),
+          report.multipleCompanions.map((match) => [match.companionPath, match.repositoryId]),
         ),
       ].join("\n"),
     );
   }
 
-  if (state === "linked-working-repository" && companionPath && repositoryId) {
-    const { configStore, workingRepoStore } = storesForCompanion(companionPath);
-    const config = await configStore.load();
-    let resolvedPolicy;
-
-    if (repository) {
-      resolvedPolicy = resolvePolicyFromConfig(config, [repository], repository.id);
-    } else {
-      resolvedPolicy = await new CompanionStore(configStore, workingRepoStore).resolvePolicy(
-        repositoryId,
-      );
-    }
-
-    if (!repository) {
-      const working = await workingRepoStore.load();
-      repository = working.repos.find((repo) => repo.id === repositoryId) ?? null;
-    }
-
+  if (report.policy) {
     printSection(
-      "Policy",
-      renderKeyValueTable([
-        ["Profile", repository?.profile ?? "unknown"],
-        ["Allowed Agents", resolvedPolicy.allowedAgents.join(", ") || "none"],
-      ]),
+      "Allowed Agents",
+      renderList(report.policy.allowedAgents, "No allowed agents configured."),
     );
+  }
+  if (report.policyError) printSection("Policy", report.policyError);
+  if (report.capabilities) printSection("Capabilities", renderCapabilities(report.capabilities));
+  if (report.toolInstallations) {
+    printSection("Tool Installations", renderToolInstallations(report.toolInstallations));
+  }
+  if (report.hub) printSection("Hub Members", renderHubMembers(report.hub.members));
+  // Companions with no drift produce no section at all: required plugins are
+  // silent when healthy.
+  if (report.requiredPluginDrift && report.requiredPluginDrift.length > 0) {
     printSection(
-      "Allowed Agents",
-      renderList(resolvedPolicy.allowedAgents, "No allowed agents configured."),
+      "Required Plugin Drift",
+      renderTable(
+        ["Plugin", "Kind", "Issue"],
+        report.requiredPluginDrift.map((entry) => [entry.pluginId, entry.kind, entry.reason]),
+      ),
     );
-    printSection("Capabilities", renderCapabilities(config.capabilities ?? []));
-    printSection("Tool Installations", renderToolInstallations(config, pathValue));
-    printRequiredPluginDrift(config);
-    printEngineRequirement(config);
-  } else if (state === "linked-working-repository") {
-    printSection("Policy", "No repository ID was provided for the resolved companion.");
-  } else if (companionPath) {
-    const { configStore } = storesForCompanion(companionPath);
-    const config = await configStore.load();
-    printSection("Capabilities", renderCapabilities(config.capabilities ?? []));
-    printSection("Tool Installations", renderToolInstallations(config, pathValue));
-    printRequiredPluginDrift(config);
-    printEngineRequirement(config);
+  }
+  if (report.engineRequirement) {
+    printSection("Version Requirement", report.engineRequirement.detail);
   }
 
   printSection(
     "Resolution Failures",
-    resolution.failures.length > 0
+    report.resolutionFailures.length > 0
       ? renderTable(
           ["Companion Path", "Error"],
-          resolution.failures.map((failure) => [failure.companionPath, failure.message]),
+          report.resolutionFailures.map((failure) => [failure.companionPath, failure.message]),
         )
       : "No companion resolution failures encountered.",
   );
 }
+
+/**
+ * @command mate doctor
+ * @description Reports the current directory's root kind — `working` (linked
+ * working repository), `companion`, `hub`, or `core` (not linked) — with
+ * kind-specific diagnostics: policy and capabilities for working repos,
+ * capabilities and tool checks for companions, member health for hubs.
+ * `--json` emits the same report as one JSON document.
+ */
+export async function runDoctorCommand(argv: string[] = [], deps: DoctorDeps = {}): Promise<void> {
+  const report = await collectDoctorReport(deps);
+  if (argv.includes("--json")) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  renderHumanReport(report);
+}

package/src/cli/commands/install.ts

@@ -1,5 +1,5 @@
 import { confirm } from "../confirm";
-import { frameworkCommandName } from "../../framework";
+import { FRAMEWORK_NAME } from "../../framework";
 import {
   buildInstallPlan,
   inspectInstallPlan,
@@ -14,13 +14,15 @@ import {
   installDeclaredPlugins,
   type PluginInstallResult,
 } from "../../tools/setup/dynamic-plugins/install";
+import { registryConfigHint } from "../../tools/setup/dynamic-plugins/registry-hint";
 
 export function reportPluginInstallResults(results: PluginInstallResult[]): void {
   for (const result of results) {
     if (result.status === "failed") {
       process.stderr.write(
-        `${frameworkCommandName()}: plugin "${result.package}" failed to install: ${result.error ?? "unknown error"}\n`,
+        `${FRAMEWORK_NAME}: plugin "${result.package}" failed to install: ${result.error ?? "unknown error"}\n`,
       );
+      process.stderr.write(`${registryConfigHint(result.package)}\n`);
     } else if (result.status === "installed") {
       console.log(`  installed plugin ${result.package}@${result.resolvedVersion}`);
     }
@@ -54,10 +56,14 @@ export async function runInstallCommand(argv: string[], cwd = process.cwd()): Pr
     process.exitCode = 1;
     return false;
   }
-  // Companion-declared plugins install first and hydrate into the registry
-  // before the plan is built, so one run goes install → load → plan and their
-  // own install requirements are part of the plan.
-  if (context.kind === "companion" && context.companionPath && context.config.plugins?.length) {
+  // Root-declared plugins (companion or hub) install first and hydrate into
+  // the registry before the plan is built, so one run goes install → load →
+  // plan and their own install requirements are part of the plan.
+  if (
+    (context.kind === "companion" || context.kind === "hub") &&
+    context.companionPath &&
+    context.config.plugins?.length
+  ) {
     reportPluginInstallResults(
       await installDeclaredPlugins(context.companionPath, context.config.plugins),
     );
@@ -72,7 +78,7 @@ export async function runInstallCommand(argv: string[], cwd = process.cwd()): Pr
       const ok = await confirm("Install the missing requirements? [y/N] ");
       if (!ok) {
         process.stderr.write(
-          `Installation declined. Run \`${frameworkCommandName()} install --yes\` to continue.\n`,
+          `Installation declined. Run \`${FRAMEWORK_NAME} install --yes\` to continue.\n`,
         );
         process.exitCode = 1;
         return false;
@@ -83,7 +89,7 @@ export async function runInstallCommand(argv: string[], cwd = process.cwd()): Pr
     printPlanText(plan);
     if (!skipConfirm) {
       process.stderr.write(
-        `${frameworkCommandName()}: installation requires confirmation in a TTY. Re-run with \`${frameworkCommandName()} install --yes\`.\n`,
+        `${FRAMEWORK_NAME}: installation requires confirmation in a TTY. Re-run with \`${FRAMEWORK_NAME} install --yes\`.\n`,
       );
       process.exitCode = 1;
       return false;
@@ -103,11 +109,11 @@ export async function runInstallCommand(argv: string[], cwd = process.cwd()): Pr
   if (!execution.ok) {
     for (const result of execution.results.filter((item) => item.status === "failed")) {
       process.stderr.write(
-        `${frameworkCommandName()}: ${result.id} failed: ${result.error ?? "unknown error"}\n`,
+        `${FRAMEWORK_NAME}: ${result.id} failed: ${result.error ?? "unknown error"}\n`,
       );
     }
     process.stderr.write(
-      `Installation is incomplete. Re-run \`${frameworkCommandName()} install\` after remediation.\n`,
+      `Installation is incomplete. Re-run \`${FRAMEWORK_NAME} install\` after remediation.\n`,
     );
     process.exitCode = 1;
     return false;
@@ -118,11 +124,9 @@ export async function runInstallCommand(argv: string[], cwd = process.cwd()): Pr
     await saveCompleteInstallState(plan, execution.results);
   } catch (error) {
     process.stderr.write(
-      `${frameworkCommandName()}: installation completed but companion reconciliation failed: ${error instanceof Error ? error.message : String(error)}\n`,
-    );
-    process.stderr.write(
-      `Installation is incomplete. Re-run \`${frameworkCommandName()} install\`.\n`,
+      `${FRAMEWORK_NAME}: installation completed but companion reconciliation failed: ${error instanceof Error ? error.message : String(error)}\n`,
     );
+    process.stderr.write(`Installation is incomplete. Re-run \`${FRAMEWORK_NAME} install\`.\n`);
     process.exitCode = 1;
     return false;
   }

package/src/cli/commands/launch/shared.ts

@@ -1,4 +1,4 @@
-import { frameworkCommandName } from "../../../framework";
+import { FRAMEWORK_NAME } from "../../../framework";
 import { FrameworkLauncher } from "../../../lib/orchestrator/launcher";
 import {
   LaunchPreflightError,
@@ -43,7 +43,7 @@ export function parseLaunchArgs(argv: string[]): ParsedLaunchArgs | null {
   const agentArgs = separatorIndex >= 0 ? argv.slice(separatorIndex + 1) : [];
 
   for (const arg of optionArgs) {
-    process.stderr.write(`${frameworkCommandName()}: unknown launch option: ${arg}\n`);
+    process.stderr.write(`${FRAMEWORK_NAME}: unknown launch option: ${arg}\n`);
     process.exitCode = 1;
     return null;
   }
@@ -109,7 +109,7 @@ export async function runLaunchToolCommand(
 
     if (error instanceof ToolNotAllowedError) {
       process.stderr.write(
-        `${frameworkCommandName()}: \`${tool}\` is disallowed by active repository policy.\n`,
+        `${FRAMEWORK_NAME}: \`${tool}\` is disallowed by active repository policy.\n`,
       );
       process.exitCode = 1;
       return;
@@ -117,7 +117,7 @@ export async function runLaunchToolCommand(
 
     if (error instanceof RepositoryNotSelectedError) {
       process.stderr.write(`${error.message}\n`);
-      process.stderr.write(`Run \`${frameworkCommandName()} companion link\` first.\n`);
+      process.stderr.write(`Run \`${FRAMEWORK_NAME} companion link\` first.\n`);
       process.exitCode = 1;
       return;
     }