@@ -5,6 +5,7 @@ import { type } from "arktype";
 import { scrubSecretShapedContent } from "../plugins/tool-result-secret-scrub.js";
 import {
   lexicalFields,
+  NO_LEXICAL_PARAMS,
   rankAndCut,
   scoreLexical,
   tokenizeLexical,
@@ -35,7 +36,7 @@ export function createAgentIndex(
     rawQuery: string,
   ): number =>
     scoreLexical(
-      lexicalFields(profile.id, profileSearchText(profile)),
+      lexicalFields(profile.id, profileSearchText(profile), NO_LEXICAL_PARAMS),
       queryTokens,
       rawQuery,
     ) +
 
@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import {
   lexicalFields,
+  NO_LEXICAL_PARAMS,
   scoreLexical,
   tokenizeLexical,
 } from "./lexical-rank.js";
@@ -11,6 +12,7 @@ describe("scoreLexical", () => {
     const fields = lexicalFields(
       "mcp__linear__list_release_notes",
       "List release notes in the workspace",
+      NO_LEXICAL_PARAMS,
     );
     // Same raw query on both sides so only the token list differs; the raw
     // query feeds a separate whole-query substring bonus.
@@ -19,4 +21,81 @@ describe("scoreLexical", () => {
       scoreLexical(fields, tokenizeLexical("release notes release"), rawQuery),
     ).toBe(scoreLexical(fields, tokenizeLexical("release notes"), rawQuery));
   });
+
+  // Two-word raw query that no fixture contains whole, so the whole-query
+  // substring bonus never applies and only the per-token tiers are compared.
+  const rawQuery = "release filter";
+  const queryTokens = tokenizeLexical(rawQuery);
+
+  test("ranks a name substring above a parameter name above a parameter description", () => {
+    // Every fixture matches "filter" in its blob, so the parameter tiers have
+    // a direct match to boost.
+    const nameSubstring = lexicalFields(
+      "mcp__acme__releaselog",
+      "Filter logs",
+      NO_LEXICAL_PARAMS,
+    );
+    const paramName = lexicalFields("mcp__acme__records", "Filter records", {
+      names: ["release"],
+      blob: "",
+    });
+    const paramDescription = lexicalFields(
+      "mcp__acme__records",
+      "Filter records",
+      {
+        names: ["id"],
+        blob: "Release ID or slug",
+      },
+    );
+    const scores = [nameSubstring, paramName, paramDescription].map((fields) =>
+      scoreLexical(fields, queryTokens, rawQuery),
+    );
+    expect(scores[0]).toBeGreaterThan(scores[1] ?? 0);
+    expect(scores[1]).toBeGreaterThan(scores[2] ?? 0);
+    expect(scores[2]).toBeGreaterThan(0);
+  });
+
+  test("ranks a parameter name above a description substring of the same word", () => {
+    // "release" sits only inside "prereleases", so the description offers
+    // just a raw-substring hit.
+    const without = lexicalFields(
+      "mcp__acme__records",
+      "Read prereleases",
+      NO_LEXICAL_PARAMS,
+    );
+    const withParam = lexicalFields("mcp__acme__records", "Read prereleases", {
+      names: ["release"],
+      blob: "",
+    });
+    expect(scoreLexical(withParam, queryTokens, rawQuery)).toBeGreaterThan(
+      scoreLexical(without, queryTokens, rawQuery),
+    );
+  });
+
+  test("a parameter match alone scores nothing", () => {
+    const fields = lexicalFields("mcp__acme__records", "Read records", {
+      names: ["release"],
+      blob: "Release ID or slug",
+    });
+    expect(scoreLexical(fields, queryTokens, rawQuery)).toBe(0);
+  });
+
+  test("a parameter match adds nothing to a word already matched by name or description", () => {
+    const params = { names: ["release"], blob: "Release ID or slug" };
+    for (const [name, blob] of [
+      ["mcp__acme__release", "Read logs"],
+      ["mcp__acme__records", "Read a release"],
+      ["mcp__acme__releaselog", "Read logs"],
+    ] as const) {
+      expect(
+        scoreLexical(lexicalFields(name, blob, params), queryTokens, rawQuery),
+      ).toBe(
+        scoreLexical(
+          lexicalFields(name, blob, NO_LEXICAL_PARAMS),
+          queryTokens,
+          rawQuery,
+        ),
+      );
+    }
+  });
 });
@@ -1,7 +1,12 @@
 // One shared dependency-free lexical ranker behind tool_search,
 // search_agents, and skill_search. Exact name-token hits weigh most, then
-// blob-token hits, then raw-substring matches (so "linear" finds
-// mcp__linear__* even though it is not a whole token there).
+// blob-token hits, then a raw name substring (so "linear" finds
+// mcp__linear__* even though it is not a whole token there), then a raw blob
+// substring. Parameter name and description tokens (tool_search only) weigh
+// less than a name substring and only boost an item that already matches by
+// name or blob: a filter makes the tool that carries it rank higher, but a
+// query that matches nothing except parameter text stays a miss, so
+// tool_search still waits for servers that are connecting.
 export function tokenizeLexical(text: string): string[] {
   return text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
 }
@@ -11,36 +16,69 @@ export interface LexicalFields {
   readonly blob: string;
   readonly nameTokens: readonly string[];
   readonly blobTokens: ReadonlySet<string>;
+  readonly paramNameTokens: ReadonlySet<string>;
+  readonly paramBlobTokens: ReadonlySet<string>;
 }
 
-export function lexicalFields(name: string, blob: string): LexicalFields {
+interface LexicalParams {
+  readonly names: readonly string[];
+  readonly blob: string;
+}
+
+export const NO_LEXICAL_PARAMS: LexicalParams = { names: [], blob: "" };
+
+export function lexicalFields(
+  name: string,
+  blob: string,
+  params: LexicalParams,
+): LexicalFields {
   return {
     name,
     blob,
     nameTokens: tokenizeLexical(name),
     blobTokens: new Set(tokenizeLexical(blob)),
+    paramNameTokens: new Set(tokenizeLexical(params.names.join(" "))),
+    paramBlobTokens: new Set(tokenizeLexical(params.blob)),
   };
 }
 
+function directTokenScore(
+  fields: LexicalFields,
+  name: string,
+  blob: string,
+  token: string,
+): number {
+  if (fields.nameTokens.includes(token)) return 3;
+  if (fields.blobTokens.has(token)) return 1;
+  if (name.includes(token)) return 0.75;
+  if (blob.includes(token)) return 0.25;
+  return 0;
+}
+
+function paramTokenScore(fields: LexicalFields, token: string): number {
+  if (fields.paramNameTokens.has(token)) return 0.5;
+  if (fields.paramBlobTokens.has(token)) return 0.25;
+  return 0;
+}
+
 export function scoreLexical(
   fields: LexicalFields,
   queryTokens: readonly string[],
   rawQuery: string,
 ): number {
   const name = fields.name.toLowerCase();
   const blob = fields.blob.toLowerCase();
-  let total = 0;
+  let matched = name.includes(rawQuery) ? 1 : 0;
+  let total = matched;
   // A model repeats a word because its sentence needs it ("release ID or
   // release slug"), not to weight it; counting each copy multiplies the
   // bonus for every tool that matches that one word.
   for (const token of new Set(queryTokens)) {
-    if (fields.nameTokens.includes(token)) total += 3;
-    else if (fields.blobTokens.has(token)) total += 1;
-    else if (name.includes(token)) total += 0.75;
-    else if (blob.includes(token)) total += 0.25;
+    const direct = directTokenScore(fields, name, blob, token);
+    matched += direct;
+    total += Math.max(direct, paramTokenScore(fields, token));
   }
-  if (name.includes(rawQuery)) total += 1;
-  return total;
+  return matched > 0 ? total : 0;
 }
 
 // One shared rank→filter→sort→slice→map cut behind tool_search,
 
@@ -6,6 +6,7 @@ import { type } from "arktype";
 import type { SkillSummary } from "../extensions/skills.js";
 import {
   lexicalFields,
+  NO_LEXICAL_PARAMS,
   rankAndCut,
   scoreLexical,
   tokenizeLexical,
@@ -67,7 +68,7 @@ function scoreSkill(
   rawQuery: string,
 ): number {
   return scoreLexical(
-    lexicalFields(skill.name, skill.description),
+    lexicalFields(skill.name, skill.description, NO_LEXICAL_PARAMS),
     queryTokens,
     rawQuery,
   );
 
@@ -118,22 +118,63 @@ const linearReleaseCatalog: ToolDefinition[] = [
   mcpDef(
     "mcp__linear__list_issues",
     '[linear] List issues in the user\'s Linear workspace, including active Triage Intelligence suggestions for issues in triage. For issues assigned to me, use "me" as the assignee. For issues created by me, use "me" as the creator. Use "null" for no assignee.',
+    {
+      assignee: {
+        type: ["string", "null"],
+        description: 'User ID, name, email, or "me"',
+      },
+      cycle: { type: "string", description: "Cycle name, number, or ID" },
+      label: { type: "string", description: "Label name or ID" },
+      project: {
+        type: "string",
+        description: "Project name, ID, identifier (e.g., P-ENG-123), or slug",
+      },
+      release: { type: "string", description: "Release ID or slug" },
+      state: { type: "string", description: "State type, name, or ID" },
+      team: { type: "string", description: "Team name or ID" },
+    },
   ),
   mcpDef(
     "mcp__linear__get_release",
     "[linear] Retrieve details of a release by ID or slug.",
+    {
+      id: { type: "string", description: "Release ID or slug" },
+      includeReleaseNotes: {
+        type: "boolean",
+        description: "Include associated release notes",
+      },
+    },
   ),
   mcpDef(
     "mcp__linear__get_release_note",
     "[linear] Retrieve release notes by ID or slug, including markdown content.",
+    {
+      id: { type: "string", description: "Release notes ID or slug" },
+      includeReleases: {
+        type: "boolean",
+        description: "Include associated releases",
+      },
+    },
   ),
   mcpDef(
     "mcp__linear__list_release_notes",
     "[linear] List release notes in the workspace, optionally filtered by pipeline or covered release.",
+    {
+      pipeline: {
+        type: "string",
+        description: "Release pipeline ID, slug, or exact name",
+      },
+      query: { type: "string", description: "Search release notes title" },
+      release: { type: "string", description: "Release ID or slug" },
+    },
   ),
   mcpDef(
     "mcp__linear__list_release_pipelines",
     "[linear] List release pipelines in the workspace.",
+    {
+      query: { type: "string", description: "Search pipeline name" },
+      team: { type: "string", description: "Team name or ID" },
+    },
   ),
 ];
 
@@ -340,11 +381,99 @@ describe("createToolIndex", () => {
   });
 
   test("a word repeated in the query does not bury the tool that answers it", () => {
-    const ranked = linearReleaseIndex.search(
+    // Parameters stripped so only counting the repeated word once keeps
+    // list_issues above the cut.
+    const namesOnlyIndex = createToolIndex(() =>
+      linearReleaseCatalog.map((def) => ({ ...def, inputSchema: {} })),
+    );
+    const ranked = namesOnlyIndex.search(
       "Linear list issues filtered by release ID or release slug",
     );
     expect(ranked).toContain("mcp__linear__list_issues");
   });
+
+  test("a release filter lifts list_issues above the tools named for releases", () => {
+    expect(linearReleaseIndex.search("linear issues release filter")[0]).toBe(
+      "mcp__linear__list_issues",
+    );
+  });
+
+  test("a release filter narrows a release query to the tool that takes it", () => {
+    expect(linearReleaseIndex.search("issues for release")).toEqual([
+      "mcp__linear__list_issues",
+    ]);
+  });
+
+  // Identical names and descriptions apart from the filter they take, with
+  // the cycle tool first so catalog order alone would rank it ahead.
+  const recordsCatalog: ToolDefinition[] = [
+    mcpDef("mcp__acme__list_records_v1", "List records", {
+      cycle: { type: "string", description: "Cycle name, number, or ID" },
+    }),
+    mcpDef("mcp__acme__list_records_v2", "List records", {
+      release: { type: "string", description: "Release ID or slug" },
+    }),
+  ];
+  const recordsIndex = createToolIndex(() => recordsCatalog);
+
+  test("a parameter name lifts the tool that takes it", () => {
+    expect(recordsIndex.search("list records by release")[0]).toBe(
+      "mcp__acme__list_records_v2",
+    );
+  });
+
+  test("a word in a parameter description lifts the tool that takes it", () => {
+    expect(recordsIndex.search("list records by slug")[0]).toBe(
+      "mcp__acme__list_records_v2",
+    );
+  });
+
+  test("a query matching only parameter text is a miss", () => {
+    expect(recordsIndex.search("release")).toEqual([]);
+  });
+
+  test("a tool named for the query keeps a parameter-only match off the shortlist", () => {
+    const ranked = linearReleaseIndex.search("linear release");
+    expect(ranked).toContain("mcp__linear__get_release");
+    expect(ranked).not.toContain("mcp__linear__list_issues");
+  });
+
+  test("a parameter shared across tools does not displace the tool named for it", () => {
+    const teamIndex = createToolIndex(() => [
+      ...linearReleaseCatalog,
+      mcpDef(
+        "mcp__linear__list_teams",
+        "[linear] List teams in the user's Linear workspace, including their parent IDs and hierarchy names",
+        { query: { type: "string", description: "Search query" } },
+      ),
+    ]);
+    expect(teamIndex.search("linear team")[0]).toBe("mcp__linear__list_teams");
+  });
+
+  test("a malformed input schema still scores on name and description", () => {
+    const malformedIndex = createToolIndex(() => [
+      {
+        name: "mcp__acme__null_props",
+        description: "Archive widgets",
+        inputSchema: { type: "object", properties: null },
+      },
+      {
+        name: "mcp__acme__numeric_description",
+        description: "Archive gadgets",
+        inputSchema: {
+          type: "object",
+          properties: { release: { type: "string", description: 42 } },
+        },
+      },
+    ]);
+    expect(malformedIndex.search("archive")).toEqual([
+      "mcp__acme__null_props",
+      "mcp__acme__numeric_description",
+    ]);
+    expect(malformedIndex.search("archive release")[0]).toBe(
+      "mcp__acme__numeric_description",
+    );
+  });
 });
 
 describe("createToolSearchTool skills", () => {