@sean.holung/minicode 0.3.4 → 0.3.5

package/dist/src/web/app.js

@@ -1443,6 +1443,86 @@ function buildStylesheet() {
   return styles;
 }
 
+// src/shared/graph-symbols.ts
+function dedupe(values) {
+  return [...new Set(values.filter((value) => value.length > 0))];
+}
+function stripCollisionSuffix(value) {
+  const hashIndex = value.indexOf("#");
+  return hashIndex >= 0 ? value.slice(0, hashIndex) : value;
+}
+function stripDisplayKindSuffix(value) {
+  return value.replace(/\s+\([^()]+\)$/, "");
+}
+function getGraphNodeId(node, fallbackId = "") {
+  return node.qualifiedName || node.id || fallbackId || node.name || "";
+}
+function getGraphNodeLabel(node, fallbackId = "") {
+  const label = node.name?.trim();
+  if (label && label.length > 0) {
+    return label;
+  }
+  const id = getGraphNodeId(node, fallbackId);
+  return id.split(".").pop() || id;
+}
+function getGraphNodeAliases(node, fallbackId = "") {
+  const id = getGraphNodeId(node, fallbackId);
+  const label = getGraphNodeLabel(node, fallbackId);
+  const shortId = id.split(".").pop() || id;
+  return dedupe([
+    id,
+    node.id ?? "",
+    node.qualifiedName ?? "",
+    label,
+    stripDisplayKindSuffix(label),
+    shortId,
+    stripCollisionSuffix(shortId),
+    stripCollisionSuffix(id)
+  ]);
+}
+function compareLabels(a, b2) {
+  return a.localeCompare(b2, void 0, { sensitivity: "base" });
+}
+function compareGraphNodeIds(a, b2, nodes) {
+  const nodeA = nodes.get(a);
+  const nodeB = nodes.get(b2);
+  const exportedA = nodeA ? Number(!!nodeA.exported) : 0;
+  const exportedB = nodeB ? Number(!!nodeB.exported) : 0;
+  if (exportedA !== exportedB) {
+    return exportedB - exportedA;
+  }
+  const labelA = getGraphNodeLabel(nodeA ?? {}, a);
+  const labelB = getGraphNodeLabel(nodeB ?? {}, b2);
+  const labelComparison = compareLabels(labelA, labelB);
+  if (labelComparison !== 0) {
+    return labelComparison;
+  }
+  return compareLabels(a, b2);
+}
+function matchesGraphNodeQuery(query, node, fallbackId = "") {
+  const normalizedQuery = query.trim().toLowerCase();
+  if (normalizedQuery.length === 0) {
+    return false;
+  }
+  return getGraphNodeAliases(node, fallbackId).some(
+    (alias) => alias.toLowerCase().includes(normalizedQuery)
+  );
+}
+function resolveGraphNodeIds(nodes, symbolName) {
+  const query = symbolName.trim();
+  if (query.length === 0) {
+    return [];
+  }
+  if (nodes.has(query)) {
+    return [query];
+  }
+  const exactMatches = [...nodes.entries()].filter(([id, node]) => getGraphNodeAliases(node, id).includes(query)).map(([id]) => id).sort((a, b2) => compareGraphNodeIds(a, b2, nodes));
+  if (exactMatches.length > 0) {
+    return exactMatches;
+  }
+  return [...nodes.entries()].filter(([id, node]) => matchesGraphNodeQuery(query, node, id)).map(([id]) => id).sort((a, b2) => compareGraphNodeIds(a, b2, nodes));
+}
+
 // src/web/graph.ts
 var cy = null;
 var graphNodes = /* @__PURE__ */ new Map();
@@ -1537,7 +1617,7 @@ async function initGraph() {
 }
 function highlightAgentActivity(symbolName) {
   if (!cy) return;
-  void focusSymbolInGraph(symbolName, {
+  void focusResolvedSymbolsInGraph(symbolName, {
     maxDegrees: 0,
     pulse: true,
     pulseDuration: 2e3,
@@ -1611,6 +1691,16 @@ function renderNodeNeighborhoodAndLayout(symbolId, maxDegrees = 1) {
   }
 }
 async function focusSymbolInGraph(symbolId, options = {}) {
+  await focusSymbolsInGraph([symbolId], options);
+}
+async function focusResolvedSymbolsInGraph(symbolName, options = {}) {
+  const matches = resolveGraphNodeIds(graphNodes, symbolName);
+  if (matches.length === 0) {
+    return;
+  }
+  await focusSymbolsInGraph(matches, options);
+}
+async function focusSymbolsInGraph(symbolIds, options = {}) {
   if (!cy) return;
   const {
     maxDegrees = 0,
@@ -1621,21 +1711,38 @@ async function focusSymbolInGraph(symbolId, options = {}) {
     flashDuration = 1200,
     openDetail = false
   } = options;
-  renderNodeNeighborhoodAndLayout(symbolId, maxDegrees);
-  const node = findNode(symbolId);
-  if (!node) return;
-  if (animate) {
-    cy.animate({ center: { eles: node }, zoom }, { duration: 300 });
-  }
-  if (pulse) {
-    node.addClass("agent-pulse");
-    setTimeout(() => node.removeClass("agent-pulse"), pulseDuration);
-  } else {
-    node.flashClass("highlighted", flashDuration);
+  const uniqueIds = [...new Set(symbolIds)];
+  let addedNodes = false;
+  for (const symbolId of uniqueIds) {
+    const beforeNodeCount = cy.nodes().length;
+    addNodeNeighborhood(symbolId, maxDegrees);
+    if (cy.nodes().length > beforeNodeCount) {
+      addedNodes = true;
+    }
+  }
+  connectExistingNodes();
+  refreshAnalysisGraphState();
+  if (addedNodes) {
+    runLayout();
+  }
+  const nodes = uniqueIds.map((symbolId) => findNode(symbolId)).filter((node) => node !== null);
+  if (nodes.length === 0) return;
+  const primaryNode = nodes[0];
+  if (animate && primaryNode) {
+    cy.animate({ center: { eles: primaryNode }, zoom }, { duration: 300 });
   }
-  if (openDetail) {
+  for (const node of nodes) {
+    if (pulse) {
+      node.addClass("agent-pulse");
+      setTimeout(() => node.removeClass("agent-pulse"), pulseDuration);
+    } else {
+      node.flashClass("highlighted", flashDuration);
+    }
+  }
+  if (openDetail && primaryNode && uniqueIds.length === 1) {
     const detailEl = document.getElementById("symbol-detail");
     if (detailEl) {
+      const node = primaryNode;
       await showDetail(node, detailEl);
     }
   }
@@ -1650,7 +1757,7 @@ function addNodeToGraph(id) {
   const nodeData = graphNodes.get(id);
   if (!nodeData) return;
   const kind = (nodeData.kind || "function").toLowerCase();
-  const name = nodeData.name || id.split(".").pop() || id;
+  const name = getGraphNodeLabel(nodeData, id);
   const file = nodeData.filePath || nodeData.file || "";
   cy.add({
     data: {
@@ -1691,11 +1798,10 @@ function findNode(name) {
   if (!cy) return null;
   const node = cy.getElementById(name);
   if (node.length > 0) return node;
-  const match = cy.nodes().filter((n) => {
-    const nName = n.data("name") || "";
-    const qName = n.data("qualifiedName") || "";
-    return nName === name || qName.endsWith("." + name);
-  });
+  const matchingIds = new Set(resolveGraphNodeIds(graphNodes, name));
+  const match = cy.nodes().filter(
+    (n) => matchingIds.has(n.data("qualifiedName") || n.data("id") || "")
+  );
   return match.length > 0 ? match : null;
 }
 function getAnalysisPanelEls() {
@@ -2335,16 +2441,7 @@ function setupToolbar() {
   dropdown.className = "search-dropdown hidden";
   searchInput.parentNode.style.position = "relative";
   searchInput.parentNode.appendChild(dropdown);
-  const rankedSymbols = allSymbolNames.slice().sort((a, b2) => {
-    const nodeA = graphNodes.get(a);
-    const nodeB = graphNodes.get(b2);
-    const expA = nodeA ? !!nodeA.exported : false;
-    const expB = nodeB ? !!nodeB.exported : false;
-    if (expA !== expB) return expA ? -1 : 1;
-    const nameA = (a.split(".").pop() || "").toLowerCase();
-    const nameB = (b2.split(".").pop() || "").toLowerCase();
-    return nameA.localeCompare(nameB);
-  });
+  const rankedSymbols = allSymbolNames.slice().sort((a, b2) => compareGraphNodeIds(a, b2, graphNodes));
   function showDropdownResults(matches) {
     if (matches.length === 0) {
       dropdown.classList.add("hidden");
@@ -2353,7 +2450,7 @@ function setupToolbar() {
     dropdown.innerHTML = matches.map((name) => {
       const node = graphNodes.get(name);
       const kind = node ? (node.kind || "").toLowerCase() : "";
-      const shortName = name.split(".").pop() || name;
+      const shortName = getGraphNodeLabel(node || {}, name);
       const kindColor = KIND_COLORS[kind] ? KIND_COLORS[kind].border : "#565f89";
       return `<div class="search-result" data-id="${escapeHtml(name)}">
         <span class="search-result-name">${escapeHtml(shortName)}</span>
@@ -2390,8 +2487,7 @@ function setupToolbar() {
         return;
       }
       const matches = rankedSymbols.filter((name) => {
-        const shortName = (name.split(".").pop() || "").toLowerCase();
-        return shortName.includes(query) || name.toLowerCase().includes(query);
+        return matchesGraphNodeQuery(query, graphNodes.get(name) || {}, name);
       }).slice(0, 15);
       showDropdownResults(matches);
     }, 150);
@@ -2438,6 +2534,20 @@ function setupToolbar() {
   });
 }
 
+// src/web/request-tracker.ts
+function createLatestRequestTracker() {
+  let latestToken = 0;
+  return {
+    begin() {
+      latestToken += 1;
+      return latestToken;
+    },
+    isCurrent(token) {
+      return token === latestToken;
+    }
+  };
+}
+
 // src/web/app.ts
 var messagesEl = document.getElementById("messages");
 var chatForm = document.getElementById("chat-form");
@@ -2473,6 +2583,7 @@ var assistantText = "";
 var hadToolCalls = false;
 var settingsPayload = null;
 var activeSavedSession = null;
+var sessionRefreshTracker = createLatestRequestTracker();
 var TOOL_RESULT_MAX = 500;
 function connect() {
   const protocol = location.protocol === "https:" ? "wss:" : "ws:";
@@ -3023,6 +3134,7 @@ saveBtn.addEventListener("click", async () => {
   const label = requestedLabel || activeSavedSession?.label || void 0;
   const isUpdatingCurrentSession = !!activeSavedSession && (requestedLabel.length === 0 || requestedLabel === activeSavedSession.label);
   try {
+    saveBtn.setAttribute("disabled", "true");
     const res = await fetch("/api/sessions/save", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -3035,9 +3147,11 @@ saveBtn.addEventListener("click", async () => {
         `${isUpdatingCurrentSession ? "Session updated" : "Session saved"}: "${data.label}"`,
         "thinking"
       );
-      void refreshSessionList();
+      await refreshSessionList();
     }
   } catch {
+  } finally {
+    saveBtn.removeAttribute("disabled");
   }
 });
 saveLabelInput.addEventListener("keydown", (e) => {
@@ -3047,9 +3161,13 @@ saveLabelInput.addEventListener("keydown", (e) => {
   }
 });
 async function refreshSessionList() {
+  const requestToken = sessionRefreshTracker.begin();
   try {
     const res = await fetch("/api/sessions");
     const data = await res.json();
+    if (!sessionRefreshTracker.isCurrent(requestToken)) {
+      return;
+    }
     const sessions = data.sessions;
     activeSavedSession = sessions.find((session) => session.id === data.currentSessionId) ?? null;
     if (activeSavedSession) {
@@ -3075,6 +3193,9 @@ async function refreshSessionList() {
       sessionList.appendChild(el);
     }
   } catch {
+    if (!sessionRefreshTracker.isCurrent(requestToken)) {
+      return;
+    }
     activeSavedSession = null;
     sessionUpdateRow.classList.add("hidden");
     sessionList.innerHTML = '<div class="dropdown-empty">Failed to load sessions</div>';

package/dist/tests/benchmark-harness.test.js

@@ -40,6 +40,8 @@ function makeTrace(overrides = {}) {
         model: "test-model",
         variant: "baseline",
         commitSha: "abc123",
+        sourceWorkspaceRoot: "/workspace/source",
+        workspaceRoot: "/tmp/minicode-benchmark/task",
         response: "Found foo in src/foo.ts at line 10.",
         toolCalls: [
             { name: "search", input: { query: "foo" }, output: "src/foo.ts:10", durationMs: 50 },
@@ -141,6 +143,24 @@ test("loadBenchmarkTask loads a single task by id", async () => {
         await rm(tmpDir, { recursive: true });
     }
 });
+test("loadBenchmarkTask preserves workspaceRoot when provided", async () => {
+    const tmpDir = await mkdtemp(path.join(tmpdir(), "bench-workspace-root-"));
+    await mkdir(path.join(tmpDir, "navigation", "fixture-task"), { recursive: true });
+    await writeFile(path.join(tmpDir, "navigation", "fixture-task", "task.json"), JSON.stringify({
+        title: "Fixture task",
+        prompt: "Use a fixture workspace",
+        workspaceRoot: "test-programs/benchmark-index",
+        rubric: {},
+    }));
+    try {
+        const task = await loadBenchmarkTask(tmpDir, "navigation/fixture-task");
+        assert.ok(task);
+        assert.equal(task.workspaceRoot, "test-programs/benchmark-index");
+    }
+    finally {
+        await rm(tmpDir, { recursive: true, force: true });
+    }
+});
 test("loadBenchmarkTask returns undefined for missing task", async () => {
     const tmpDir = await createTempTaskDir();
     try {
@@ -413,6 +433,86 @@ test("runBenchmarkTask tracks symbols from structural tools", async () => {
     });
     assert.ok(trace.symbolsQueried.includes("CodingAgent"));
 });
+test("runBenchmarkTask resolves task workspace overrides and isolates the run", async () => {
+    const repoRoot = await mkdtemp(path.join(tmpdir(), "bench-repo-root-"));
+    const sourceWorkspace = path.join(repoRoot, "fixtures", "sample-project");
+    await mkdir(path.join(sourceWorkspace, "src"), { recursive: true });
+    await writeFile(path.join(sourceWorkspace, "src", "index.ts"), "export const answer = 42;\n");
+    const task = {
+        id: "navigation/workspace-root",
+        title: "Workspace root test",
+        category: "navigation",
+        prompt: "Inspect the fixture workspace",
+        workspaceRoot: "fixtures/sample-project",
+        rubric: {},
+    };
+    try {
+        const config = createTestAgentConfig(repoRoot);
+        const trace = await runBenchmarkTask(task, {
+            modelClient: new MockModelClient("done"),
+            config,
+            tools: [],
+            variant: "test",
+            repoRoot,
+        });
+        assert.equal(trace.sourceWorkspaceRoot, sourceWorkspace);
+        assert.notEqual(trace.workspaceRoot, sourceWorkspace);
+        assert.ok(trace.workspaceRoot.includes("minicode-benchmark-"));
+    }
+    finally {
+        await rm(repoRoot, { recursive: true, force: true });
+    }
+});
+test("runBenchmarkTask uses project index metadata to count read_symbol as a file read", async () => {
+    const workspaceRoot = path.resolve(import.meta.dirname, "..");
+    const task = {
+        id: "navigation/structural-file-tracking",
+        title: "Structural file tracking",
+        category: "navigation",
+        prompt: "Read the CodingAgent symbol",
+        rubric: {},
+    };
+    let callCount = 0;
+    const mockClient = {
+        async chat(params) {
+            void params;
+            callCount += 1;
+            if (callCount === 1) {
+                return {
+                    text: "Looking up symbol",
+                    toolCalls: [{ id: "t1", name: "read_symbol", input: { name: "CodingAgent" } }],
+                    stopReason: "tool_use",
+                    usage: { inputTokens: 100, outputTokens: 50 },
+                };
+            }
+            return {
+                text: "Found CodingAgent",
+                toolCalls: [],
+                stopReason: "end_turn",
+                usage: { inputTokens: 100, outputTokens: 50 },
+            };
+        },
+    };
+    const config = createTestAgentConfig(workspaceRoot);
+    const trace = await runBenchmarkTask(task, {
+        modelClient: mockClient,
+        config,
+        variant: "v1",
+        isolateWorkspace: false,
+        createToolset: async (taskConfig) => {
+            const { buildProjectIndex } = await import("../src/indexer/project-index.js");
+            const { createToolRegistry } = await import("../src/tools/registry.js");
+            const projectIndex = await buildProjectIndex(taskConfig.workspaceRoot);
+            const toolRegistry = createToolRegistry(taskConfig, projectIndex);
+            return {
+                tools: toolRegistry.getDefinitions(),
+                projectIndex,
+            };
+        },
+    });
+    assert.ok(trace.symbolsQueried.includes("CodingAgent"));
+    assert.ok(trace.filesRead.some((file) => file.endsWith("packages/agent-sdk/src/agent/agent.ts")), "read_symbol should count the owning file as read");
+});
 // ─── Reporter Tests ────────────────────────────────────────────
 test("buildReport generates correct summary", () => {
     const tasks = [

package/dist/tests/file-tools.test.js

@@ -3,7 +3,7 @@ import { mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { test } from "node:test";
-import { createEditFileTool, createReadFileTool } from "@minicode/agent-sdk";
+import { createEditFileTool, createReadFileTool, createRunCommandTool, createWriteFileTool } from "@minicode/agent-sdk";
 import { buildProjectIndex } from "../src/indexer/project-index.js";
 import { createTestAgentConfig } from "./test-utils.js";
 async function createTempWorkspace() {
@@ -58,6 +58,39 @@ test("edit_file triggers reindex when projectIndex provided", async () => {
     const after = index.getSymbol("add");
     assert.ok(after?.signature.includes("c?: number"), "index should reflect edit");
 });
+test("write_file triggers reindex when projectIndex provided", async () => {
+    const workspaceRoot = await createTempWorkspace();
+    const index = await buildProjectIndex(workspaceRoot);
+    const writeTool = createWriteFileTool(createTestAgentConfig(workspaceRoot), { afterWrite: (relPath, content) => index.reindexFile(relPath, content) });
+    await writeTool.execute({
+        path: "src/util.ts",
+        content: `export function add(a: number, b: number): number {\n  return a + b;\n}\n`,
+    });
+    const added = index.getSymbol("add");
+    assert.ok(added?.signature.includes("a: number, b: number"), "index should reflect newly written file");
+});
+test("run_command refreshes index after shell-created file changes", async () => {
+    const workspaceRoot = await createTempWorkspace();
+    const index = await buildProjectIndex(workspaceRoot);
+    const runTool = createRunCommandTool(createTestAgentConfig(workspaceRoot), { afterCommand: async () => index.refreshFromWorkspace() });
+    await runTool.execute({
+        command: "mkdir -p src && cat <<'EOF' > src/util.ts\nexport function add(a: number, b: number): number {\n  return a + b;\n}\nEOF",
+    });
+    const added = index.getSymbol("add");
+    assert.ok(added?.signature.includes("a: number, b: number"), "index should reflect shell-created file");
+});
+test("run_command refresh removes deleted files from the index", async () => {
+    const workspaceRoot = await createTempWorkspace();
+    const { mkdir } = await import("node:fs/promises");
+    const filePath = path.join(workspaceRoot, "src", "util.ts");
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `export function add(a: number, b: number): number {\n  return a + b;\n}\n`, "utf8");
+    const index = await buildProjectIndex(workspaceRoot);
+    assert.ok(index.getSymbol("add"));
+    const runTool = createRunCommandTool(createTestAgentConfig(workspaceRoot), { afterCommand: async () => index.refreshFromWorkspace() });
+    await runTool.execute({ command: "rm src/util.ts" });
+    assert.equal(index.getSymbol("add"), undefined, "deleted file should be removed from the index");
+});
 test("read_file supports negative offset and line limits", async () => {
     const workspaceRoot = await createTempWorkspace();
     const filePath = path.join(workspaceRoot, "lines.txt");

package/dist/tests/find-path.test.js

@@ -1,7 +1,9 @@
 import assert from "node:assert/strict";
 import path from "node:path";
 import { test } from "node:test";
-import { createProjectIndex } from "../src/indexer/project-index.js";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { buildProjectIndex, createProjectIndex } from "../src/indexer/project-index.js";
 import { createFindPathTool } from "../src/tools/find-path.js";
 function makeSymbol(name, kind = "function") {
     return {
@@ -169,7 +171,6 @@ test("find_path tool reports no path when symbols are disconnected", async () =>
     assert.ok(result.includes("No path found"));
 });
 test("find_path tool works with real project index", async () => {
-    const { buildProjectIndex } = await import("../src/indexer/project-index.js");
     const root = path.resolve(import.meta.dirname, "..");
     const projectIndex = await buildProjectIndex(root);
     const tool = createFindPathTool(projectIndex);
@@ -181,3 +182,43 @@ test("find_path tool works with real project index", async () => {
     assert.ok(result.includes("# Path from createModelClient to AgentConfig"));
     assert.ok(result.includes("symbols"));
 });
+test("find_path returns disambiguation list for ambiguous bare target symbols", async () => {
+    const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-find-path-collisions-"));
+    await writeFile(path.join(workspaceRoot, "sample.ts"), `export type Review = { id: string };
+
+export class Review {
+  constructor(public id: string) {}
+}
+
+export function createReview(id: string) {
+  return new Review(id);
+}
+`, "utf8");
+    const projectIndex = await buildProjectIndex(workspaceRoot);
+    const tool = createFindPathTool(projectIndex);
+    const result = await tool.execute({ from: "createReview", to: "Review" });
+    assert.ok(result.includes('Symbol "Review" is ambiguous'));
+    assert.ok(result.includes("Review (type)"));
+    assert.ok(result.includes("Review (class)"));
+    assert.ok(result.includes("qualified: Review#type"));
+    assert.ok(result.includes("qualified: Review#class"));
+});
+test("find_path accepts qualified names for colliding symbols", async () => {
+    const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-find-path-qualified-"));
+    await writeFile(path.join(workspaceRoot, "sample.ts"), `export type Review = { id: string };
+
+export class Review {
+  constructor(public id: string) {}
+}
+
+export function createReview(id: string) {
+  return new Review(id);
+}
+`, "utf8");
+    const projectIndex = await buildProjectIndex(workspaceRoot);
+    const tool = createFindPathTool(projectIndex);
+    const result = await tool.execute({ from: "createReview", to: "Review#class" });
+    assert.ok(result.includes("# Path from createReview to Review (class)"));
+    assert.ok(result.includes("[function] createReview"));
+    assert.ok(result.includes("[class] Review (class)"));
+});

package/dist/tests/find-references.test.js

@@ -1,6 +1,8 @@
 import assert from "node:assert/strict";
 import path from "node:path";
 import { test } from "node:test";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { buildProjectIndex } from "../src/indexer/project-index.js";
 import { createFindReferencesTool } from "../src/tools/find-references.js";
 test("find_references returns symbols that reference ProjectIndex", async () => {
@@ -28,3 +30,50 @@ test("find_references appears in tool registry when projectIndex provided", asyn
     const findRefs = schemas.find((s) => s.name === "find_references");
     assert.ok(findRefs);
 });
+test("find_references returns disambiguation list for ambiguous bare symbol names", async () => {
+    const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-find-references-collisions-"));
+    await writeFile(path.join(workspaceRoot, "sample.ts"), `export type Review = { id: string };
+
+export function serializeReview(review: Review) {
+  return review.id;
+}
+
+export class Review {
+  constructor(public id: string) {}
+}
+
+export function createReview(id: string) {
+  return new Review(id);
+}
+`, "utf8");
+    const projectIndex = await buildProjectIndex(workspaceRoot);
+    const tool = createFindReferencesTool(projectIndex);
+    const result = await tool.execute({ name: "Review" });
+    assert.ok(result.includes('Symbol "Review" is ambiguous'));
+    assert.ok(result.includes("Review (type)"));
+    assert.ok(result.includes("Review (class)"));
+    assert.ok(result.includes("qualified: Review#type"));
+    assert.ok(result.includes("qualified: Review#class"));
+});
+test("find_references accepts qualified names for colliding symbols", async () => {
+    const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-find-references-qualified-"));
+    await writeFile(path.join(workspaceRoot, "sample.ts"), `export type Review = { id: string };
+
+export function serializeReview(review: Review) {
+  return review.id;
+}
+
+export class Review {
+  constructor(public id: string) {}
+}
+
+export function createReview(id: string) {
+  return new Review(id);
+}
+`, "utf8");
+    const projectIndex = await buildProjectIndex(workspaceRoot);
+    const tool = createFindReferencesTool(projectIndex);
+    const result = await tool.execute({ name: "Review#class" });
+    assert.ok(result.includes("# References to Review (class)"));
+    assert.ok(result.includes("createReview"));
+});

package/dist/tests/get-dependencies.test.js

@@ -1,6 +1,8 @@
 import assert from "node:assert/strict";
 import path from "node:path";
 import { test } from "node:test";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { buildProjectIndex } from "../src/indexer/project-index.js";
 import { createGetDependenciesTool } from "../src/tools/get-dependencies.js";
 test("get_dependencies returns dependency cone for createModelClient", async () => {
@@ -33,3 +35,24 @@ test("get_dependencies returns error for unknown symbol", async () => {
     const result = await tool.execute({ name: "NonExistent" });
     assert.ok(result.includes("not found"));
 });
+test("get_dependencies returns disambiguation list for ambiguous bare symbol names", async () => {
+    const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-get-dependencies-collisions-"));
+    await writeFile(path.join(workspaceRoot, "sample.ts"), `export type Review = { id: string };
+
+export class Review {
+  constructor(public id: string) {}
+}
+
+export function createReview(id: string) {
+  return new Review(id);
+}
+`, "utf8");
+    const projectIndex = await buildProjectIndex(workspaceRoot);
+    const tool = createGetDependenciesTool(projectIndex);
+    const result = await tool.execute({ name: "Review" });
+    assert.ok(result.includes('Symbol "Review" is ambiguous'));
+    assert.ok(result.includes("Review (type)"));
+    assert.ok(result.includes("Review (class)"));
+    assert.ok(result.includes("qualified: Review#type"));
+    assert.ok(result.includes("qualified: Review#class"));
+});

package/dist/tests/graph-symbols.test.js

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { compareGraphNodeIds, getGraphNodeLabel, matchesGraphNodeQuery, resolveGraphNodeIds, } from "../src/shared/graph-symbols.js";
+test("getGraphNodeLabel prefers display names for graph collisions", () => {
+    assert.equal(getGraphNodeLabel({ name: "Review (class)", qualifiedName: "Review#class" }), "Review (class)");
+    assert.equal(getGraphNodeLabel({ qualifiedName: "Session.trim" }), "trim");
+});
+test("resolveGraphNodeIds returns all exact bare-name collisions", () => {
+    const nodes = new Map([
+        ["Review#type", { name: "Review (type)", qualifiedName: "Review#type", exported: true }],
+        ["Review#class", { name: "Review (class)", qualifiedName: "Review#class", exported: true }],
+        ["Review.constructor", { name: "Review.constructor", qualifiedName: "Review.constructor", exported: false }],
+    ]);
+    assert.deepEqual(resolveGraphNodeIds(nodes, "Review"), [
+        "Review#class",
+        "Review#type",
+    ]);
+    assert.deepEqual(resolveGraphNodeIds(nodes, "Review (class)"), [
+        "Review#class",
+    ]);
+    assert.deepEqual(resolveGraphNodeIds(nodes, "Review#type"), [
+        "Review#type",
+    ]);
+});
+test("matchesGraphNodeQuery supports disambiguated labels and bare collision names", () => {
+    const typeNode = { name: "Review (type)", qualifiedName: "Review#type" };
+    const classNode = { name: "Review (class)", qualifiedName: "Review#class" };
+    assert.equal(matchesGraphNodeQuery("Review", typeNode, "Review#type"), true);
+    assert.equal(matchesGraphNodeQuery("Review", classNode, "Review#class"), true);
+    assert.equal(matchesGraphNodeQuery("class", classNode, "Review#class"), true);
+    assert.equal(matchesGraphNodeQuery("type", classNode, "Review#class"), false);
+});
+test("compareGraphNodeIds sorts exported collisions by label", () => {
+    const nodes = new Map([
+        ["Review#type", { name: "Review (type)", qualifiedName: "Review#type", exported: true }],
+        ["Review#class", { name: "Review (class)", qualifiedName: "Review#class", exported: true }],
+        ["internalReviewHelper", { name: "internalReviewHelper", qualifiedName: "internalReviewHelper", exported: false }],
+    ]);
+    const sorted = [...nodes.keys()].sort((a, b) => compareGraphNodeIds(a, b, nodes));
+    assert.deepEqual(sorted, [
+        "Review#class",
+        "Review#type",
+        "internalReviewHelper",
+    ]);
+});