@mrclrchtr/supi-code-intelligence 4.1.0 → 4.3.0

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/outline-polyglot.ts

@@ -0,0 +1,218 @@
+import { nodeToRange } from "../coordinates.ts";
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { OutlineItem } from "../types.ts";
+import { extractCFamilyOutlineItems } from "./outline-c-family.ts";
+import { extractHtmlSqlOutlineItems } from "./outline-html-sql.ts";
+import { extractJvmOutlineItems } from "./outline-jvm.ts";
+import { extractScriptingOutlineItems } from "./outline-scripting.ts";
+
+/** Extract declarations whose Tree-sitter node shapes are specific to non-JS/TS grammars. */
+export function extractPolyglotOutlineItems(
+  node: SyntaxNodeLike,
+  source: string,
+): OutlineItem[] | undefined {
+  const scriptingItems = extractScriptingOutlineItems(node, source);
+  if (scriptingItems) return scriptingItems;
+
+  const htmlSqlItems = extractHtmlSqlOutlineItems(node, source);
+  if (htmlSqlItems) return htmlSqlItems;
+
+  switch (node.type) {
+    case "function_definition": {
+      const name = node.childForFieldName("name");
+      return name
+        ? [{ name: name.text, kind: "function", range: nodeToRange(node, source) }]
+        : extractCFamilyOutlineItems(node, source);
+    }
+    case "class_definition":
+      return one(container(node, "class", source, pythonMethods));
+    case "expression_statement":
+      return pythonAssignments(node, source);
+    case "function_item":
+      return one(named(node, "function", source));
+    case "struct_item":
+      return one(container(node, "struct", source, rustFields));
+    case "union_item":
+      return one(container(node, "union", source, rustFields));
+    case "enum_item":
+      return one(container(node, "enum", source, rustEnumVariants));
+    case "trait_item":
+      return one(container(node, "interface", source, rustMethods));
+    case "impl_item":
+      return one(rustImplementation(node, source));
+    case "const_item":
+      return one(named(node, "constant", source));
+    case "static_item":
+      return one(named(node, "variable", source));
+    case "type_item":
+      return one(named(node, "type", source));
+    case "mod_item":
+      return one(named(node, "module", source));
+    case "method_declaration":
+      return one(named(node, "method", source));
+    case "type_spec":
+      return one(goType(node, source));
+    case "type_alias":
+      return one(named(node, "type", source));
+    case "const_spec":
+      return namedItems(node, "constant", source);
+    case "var_spec":
+      return namedItems(node, "variable", source);
+    default:
+      return extractCFamilyOutlineItems(node, source) ?? extractJvmOutlineItems(node, source);
+  }
+}
+
+function one(item: OutlineItem | null): OutlineItem[] {
+  return item ? [item] : [];
+}
+
+function named(node: SyntaxNodeLike, kind: string, source: string): OutlineItem | null {
+  const name = findName(node);
+  return name ? { name: name.text, kind, range: nodeToRange(node, source) } : null;
+}
+
+function container(
+  node: SyntaxNodeLike,
+  kind: string,
+  source: string,
+  collectChildren: (node: SyntaxNodeLike, source: string) => OutlineItem[],
+): OutlineItem | null {
+  const name = findName(node);
+  if (!name) return null;
+  return {
+    name: name.text,
+    kind,
+    range: nodeToRange(node, source),
+    children: collectChildren(node, source),
+  };
+}
+
+function pythonAssignments(node: SyntaxNodeLike, source: string): OutlineItem[] | undefined {
+  const assignment = node.children.find((child) => child.type === "assignment");
+  return assignment ? collectPythonAssignment(assignment, source) : undefined;
+}
+
+function collectPythonAssignment(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  const items = pythonBindingItems(node.childForFieldName("left"), node, source);
+  const right = node.childForFieldName("right");
+  if (right?.type === "assignment") items.push(...collectPythonAssignment(right, source));
+  return items;
+}
+
+function pythonBindingItems(
+  target: SyntaxNodeLike | null,
+  declaration: SyntaxNodeLike,
+  source: string,
+): OutlineItem[] {
+  if (!target) return [];
+  if (target.type === "identifier") {
+    return [{ name: target.text, kind: "variable", range: nodeToRange(declaration, source) }];
+  }
+  if (!PYTHON_BINDING_PATTERNS.has(target.type)) return [];
+  return target.children.flatMap((child) => pythonBindingItems(child, declaration, source));
+}
+
+const PYTHON_BINDING_PATTERNS = new Set(["pattern_list", "list_pattern", "tuple_pattern"]);
+
+function pythonMethods(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  const body = node.childForFieldName("body");
+  if (!body) return [];
+  return body.children.flatMap((child) => {
+    const declaration =
+      child.type === "decorated_definition"
+        ? child.children.find((nested) => nested.type === "function_definition")
+        : child;
+    if (declaration?.type !== "function_definition") return [];
+    const item = named(declaration, "method", source);
+    return item ? [item] : [];
+  });
+}
+
+function rustFields(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  const body = node.childForFieldName("body");
+  return collectNamedChildren(body, new Set(["field_declaration"]), "field", source);
+}
+
+function rustEnumVariants(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  const body = node.childForFieldName("body");
+  return collectNamedChildren(body, new Set(["enum_variant"]), "enum-member", source);
+}
+
+function rustMethods(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  const body = node.childForFieldName("body");
+  return collectNamedChildren(
+    body,
+    new Set(["function_item", "function_signature_item"]),
+    "method",
+    source,
+  );
+}
+
+function rustImplementation(node: SyntaxNodeLike, source: string): OutlineItem | null {
+  const type = node.childForFieldName("type");
+  if (!type) return null;
+  const trait = node.childForFieldName("trait");
+  return {
+    name: trait ? `${trait.text} for ${type.text}` : type.text,
+    kind: "implementation",
+    range: nodeToRange(node, source),
+    children: rustMethods(node, source),
+  };
+}
+
+function goType(node: SyntaxNodeLike, source: string): OutlineItem | null {
+  const type = node.childForFieldName("type");
+  if (!type) return named(node, "type", source);
+  if (type.type === "struct_type") return container(node, "struct", source, goStructFields);
+  if (type.type === "interface_type") return container(node, "interface", source, goMethods);
+  return named(node, "type", source);
+}
+
+function goStructFields(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  const body = node
+    .childForFieldName("type")
+    ?.children.find((child) => child.type.endsWith("list"));
+  if (!body) return [];
+  return body.children.flatMap((child) =>
+    child.type === "field_declaration" ? namedItems(child, "field", source) : [],
+  );
+}
+
+function goMethods(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  const body = node.childForFieldName("type");
+  return collectNamedChildren(body, new Set(["method_elem"]), "method", source);
+}
+
+function collectNamedChildren(
+  parent: SyntaxNodeLike | null | undefined,
+  accepted: ReadonlySet<string>,
+  kind: string,
+  source: string,
+): OutlineItem[] {
+  if (!parent) return [];
+  return parent.children.flatMap((child) => {
+    if (!accepted.has(child.type)) return [];
+    const item = named(child, kind, source);
+    return item ? [item] : [];
+  });
+}
+
+function namedItems(node: SyntaxNodeLike, kind: string, source: string): OutlineItem[] {
+  const names = node
+    .childrenForFieldName("name")
+    .filter((child) => NAME_NODE_TYPES.has(child.type));
+  if (names.length === 0) return one(named(node, kind, source));
+  const range = nodeToRange(node, source);
+  return names.map((name) => ({ name: name.text, kind, range }));
+}
+
+const NAME_NODE_TYPES = new Set(["identifier", "type_identifier", "field_identifier"]);
+
+function findName(node: SyntaxNodeLike): SyntaxNodeLike | null {
+  return (
+    node.childForFieldName("name") ??
+    node.children.find((child) => NAME_NODE_TYPES.has(child.type)) ??
+    null
+  );
+}

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/outline-scripting.ts

@@ -0,0 +1,307 @@
+import { nodeToRange } from "../coordinates.ts";
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { OutlineItem } from "../types.ts";
+
+/** Extract Ruby, shell, and R declarations from their grammar-specific node shapes. */
+export function extractScriptingOutlineItems(
+  node: SyntaxNodeLike,
+  source: string,
+): OutlineItem[] | undefined {
+  const ruby = rubyItems(node, "top-level", source);
+  if (ruby) return ruby;
+
+  switch (node.type) {
+    case "variable_assignment":
+      return isNestedShellDeclaration(node) || node.parent?.type === "command"
+        ? []
+        : one(shellVariable(node, "variable", source));
+    case "declaration_command":
+      return isNestedShellDeclaration(node) ? [] : shellDeclarations(node, source);
+    case "function_definition": {
+      const nameType = node.childForFieldName("name")?.type;
+      if (nameType === "word") {
+        return isNestedShellDeclaration(node) ? [] : one(named(node, "function", source));
+      }
+      return nameType === "function" || nameType === "\\" ? [] : undefined;
+    }
+    case "binary_operator":
+      return rAssignments(node, source);
+    default:
+      return undefined;
+  }
+}
+
+function rubyItems(
+  node: SyntaxNodeLike,
+  context: "top-level" | "member",
+  source: string,
+): OutlineItem[] | undefined {
+  switch (node.type) {
+    case "assignment":
+    case "operator_assignment":
+      return rubyAssignments(node, context, source);
+    case "module":
+      return isRubyContainer(node) ? one(rubyContainer(node, "module", source)) : undefined;
+    case "class":
+      return isRubyContainer(node) ? one(rubyContainer(node, "class", source)) : undefined;
+    case "method":
+      return one(named(node, context === "member" ? "method" : "function", source));
+    case "singleton_method":
+      return one(named(node, "method", source));
+    case "singleton_class":
+      return rubyMembers(node.childForFieldName("body"), source);
+    case "alias":
+      return one(named(node, context === "member" ? "method" : "function", source));
+    case "call":
+      return context === "member" ? rubyCallMethods(node, source) : undefined;
+    case "block":
+      return node.childForFieldName("body")?.type === "block_body" ? [] : undefined;
+    case "do_block":
+      return node.childForFieldName("body")?.type === "body_statement" ? [] : undefined;
+    default:
+      return undefined;
+  }
+}
+
+function isRubyContainer(node: SyntaxNodeLike): boolean {
+  const name = node.childForFieldName("name");
+  const body = node.childForFieldName("body");
+  return Boolean(
+    name && RUBY_CONTAINER_NAME_TYPES.has(name.type) && (!body || body.type === "body_statement"),
+  );
+}
+
+function rubyContainer(node: SyntaxNodeLike, kind: string, source: string): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  if (!name) return null;
+  return {
+    name: name.text,
+    kind,
+    range: nodeToRange(node, source),
+    children: rubyMembers(node.childForFieldName("body"), source),
+  };
+}
+
+function rubyMembers(body: SyntaxNodeLike | null | undefined, source: string): OutlineItem[] {
+  if (!body) return [];
+  return body.children.flatMap((child) => rubyItems(child, "member", source) ?? []);
+}
+
+function rubyAssignments(
+  node: SyntaxNodeLike,
+  context: "top-level" | "member",
+  source: string,
+): OutlineItem[] {
+  const left = node.childForFieldName("left");
+  if (!left) return [];
+  const range = nodeToRange(node, source);
+  const items = rubyBindingNodes(left)
+    .filter((binding) => context === "top-level" || binding.type !== "identifier")
+    .map((binding) => ({
+      name: binding.text,
+      kind:
+        binding.type === "constant" || binding.type === "scope_resolution"
+          ? "constant"
+          : "variable",
+      range,
+    }));
+  const right = unwrapParentheses(node.childForFieldName("right"));
+  const chained =
+    right?.type === "assignment" || right?.type === "operator_assignment"
+      ? rubyAssignments(right, context, source)
+      : [];
+  return [...items, ...chained];
+}
+
+function rubyBindingNodes(node: SyntaxNodeLike): SyntaxNodeLike[] {
+  if (RUBY_BINDING_TYPES.has(node.type)) return [node];
+  if (!RUBY_BINDING_PATTERNS.has(node.type)) return [];
+  return node.children.flatMap(rubyBindingNodes);
+}
+
+function rubyCallMethods(node: SyntaxNodeLike, source: string): OutlineItem[] | undefined {
+  const method = node.childForFieldName("method")?.text;
+  const argumentsNode = node.childForFieldName("arguments");
+  if (!method || !argumentsNode || node.childForFieldName("receiver")) return undefined;
+
+  if (RUBY_ATTRIBUTE_METHODS.has(method)) {
+    const range = nodeToRange(node, source);
+    return rubySymbolNames(argumentsNode).flatMap((name) => {
+      if (method === "attr_writer") return [{ name: `${name}=`, kind: "method", range }];
+      if (method === "attr_accessor") {
+        return [
+          { name, kind: "method", range },
+          { name: `${name}=`, kind: "method", range },
+        ];
+      }
+      return [{ name, kind: "method", range }];
+    });
+  }
+  if (method === "alias_method") {
+    const name = rubySymbolNames(argumentsNode)[0];
+    return name ? [{ name, kind: "method", range: nodeToRange(node, source) }] : [];
+  }
+  if (RUBY_VISIBILITY_METHODS.has(method)) {
+    const declaration = argumentsNode.children.find(
+      (child) => child.type === "method" || child.type === "singleton_method",
+    );
+    return declaration ? rubyItems(declaration, "member", source) : [];
+  }
+  return undefined;
+}
+
+function rubySymbolNames(node: SyntaxNodeLike): string[] {
+  return node.children
+    .filter((child) => child.type === "simple_symbol")
+    .map((child) => child.text.replace(/^:/, ""));
+}
+
+function isNestedShellDeclaration(node: SyntaxNodeLike): boolean {
+  if (isBackgroundedShellNode(node)) return true;
+  for (let parent = node.parent; parent; parent = parent.parent) {
+    if (SHELL_SCOPE_BOUNDARIES.has(parent.type)) return true;
+  }
+  return false;
+}
+
+function isBackgroundedShellNode(node: SyntaxNodeLike): boolean {
+  for (let current = node, parent = node.parent; parent; current = parent, parent = parent.parent) {
+    const index = parent.children.findIndex((child) => sameNode(child, current));
+    if (index >= 0 && parent.children[index + 1]?.type === "&") return true;
+  }
+  return false;
+}
+
+function sameNode(left: SyntaxNodeLike, right: SyntaxNodeLike): boolean {
+  return (
+    left.type === right.type &&
+    left.startPosition.row === right.startPosition.row &&
+    left.startPosition.column === right.startPosition.column &&
+    left.endPosition.row === right.endPosition.row &&
+    left.endPosition.column === right.endPosition.column
+  );
+}
+
+function shellVariable(
+  node: SyntaxNodeLike,
+  kind: "constant" | "variable",
+  source: string,
+): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  return name?.type === "variable_name"
+    ? { name: name.text, kind, range: nodeToRange(node, source) }
+    : null;
+}
+
+function shellDeclarations(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  if (node.children.some((child) => child.type === "word" && /^-[a-z]*[pf]/i.test(child.text))) {
+    return [];
+  }
+  const constant =
+    node.children.some((child) => child.type === "readonly") ||
+    node.children.some((child) => child.type === "word" && /^-[a-z]*r/i.test(child.text));
+  const range = nodeToRange(node, source);
+  return node.children.flatMap((child) => {
+    if (child.type === "variable_assignment") {
+      const item = shellVariable(child, constant ? "constant" : "variable", source);
+      return item ? [{ ...item, range }] : [];
+    }
+    return child.type === "variable_name"
+      ? [{ name: child.text, kind: constant ? "constant" : "variable", range }]
+      : [];
+  });
+}
+
+function rAssignments(node: SyntaxNodeLike, source: string): OutlineItem[] | undefined {
+  const operator = node.children.find((child) => R_ASSIGNMENT_OPERATORS.has(child.type))?.type;
+  if (!operator) return undefined;
+
+  const leftward = operator === "=" || operator.endsWith("<-");
+  const receiver = node.childForFieldName(leftward ? "lhs" : "rhs");
+  const value = node.childForFieldName(leftward ? "rhs" : "lhs");
+  if (!receiver || !value) return [];
+
+  const item =
+    receiver.type === "identifier"
+      ? [
+          {
+            name: receiver.text,
+            kind: rAssignedValue(value)?.type === "function_definition" ? "function" : "variable",
+            range: nodeToRange(node, source),
+          },
+        ]
+      : [];
+  const nestedAssignment = unwrapParentheses(value);
+  const chained =
+    nestedAssignment?.type === "binary_operator"
+      ? (rAssignments(nestedAssignment, source) ?? [])
+      : [];
+  return [...item, ...chained];
+}
+
+function unwrapParentheses(node: SyntaxNodeLike | null): SyntaxNodeLike | null {
+  if (node?.type === "parenthesized_expression") {
+    return unwrapParentheses(node.childForFieldName("body"));
+  }
+  if (node?.type === "parenthesized_statements") {
+    return unwrapParentheses(
+      node.children.find(
+        (child) => child.type === "assignment" || child.type === "operator_assignment",
+      ) ?? null,
+    );
+  }
+  return node;
+}
+
+function rAssignedValue(node: SyntaxNodeLike): SyntaxNodeLike | null {
+  const assignment = unwrapParentheses(node);
+  if (assignment?.type !== "binary_operator") return assignment;
+
+  const operator = assignment.children.find((child) =>
+    R_ASSIGNMENT_OPERATORS.has(child.type),
+  )?.type;
+  if (!operator) return assignment;
+  const leftward = operator === "=" || operator.endsWith("<-");
+  const value = assignment.childForFieldName(leftward ? "rhs" : "lhs");
+  return value ? rAssignedValue(value) : null;
+}
+
+function one(item: OutlineItem | null): OutlineItem[] {
+  return item ? [item] : [];
+}
+
+function named(node: SyntaxNodeLike, kind: string, source: string): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  return name ? { name: name.text, kind, range: nodeToRange(node, source) } : null;
+}
+
+const RUBY_BINDING_TYPES = new Set([
+  "constant",
+  "identifier",
+  "global_variable",
+  "class_variable",
+  "instance_variable",
+  "scope_resolution",
+]);
+const RUBY_BINDING_PATTERNS = new Set([
+  "left_assignment_list",
+  "destructured_left_assignment",
+  "rest_assignment",
+]);
+const RUBY_CONTAINER_NAME_TYPES = new Set(["constant", "scope_resolution"]);
+const RUBY_ATTRIBUTE_METHODS = new Set(["attr", "attr_reader", "attr_writer", "attr_accessor"]);
+const RUBY_VISIBILITY_METHODS = new Set([
+  "private",
+  "protected",
+  "public",
+  "module_function",
+  "private_class_method",
+  "public_class_method",
+]);
+const SHELL_SCOPE_BOUNDARIES = new Set([
+  "command_substitution",
+  "process_substitution",
+  "subshell",
+  "pipeline",
+]);
+const R_ASSIGNMENT_OPERATORS = new Set(["=", "<-", "<<-", "->", "->>"]);

package/node_modules/@mrclrchtr/supi-tree-sitter/src/tool/outline.ts

@@ -3,6 +3,7 @@
 import { nodeToRange } from "../coordinates.ts";
 import type { SyntaxNodeLike } from "../syntax-node.ts";
 import type { OutlineItem } from "../types.ts";
+import { extractPolyglotOutlineItems } from "./outline-polyglot.ts";
 
 /** Node types that can be extracted directly as outline items. */
 const OUTLINE_DECLARATION_NODE_TYPES = new Set([
@@ -32,12 +33,15 @@ function collectItems(node: SyntaxNodeLike, source: string): OutlineItem[] {
   const items: OutlineItem[] = [];
 
   for (const child of node.children) {
-    const item = extractItem(child, source);
-    if (item) {
-      items.push(item);
-    } else {
-      items.push(...collectItems(child, source));
+    const polyglotItems = extractPolyglotOutlineItems(child, source);
+    if (polyglotItems) {
+      items.push(...polyglotItems);
+      continue;
     }
+
+    const item = extractItem(child, source);
+    if (item) items.push(item);
+    else items.push(...collectItems(child, source));
   }
 
   return items;

package/node_modules/@mrclrchtr/supi-tree-sitter/src/types.ts

@@ -79,7 +79,10 @@ export interface TreeSitterService {
   canParse(file: string): Promise<TreeSitterResult<{ file: string; language: string }>>;
   /** Run a Tree-sitter query and return all captures. */
   query(file: string, queryString: string): Promise<TreeSitterResult<QueryCapture[]>>;
-  /** Extract top-level declarations plus supported class/interface/enum members. */
+  /**
+   * Extract shallow declarations, including supported nested code members,
+   * HTML ids, and SQL schema members.
+   */
   outline(file: string): Promise<TreeSitterResult<OutlineItem[]>>;
   /** Extract static ES import declarations. */
   imports(file: string): Promise<TreeSitterResult<ImportRecord[]>>;
@@ -143,7 +146,6 @@ export type SupportedExtension =
   | ".pyi"
   | ".rs"
   | ".go"
-  | ".mod"
   | ".c"
   | ".h"
   | ".cpp"
@@ -157,9 +159,11 @@ export type SupportedExtension =
   | ".kt"
   | ".kts"
   | ".rb"
+  | ".gemspec"
   | ".sh"
   | ".bash"
   | ".zsh"
+  | ".ksh"
   | ".html"
   | ".htm"
   | ".xhtml"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-intelligence",
-  "version": "4.1.0",
+  "version": "4.3.0",
   "description": "SuPi Code Intelligence extension — workspace orientation, target resolution and inspection, relationship analysis, code-aware search, live health, and semantic refactoring for pi",
   "license": "MIT",
   "repository": {
@@ -34,10 +34,10 @@
   ],
   "dependencies": {
     "yaml": "^2.9.0",
-    "@mrclrchtr/supi-core": "4.1.0",
-    "@mrclrchtr/supi-tree-sitter": "4.1.0",
-    "@mrclrchtr/supi-lsp": "4.1.0",
-    "@mrclrchtr/supi-code-runtime": "4.1.0"
+    "@mrclrchtr/supi-code-runtime": "4.3.0",
+    "@mrclrchtr/supi-core": "4.3.0",
+    "@mrclrchtr/supi-lsp": "4.3.0",
+    "@mrclrchtr/supi-tree-sitter": "4.3.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/src/analysis/search/pattern.ts

@@ -344,7 +344,7 @@ async function collectMatchesForFile(
   const outline = await structural.outline(relFile);
   if (!handleStructuralResult(outline, recordFailure)) return;
   for (const item of flattenOutlineItems(outline.data)) {
-    if (kind === "type" && !TYPE_LIKE_KINDS.has(item.kind.toLowerCase())) continue;
+    if (kind === "type" && !TYPE_KIND.test(item.kind.toLowerCase())) continue;
     if (kind === "interface" && item.kind.toLowerCase() !== "interface") continue;
     if (kind === "class" && item.kind.toLowerCase() !== "class") continue;
     if (kind === "method" && item.kind.toLowerCase() !== "method") continue;
@@ -368,7 +368,7 @@ function handleStructuralResult<T>(
   return false;
 }
 
-const TYPE_LIKE_KINDS = new Set(["class", "interface", "type", "enum"]);
+const TYPE_KIND = /^(?:class|interface|type|enum|struct|union|record|object|concept)$/;
 
 const AST_KIND_OPERATIONS = {
   definition: "outline",

package/src/analysis/target/symbol.ts

@@ -117,7 +117,10 @@ export async function resolveSymbolTarget(
     };
   }
   if (result.data.length === 0) {
-    return { kind: "error", message: `Symbol not found: \`${symbol}\`` };
+    return {
+      kind: "error",
+      message: `Symbol not found: \`${symbol}\`. Try \`code_resolve\` to search for it, or use an anchor target (file/line/character) if you know the location.`,
+    };
   }
 
   const scopePath = options?.path ? normalizePath(options.path, cwd) : null;
@@ -130,7 +133,7 @@ export async function resolveSymbolTarget(
   if (eligible.length === 0) {
     return {
       kind: "error",
-      message: `Symbol not found: \`${symbol}\`${scopePath ? ` in path \`${options?.path}\`` : ""}`,
+      message: `Symbol not found: \`${symbol}\`${scopePath ? ` in path \`${options?.path}\`` : ""}. Try \`code_resolve\` to search for it, or use an anchor target (file/line/character) if you know the location.`,
     };
   }
 

package/src/extension.ts

@@ -43,7 +43,11 @@ export default function codeIntelligenceExtension(
   );
 
   registerCiStatusCommand(pi);
-  registerLspFooterContribution(lspState);
+  const lspFooter = registerLspFooterContribution(pi, lspState);
+
+  pi.on("session_shutdown", () => {
+    lspFooter.dispose();
+  });
 
   pi.on("before_agent_start", (event, ctx) => {
     const session = app.getSession(ctx.cwd) ?? app.createSession(ctx.cwd);