@sean.holung/minicode 0.3.11 → 0.4.1

package/dist/src/tools/search-code-map.js

@@ -1,13 +1,99 @@
-import { expectNonEmptyString, expectOptionalNumber } from "@minicode/agent-sdk";
+import { expectNonEmptyString, expectOptionalNumber } from "@sean.holung/minicode-sdk";
 import { getSymbolDisplayName, getSymbolLookupNames } from "../indexer/symbol-names.js";
 import { searchSymbols } from "../shared/symbol-search.js";
 const DEFAULT_LIMIT = 30;
+const DOC_SUMMARY_MAX_CHARS = 100;
+/**
+ * Strip JSDoc/block-comment markers and return the first non-empty line of
+ * the comment, truncated.
+ *
+ * Surfacing this beside each match in `search_code_map` output is what
+ * addresses the disambiguation failure case from issue #184: when a search
+ * returns several similar-named symbols (e.g. `ToolRegistry` class +
+ * `createToolRegistry` wrapper + `ToolRegistry.createDefault` method), the
+ * model has no way to pick the right one from kind+path alone. The doc
+ * summary tells it which is which.
+ */
+export function summarizeDocComment(doc) {
+    if (!doc) {
+        return "";
+    }
+    // Strip leading /** and trailing */ — defense-in-depth; symbol indexing
+    // already cleans most of this.
+    const lines = doc
+        .replace(/^\s*\/\*\*?/, "")
+        .replace(/\*\/\s*$/, "")
+        // TS compiler can emit JSDoc with `\r` line separators (not `\n`),
+        // so we split on both. Without this, the entire comment becomes a
+        // single "line" and the truncation chops mid-paragraph rather than
+        // at the first description sentence.
+        .split(/\r\n|\r|\n/)
+        .map((line) => line.replace(/^\s*\*\s?/, "").trim())
+        .filter((line) => line.length > 0);
+    if (lines.length === 0) {
+        return "";
+    }
+    const first = lines[0];
+    if (first.length <= DOC_SUMMARY_MAX_CHARS) {
+        return first;
+    }
+    return `${first.slice(0, DOC_SUMMARY_MAX_CHARS - 3)}...`;
+}
+/**
+ * When a search returns matches of multiple symbol kinds (class, function,
+ * method, …) for what is likely the same conceptual name, the model can
+ * confidently pick the wrong one — particularly for queries like
+ * `ToolRegistry` that resolve to a class, several class methods, and a
+ * standalone wrapper function. This is exactly the failure shape from
+ * issue #184. We surface the ambiguity so the model knows to refine
+ * rather than guess.
+ *
+ * The hint fires only on cross-kind ambiguity (class/interface/type AND
+ * function/method) — the typical "noun vs. verb" shape (`Foo` class vs.
+ * `createFoo()` factory). Methods alone alongside their class are
+ * structurally expected and not flagged.
+ */
+export function buildAmbiguityHint(matches) {
+    const kinds = new Set(matches.map((m) => m.kind));
+    if (kinds.size <= 1) {
+        return "";
+    }
+    const hasNoun = kinds.has("class") || kinds.has("interface") || kinds.has("type");
+    // Standalone functions only — class methods alongside their class
+    // (e.g. `Widget` + `Widget.init`) are a structurally expected pairing,
+    // not a disambiguation problem. The model already understands that
+    // `Foo.method` is a member of `Foo`. The real confusion is between a
+    // type-name and a same-base-name standalone function (`Widget` class
+    // vs. `createWidget()` factory).
+    //
+    // Trade-off: this deliberately under-flags the rarer cross-class case
+    // (`class Widget` in one file plus an unrelated `widget()` method on
+    // some other class). Adding `method` to the verb set would close that
+    // gap but would also make the hint fire on every class-with-its-own-
+    // methods search, which is by far the more common shape — false
+    // positives there would be louder than the missed cross-class case.
+    const hasStandaloneVerb = kinds.has("function");
+    if (!hasNoun || !hasStandaloneVerb) {
+        return "";
+    }
+    return [
+        "Note: results span multiple symbol kinds. A class/interface/type and a function/method with similar",
+        "names usually have different responsibilities (e.g. `Foo` class vs. `createFoo()` factory). Read the",
+        "doc summaries below or call `read_symbol` on a specific candidate before assuming which one the",
+        "question is about.",
+    ].join("\n");
+}
+function formatMatchLine(s) {
+    const main = `- ${getSymbolDisplayName(s)} (${s.kind}) — ${s.filePath}:${s.startLine} — qualified: ${s.qualifiedName}`;
+    const summary = summarizeDocComment(s.docComment);
+    return summary ? `${main}\n    └─ ${summary}` : main;
+}
 export function createSearchCodeMapTool(projectIndex) {
     return {
         name: "search_code_map",
         description: "Search the full project index for symbols by name or substring. " +
             "Use when the code map is truncated and you need to find a symbol not listed. " +
-            "Returns disambiguated display names, qualified names, and file paths; use read_symbol with the result.",
+            "Returns disambiguated display names, qualified names, file paths, and a one-line doc summary; use read_symbol with the result.",
         inputSchema: {
             type: "object",
             properties: {
@@ -52,10 +138,10 @@ export function createSearchCodeMapTool(projectIndex) {
                 lookupNames: getSymbolLookupNames(sym),
             })), pattern, { kind, limit, skip });
             const shown = result.matches;
-            const lines = shown.map((s) => `- ${getSymbolDisplayName(s)} (${s.kind}) — ${s.filePath}:${s.startLine} — qualified: ${s.qualifiedName}`);
+            const lines = shown.map(formatMatchLine);
             const remaining = result.total - skip - shown.length;
             const footer = remaining > 0
-                ? `\n... and ${remaining} more (use skip: ${skip + limit}, limit: ${limit} for next page)`
+                ? `\n... and ${remaining} more. Use skip: ${skip + limit}, limit: ${limit} for the next page, or refine the pattern to narrow.`
                 : "";
             if (result.total === 0) {
                 return `No symbols matching "${pattern}"${kind ? ` (kind: ${kind})` : ""}. Try a shorter or different pattern.`;
@@ -70,12 +156,18 @@ export function createSearchCodeMapTool(projectIndex) {
                     footer,
                 ].join("\n");
             }
-            return [
+            const ambiguityHint = buildAmbiguityHint(shown);
+            const sections = [
                 `# Symbols matching "${pattern}" (${result.total} total)`,
-                "",
-                ...lines,
-                footer,
-            ].join("\n");
+            ];
+            if (ambiguityHint) {
+                sections.push("", ambiguityHint);
+            }
+            sections.push("", ...lines);
+            if (footer) {
+                sections.push(footer);
+            }
+            return sections.join("\n");
         },
     };
 }

package/dist/src/ui/cli-ink.js

@@ -1,5 +1,5 @@
 import process from "node:process";
-import { CodingAgent, createModelClient } from "@minicode/agent-sdk";
+import { CodingAgent, createModelClient } from "@sean.holung/minicode-sdk";
 import { loadAgentConfig, getConfigSetupMessage } from "../agent/config.js";
 import { handleConfigSlashCommand } from "../cli/config-slash-command.js";
 import { computeFileHashes, getWorkspaceCacheDir, loadIndex, saveIndex, } from "../indexer/cache.js";

package/dist/src/web/app.js

@@ -2580,7 +2580,7 @@ async function showDetail(node, detailEl) {
   html += '<div class="detail-section" id="detail-refs"><div class="detail-section-title">References</div><div class="detail-section-list">Loading...</div></div>';
   detailEl.innerHTML = '<div class="resize-handle"></div>' + html;
   detailEl.classList.remove("hidden");
-  syncDetailPanelLayout({ fit: true });
+  syncDetailPanelLayout();
   const handle = detailEl.querySelector(".resize-handle");
   handle.addEventListener("mousedown", (e) => {
     e.preventDefault();

package/dist/src/web/favicon.svg

@@ -0,0 +1,9 @@
+<svg width="64" height="64" viewBox="0 0 64 64" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <rect width="64" height="64" rx="16" fill="#0f172a"/>
+  <path d="M18 19L44 22M18 19L20 45M44 22L46 46M20 45L46 46M18 19L46 46" stroke="#38bdf8" stroke-width="3" stroke-linecap="round" opacity="0.65"/>
+  <circle cx="18" cy="19" r="7" fill="#e2e8f0"/>
+  <circle cx="44" cy="22" r="6" fill="#22d3ee"/>
+  <circle cx="20" cy="45" r="6" fill="#22d3ee"/>
+  <circle cx="46" cy="46" r="7" fill="#e2e8f0"/>
+  <path d="M18 19L46 46" stroke="#f8fafc" stroke-width="2" stroke-linecap="round" opacity="0.35"/>
+</svg>

package/dist/src/web/index.html

@@ -4,6 +4,8 @@
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>minicode</title>
+  <link rel="icon" type="image/svg+xml" href="/favicon.svg">
+  <link rel="icon" sizes="any" href="/favicon.ico">
   <link rel="stylesheet" href="style.css">
   <link rel="preconnect" href="https://fonts.googleapis.com">
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>

package/dist/tests/agent.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import path from "node:path";
 import { test } from "node:test";
-import { CodingAgent, ToolRegistry, } from "@minicode/agent-sdk";
+import { CodingAgent, ToolRegistry, } from "@sean.holung/minicode-sdk";
 import { buildProjectIndex } from "../src/indexer/project-index.js";
 import { createTestAgentConfig } from "./test-utils.js";
 class SequenceModelClient {

package/dist/tests/context-indicator.test.js

@@ -5,7 +5,7 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { createRequestHandler } from "../src/serve/server.js";
 import { AgentBridge } from "../src/serve/agent-bridge.js";
-import { CodingAgent, ToolRegistry, } from "@minicode/agent-sdk";
+import { CodingAgent, ToolRegistry, } from "@sean.holung/minicode-sdk";
 import { UiStore } from "../src/ui/state/ui-store.js";
 import { createTestAgentConfig } from "./test-utils.js";
 const distWeb = join(import.meta.dirname, "..", "dist", "src", "web");

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, createRunCommandTool, createWriteFileTool } from "@minicode/agent-sdk";
+import { createEditFileTool, createReadFileTool, createRunCommandTool, createWriteFileTool } from "@sean.holung/minicode-sdk";
 import { buildProjectIndex } from "../src/indexer/project-index.js";
 import { createToolRegistry } from "../src/tools/registry.js";
 import { createTestAgentConfig } from "./test-utils.js";
@@ -33,7 +33,7 @@ test("edit_file fails when old_string is not unique", async () => {
         path: "sample.txt",
         old_string: "repeat",
         new_string: "once",
-    }), /matched 3 times/);
+    }), /multiple matches/i);
     const unchanged = await readFile(filePath, "utf8");
     assert.equal(unchanged, "repeat repeat repeat");
 });

package/dist/tests/focus-tracker.test.js

@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { FocusTracker } from "@minicode/agent-sdk";
+import { FocusTracker } from "@sean.holung/minicode-sdk";
 test("FocusTracker tracks added symbols", () => {
     const tracker = new FocusTracker();
     tracker.addSymbol("Foo");

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

@@ -3,6 +3,7 @@ import { test } from 'node:test';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 const distWeb = join(import.meta.dirname, '..', 'dist', 'src', 'web');
+const graphSource = join(import.meta.dirname, '..', 'src', 'web', 'graph.ts');
 test('built CSS contains graph-onboarding styles', () => {
     const css = readFileSync(join(distWeb, 'style.css'), 'utf-8');
     assert.ok(css.includes('.graph-onboarding'), 'CSS should contain .graph-onboarding class');
@@ -23,11 +24,20 @@ test('built HTML contains #cy graph container', () => {
     const html = readFileSync(join(distWeb, 'index.html'), 'utf-8');
     assert.ok(html.includes('id="cy"'), 'HTML should contain the #cy graph container');
     assert.ok(html.includes('id="graph-pane"'), 'HTML should contain the #graph-pane wrapper');
+    assert.ok(html.includes('href="/favicon.svg"'), 'HTML should link the app favicon');
+    assert.ok(html.includes('href="/favicon.ico"'), 'HTML should link the fallback ICO favicon');
     assert.ok(html.includes('Search symbols or files...'), 'HTML should expose mixed symbol/file search');
     assert.ok(html.includes('id="graph-refresh"'), 'HTML should expose a graph refresh button');
     assert.ok(html.includes('id="file-preview-modal"'), 'HTML should contain the file preview modal shell');
     assert.ok(html.includes('id="file-preview-code"'), 'HTML should contain the file preview code surface');
 });
+test('web build copies the favicon asset', () => {
+    const favicon = readFileSync(join(distWeb, 'favicon.svg'), 'utf-8');
+    const fallbackFavicon = readFileSync(join(distWeb, 'favicon.ico'));
+    assert.ok(favicon.includes('<svg'), 'favicon should be an SVG asset');
+    assert.ok(favicon.includes('#38bdf8'), 'favicon should use the minicode graph accent');
+    assert.ok(fallbackFavicon.length > 0, 'fallback favicon should be copied');
+});
 test('onboarding hint includes user-facing guidance text in built JS', () => {
     const js = readFileSync(join(distWeb, 'app.js'), 'utf-8');
     assert.ok(js.includes('Code dependency graph'), 'onboarding title should mention the code dependency graph');
@@ -58,6 +68,16 @@ test('built JS auto-opens symbol details for agent activity and graph search sel
     assert.ok(js.includes('openDetail: true'), 'JS should request the detail panel when focusing symbols from agent activity or search');
     assert.ok(js.includes('await showDetail(node, detailEl)'), 'JS should populate the symbol detail panel when focus requests it');
 });
+test('symbol selection keeps the current graph viewport instead of fitting the canvas', () => {
+    const source = readFileSync(graphSource, 'utf-8');
+    const showDetailStart = source.indexOf('async function showDetail');
+    const loadSourceStart = source.indexOf('async function loadSource');
+    assert.ok(showDetailStart >= 0, 'graph source should define showDetail');
+    assert.ok(loadSourceStart > showDetailStart, 'graph source should define loadSource after showDetail');
+    const showDetailBody = source.slice(showDetailStart, loadSourceStart);
+    assert.ok(showDetailBody.includes('syncDetailPanelLayout();'), 'showDetail should resize Cytoscape without changing pan/zoom');
+    assert.ok(!showDetailBody.includes('syncDetailPanelLayout({ fit: true })'), 'showDetail should not fit the graph when a symbol is selected');
+});
 test('built JS supports file search results and file-centered neighborhood rendering', () => {
     const js = readFileSync(join(distWeb, 'app.js'), 'utf-8');
     assert.ok(js.includes('focusFileInGraph'), 'JS should define a file-focused graph seeding helper');

package/dist/tests/guardrails.test.js

@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { resolveWorkspacePath, validateCommand, validatePath, } from "@minicode/agent-sdk";
+import { resolveWorkspacePath, validateCommand, validatePath, } from "@sean.holung/minicode-sdk";
 test("validatePath allows files within workspace", () => {
     const workspaceRoot = "/tmp/workspace";
     assert.equal(validatePath("src/index.ts", workspaceRoot), true);

package/dist/tests/indexer.test.js

@@ -168,11 +168,29 @@ test("Code map handles empty symbols map", () => {
     assert.ok(result.text.includes("# Project Code Map"));
     assert.ok(result.text.length < 100);
 });
+test("Code map honors MINICODE_CODE_MAP_FORMAT=full opt-out", () => {
+    const symbols = typescriptPlugin.indexFile("sample.ts", SAMPLE_TS);
+    const byFile = new Map([["sample.ts", symbols]]);
+    const prev = process.env.MINICODE_CODE_MAP_FORMAT;
+    process.env.MINICODE_CODE_MAP_FORMAT = "full";
+    try {
+        const result = generateCodeMap(byFile);
+        // Full format prefixes each non-method symbol with the bare kind keyword
+        // (e.g. "class CodingAgent") and emits a separate signature line.
+        assert.ok(result.text.includes("class CodingAgent"), "full format prefixes class keyword");
+    }
+    finally {
+        if (prev === undefined)
+            delete process.env.MINICODE_CODE_MAP_FORMAT;
+        else
+            process.env.MINICODE_CODE_MAP_FORMAT = prev;
+    }
+});
 test("Code map nests methods under class", () => {
     const symbols = typescriptPlugin.indexFile("sample.ts", SAMPLE_TS);
     const byFile = new Map([["sample.ts", symbols]]);
     const result = generateCodeMap(byFile);
-    assert.ok(result.text.includes("class CodingAgent"));
+    assert.ok(result.text.includes("CodingAgent (class)"));
     assert.ok(result.text.includes("runTurn"));
     const runTurnLine = result.text.split("\n").find((l) => l.includes("runTurn"));
     assert.ok(runTurnLine?.startsWith("    "), "method should be indented under class");
@@ -197,19 +215,32 @@ test("reindexFile updates symbols and code map after file change", async () => {
     const updatedSym = index.getSymbol("greet");
     assert.ok(updatedSym, "should still find greet");
     assert.ok(updatedSym.signature.includes("title?: string"), "signature should reflect updated params");
-    const codeMap = index.getCodeMap();
-    assert.ok(codeMap.text.includes("title?: string"), "code map should reflect new signature");
+    // Verify the code map is regenerated after reindex. The default named
+    // format doesn't include signatures, so we opt into the full format
+    // here to assert the signature change flows through.
+    const prev = process.env.MINICODE_CODE_MAP_FORMAT;
+    process.env.MINICODE_CODE_MAP_FORMAT = "full";
+    try {
+        const codeMap = index.getCodeMap();
+        assert.ok(codeMap.text.includes("title?: string"), "code map should reflect new signature");
+    }
+    finally {
+        if (prev === undefined)
+            delete process.env.MINICODE_CODE_MAP_FORMAT;
+        else
+            process.env.MINICODE_CODE_MAP_FORMAT = prev;
+    }
 });
 test("buildProjectIndex preserves colliding top-level symbols with distinct display names", async () => {
     const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-colliding-symbols-"));
     const samplePath = path.join(workspaceRoot, "sample.ts");
-    const content = `export interface Employee {
-  id: string;
-}
-
-export class Employee {
-  constructor(public id: string) {}
-}
+    const content = `export interface Employee {
+  id: string;
+}
+
+export class Employee {
+  constructor(public id: string) {}
+}
 `;
     await writeFile(samplePath, content, "utf8");
     const index = await buildProjectIndex(workspaceRoot);
@@ -227,8 +258,8 @@ export class Employee {
     assert.equal(employeeClass.kind, "class");
     assert.equal(employeeInterface.kind, "interface");
     const codeMap = index.getCodeMap();
-    assert.ok(codeMap.text.includes("interface Employee (interface)"));
-    assert.ok(codeMap.text.includes("class Employee (class)"));
+    assert.ok(codeMap.text.includes("Employee (interface)"));
+    assert.ok(codeMap.text.includes("Employee (class)"));
     const resolved = index.getSymbol("Employee");
     assert.ok(resolved, "bare lookup should still resolve one of the colliding symbols");
     assert.ok(resolved.displayName === "Employee (class)" || resolved.displayName === "Employee (interface)", "resolved symbol should use a disambiguated display name");
@@ -359,23 +390,23 @@ function beta() {}
     assert.ok(callEdge, "should resolve dependencies even without cached AST");
 });
 test("resolveDependencies prefers same-file symbols over same-named helpers in other files", () => {
-    const projectIndexCode = `
-async function collectSourceFiles(dir: string): Promise<void> {
-  await collectSourceFiles(dir + "/nested");
-}
-
-export async function buildProjectIndex(): Promise<void> {
-  await collectSourceFiles("src");
-}
+    const projectIndexCode = `
+async function collectSourceFiles(dir: string): Promise<void> {
+  await collectSourceFiles(dir + "/nested");
+}
+
+export async function buildProjectIndex(): Promise<void> {
+  await collectSourceFiles("src");
+}
 `;
-    const cacheCode = `
-async function collectSourceFiles(dir: string): Promise<void> {
-  await collectSourceFiles(dir + "/cached");
-}
-
-export async function computeFileHashes(): Promise<void> {
-  await collectSourceFiles("src");
-}
+    const cacheCode = `
+async function collectSourceFiles(dir: string): Promise<void> {
+  await collectSourceFiles(dir + "/cached");
+}
+
+export async function computeFileHashes(): Promise<void> {
+  await collectSourceFiles("src");
+}
 `;
     const byFile = new Map([
         ["src/indexer/project-index.ts", typescriptPlugin.indexFile("src/indexer/project-index.ts", projectIndexCode)],

package/dist/tests/model-client-openai.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { OpenAICompatibleModelClient, createModelClient, } from "@minicode/agent-sdk";
+import { OpenAICompatibleModelClient, createModelClient, } from "@sean.holung/minicode-sdk";
 import { createTestAgentConfig } from "./test-utils.js";
 test("openai-compatible client sends tool schemas and parses tool calls", async () => {
     let capturedUrl = "";
@@ -73,7 +73,7 @@ test("openai-compatible client sends tool schemas and parses tool calls", async
     const tools = parsedBody.tools;
     assert.equal(tools[0]?.type, "function");
 });
-test("openai-compatible client sends correct app URL in HTTP-Referer header", async () => {
+test("openai-compatible client sends OpenRouter app attribution headers", async () => {
     let capturedHeaders = {};
     const fetchImpl = async (_input, init) => {
         const rawHeaders = init?.headers;
@@ -100,7 +100,8 @@ test("openai-compatible client sends correct app URL in HTTP-Referer header", as
         maxTokens: 64,
     });
     assert.equal(capturedHeaders["HTTP-Referer"], "https://minicode.seanholung.com", "HTTP-Referer should point to minicode.seanholung.com");
-    assert.equal(capturedHeaders["X-Title"], "minicode");
+    assert.equal(capturedHeaders["X-OpenRouter-Title"], "minicode");
+    assert.equal(capturedHeaders["X-OpenRouter-Categories"], "cli-agent,programming-app");
 });
 test("openai-compatible client repairs missing tool results before sending", async () => {
     let capturedBody = "";

package/dist/tests/model-selection.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
 import { createServer } from "node:http";
-import { OpenAICompatibleModelClient } from "@minicode/agent-sdk";
+import { OpenAICompatibleModelClient } from "@sean.holung/minicode-sdk";
 import { createRequestHandler } from "../src/serve/server.js";
 import { AgentBridge } from "../src/serve/agent-bridge.js";
 import { createTestAgentConfig } from "./test-utils.js";

package/dist/tests/package-metadata.test.js

@@ -0,0 +1,9 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const packageJsonPath = join(import.meta.dirname, '..', 'package.json');
+test('package metadata includes the minicode website for app attribution', () => {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    assert.equal(pkg.homepage, 'https://minicode.seanholung.com');
+});

package/dist/tests/python-plugin.test.js

@@ -37,9 +37,9 @@ test("buildProjectIndex indexes a Python workspace", async () => {
     assert.ok(index.getSymbol("Foo.bar"));
     assert.ok(index.getSymbol("baz"));
     const codeMap = index.getCodeMap();
-    assert.ok(codeMap.text.includes("class Foo"));
-    assert.ok(codeMap.text.includes("def bar"));
-    assert.ok(codeMap.text.includes("def baz"));
+    assert.ok(codeMap.text.includes("Foo (class)"));
+    assert.ok(codeMap.text.includes("bar"));
+    assert.ok(codeMap.text.includes("baz"));
 });
 test("verify-index-python fixture exercises the indexing pipeline", async () => {
     const root = path.resolve(import.meta.dirname, "..");

package/dist/tests/read-symbol.test.js

@@ -27,6 +27,11 @@ test("read_symbol returns error for unknown symbol name", async () => {
     const result = await tool.execute({ name: "NonExistentSymbol123" });
     assert.ok(result.includes("not found"));
     assert.ok(result.includes("search") || result.includes("read_file"));
+    // Miss path should preferentially nudge toward search_code_map (the
+    // graph-aware retry) before suggesting full-file reads — otherwise
+    // the agent abandons minicode's symbol-aware path the moment it
+    // hits a single miss.
+    assert.ok(result.includes("search_code_map"), `expected miss message to suggest search_code_map; got: ${result}`);
 });
 test("read_symbol with includeBody: false returns signature only", async () => {
     const root = path.resolve(import.meta.dirname, "..");
@@ -66,6 +71,75 @@ test("read_symbol appears in tool registry schemas when projectIndex provided",
     const props = readSymbol.input_schema.properties;
     assert.ok(props && "name" in props);
 });
+test("MINICODE_TOOL_PROFILE=file-search-only omits the five graph-aware tools", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const config = createTestAgentConfig(root);
+    const projectIndex = await buildProjectIndex(root);
+    const original = process.env.MINICODE_TOOL_PROFILE;
+    process.env.MINICODE_TOOL_PROFILE = "file-search-only";
+    try {
+        const registry = createToolRegistry(config, projectIndex);
+        const schemas = registry.getToolSchemas();
+        const names = new Set(schemas.map((s) => s.name));
+        // Graph-aware tools must be absent in file-search-only mode.
+        for (const omitted of [
+            "read_symbol",
+            "find_references",
+            "get_dependencies",
+            "find_path",
+            "search_code_map",
+        ]) {
+            assert.ok(!names.has(omitted), `expected ${omitted} to be absent`);
+        }
+        // Core file/search/run tools must still be present — that's the
+        // "search-only" half of the profile name.
+        for (const required of [
+            "read_file",
+            "write_file",
+            "edit_file",
+            "search",
+            "list_files",
+            "run_command",
+        ]) {
+            assert.ok(names.has(required), `expected ${required} to be present`);
+        }
+    }
+    finally {
+        if (original === undefined) {
+            delete process.env.MINICODE_TOOL_PROFILE;
+        }
+        else {
+            process.env.MINICODE_TOOL_PROFILE = original;
+        }
+    }
+});
+test("createToolRegistry includes graph-aware tools by default when projectIndex is provided", async () => {
+    const root = path.resolve(import.meta.dirname, "..");
+    const config = createTestAgentConfig(root);
+    const projectIndex = await buildProjectIndex(root);
+    // Must run with no MINICODE_TOOL_PROFILE set, otherwise the env from a
+    // host shell would mask the default behavior.
+    const original = process.env.MINICODE_TOOL_PROFILE;
+    delete process.env.MINICODE_TOOL_PROFILE;
+    try {
+        const registry = createToolRegistry(config, projectIndex);
+        const names = new Set(registry.getToolSchemas().map((s) => s.name));
+        for (const required of [
+            "read_symbol",
+            "find_references",
+            "get_dependencies",
+            "find_path",
+            "search_code_map",
+        ]) {
+            assert.ok(names.has(required), `expected ${required} to be present by default`);
+        }
+    }
+    finally {
+        if (original !== undefined) {
+            process.env.MINICODE_TOOL_PROFILE = original;
+        }
+    }
+});
 test("read_symbol includes Referenced Types section for createToolRegistry", async () => {
     const root = path.resolve(import.meta.dirname, "..");
     const config = createTestAgentConfig(root);
@@ -77,11 +151,11 @@ test("read_symbol includes Referenced Types section for createToolRegistry", asy
 });
 test("read_symbol returns disambiguation list for ambiguous bare symbol names", async () => {
     const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-read-symbol-collisions-"));
-    await writeFile(path.join(workspaceRoot, "sample.ts"), `export type Review = { id: string };
-
-export class Review {
-  constructor(public id: string) {}
-}
+    await writeFile(path.join(workspaceRoot, "sample.ts"), `export type Review = { id: string };
+
+export class Review {
+  constructor(public id: string) {}
+}
 `, "utf8");
     const config = createTestAgentConfig(workspaceRoot);
     const projectIndex = await buildProjectIndex(workspaceRoot);
@@ -95,11 +169,11 @@ export class Review {
 });
 test("read_symbol accepts qualified names for colliding symbols", async () => {
     const workspaceRoot = await mkdtemp(path.join(tmpdir(), "minicode-read-symbol-qualified-"));
-    await writeFile(path.join(workspaceRoot, "sample.ts"), `export type Review = { id: string };
-
-export class Review {
-  constructor(public id: string) {}
-}
+    await writeFile(path.join(workspaceRoot, "sample.ts"), `export type Review = { id: string };
+
+export class Review {
+  constructor(public id: string) {}
+}
 `, "utf8");
     const config = createTestAgentConfig(workspaceRoot);
     const projectIndex = await buildProjectIndex(workspaceRoot);

package/dist/tests/reasoning-effort.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { OpenAICompatibleModelClient, CodingAgent, ToolRegistry, } from "@minicode/agent-sdk";
+import { OpenAICompatibleModelClient, CodingAgent, ToolRegistry, } from "@sean.holung/minicode-sdk";
 import { createTestAgentConfig } from "./test-utils.js";
 import { loadAgentConfig } from "../src/agent/config.js";
 // ---------------------------------------------------------------------------