@sean.holung/minicode 0.3.4 → 0.3.6

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-onboarding.test.js

@@ -9,6 +9,7 @@ test('built CSS contains graph-onboarding styles', () => {
     assert.ok(css.includes('.graph-onboarding-icon'), 'CSS should contain .graph-onboarding-icon class');
     assert.ok(css.includes('.graph-onboarding-title'), 'CSS should contain .graph-onboarding-title class');
     assert.ok(css.includes('.graph-onboarding-subtitle'), 'CSS should contain .graph-onboarding-subtitle class');
+    assert.ok(css.includes('.search-result-subtitle'), 'CSS should contain secondary search result text styling');
     assert.ok(css.includes('pointer-events: none'), 'onboarding overlay should not block interactions');
     assert.ok(css.includes('width: 380px;'), 'symbol detail panel should have a wider default width');
 });
@@ -22,11 +23,12 @@ 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('Search symbols or files...'), 'HTML should expose mixed symbol/file search');
 });
 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');
-    assert.ok(js.includes('Search for a symbol'), 'onboarding subtitle should guide users to search');
+    assert.ok(js.includes('Search for a symbol or file'), 'onboarding subtitle should guide users to search');
 });
 test('onboarding hint is re-shown on clear in built JS', () => {
     const js = readFileSync(join(distWeb, 'app.js'), 'utf-8');
@@ -53,3 +55,10 @@ 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('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');
+    assert.ok(js.includes('buildGraphSearchResults'), 'JS should use the shared mixed search result helper');
+    assert.ok(js.includes('el.dataset.type') && js.includes('focusFileInGraph(id)'), 'JS should branch on file search results when handling selection');
+    assert.ok(js.includes('buildFileFocusedSelection'), 'file-focused graph seeding should use the shared file selection helper');
+});

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

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { buildGraphFileIndex, buildGraphSearchResults, compareGraphFilePaths, matchesGraphFileQuery, } from "../src/shared/graph-search.js";
+test("buildGraphFileIndex groups graph nodes by file path", () => {
+    const nodes = new Map([
+        ["Review#class", { name: "Review (class)", qualifiedName: "Review#class", filePath: "src/review.ts", exported: true }],
+        ["Review#type", { name: "Review (type)", qualifiedName: "Review#type", filePath: "src/review.ts", exported: true }],
+        ["Session.trim", { name: "trim", qualifiedName: "Session.trim", filePath: "src/session.ts", exported: false }],
+    ]);
+    const fileIndex = buildGraphFileIndex(nodes);
+    assert.deepEqual(fileIndex.get("src/review.ts"), ["Review#class", "Review#type"]);
+    assert.deepEqual(fileIndex.get("src/session.ts"), ["Session.trim"]);
+});
+test("compareGraphFilePaths prefers files with more indexed symbols", () => {
+    const fileIndex = new Map([
+        ["src/review.ts", ["Review#class", "Review#type"]],
+        ["src/session.ts", ["Session.trim"]],
+    ]);
+    const ranked = [...fileIndex.keys()].sort((a, b) => compareGraphFilePaths(a, b, fileIndex));
+    assert.deepEqual(ranked, ["src/review.ts", "src/session.ts"]);
+});
+test("matchesGraphFileQuery matches file path substrings case-insensitively", () => {
+    assert.equal(matchesGraphFileQuery("review", "src/review.ts"), true);
+    assert.equal(matchesGraphFileQuery("SRC/REVIEW", "src/review.ts"), true);
+    assert.equal(matchesGraphFileQuery("session", "src/review.ts"), false);
+});
+test("buildGraphSearchResults returns mixed symbol and file matches", () => {
+    const nodes = new Map([
+        ["Review#class", { name: "Review (class)", qualifiedName: "Review#class", kind: "class", filePath: "src/review.ts", exported: true }],
+        ["Review#type", { name: "Review (type)", qualifiedName: "Review#type", kind: "type", filePath: "src/review.ts", exported: true }],
+        ["Session.trim", { name: "trim", qualifiedName: "Session.trim", kind: "method", filePath: "src/session.ts", exported: false }],
+    ]);
+    const rankedSymbols = [...nodes.keys()];
+    const fileIndex = buildGraphFileIndex(nodes);
+    const results = buildGraphSearchResults({
+        query: "review",
+        symbolIds: rankedSymbols,
+        nodes,
+        fileIndex,
+    });
+    assert.equal(results[0]?.type, "symbol");
+    assert.equal(results[0]?.id, "Review#class");
+    assert.equal(results[1]?.type, "symbol");
+    assert.equal(results[2]?.type, "file");
+    assert.equal(results[2]?.id, "src/review.ts");
+});
+test("buildGraphSearchResults returns default file suggestions for short queries", () => {
+    const nodes = new Map([
+        ["Review#class", { name: "Review (class)", qualifiedName: "Review#class", kind: "class", filePath: "src/review.ts", exported: true }],
+        ["Review#type", { name: "Review (type)", qualifiedName: "Review#type", kind: "type", filePath: "src/review.ts", exported: true }],
+        ["Session.trim", { name: "trim", qualifiedName: "Session.trim", kind: "method", filePath: "src/session.ts", exported: false }],
+    ]);
+    const rankedSymbols = [...nodes.keys()];
+    const fileIndex = buildGraphFileIndex(nodes);
+    const results = buildGraphSearchResults({
+        query: "",
+        symbolIds: rankedSymbols,
+        nodes,
+        fileIndex,
+        symbolLimit: 2,
+        fileLimit: 1,
+    });
+    assert.equal(results.length, 3);
+    assert.equal(results[2]?.type, "file");
+    assert.equal(results[2]?.id, "src/review.ts");
+});

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

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { buildFileFocusedSelection, buildGraphEdgeId, buildGraphEdgeIndex, } from "../src/shared/graph-selection.js";
+test("buildGraphEdgeIndex indexes edges by both source and target", () => {
+    const edges = [
+        { source: "Review#class", target: "Session.trim", kind: "references" },
+        { source: "renderReview", target: "Review#type", kind: "references" },
+    ];
+    const edgeIndex = buildGraphEdgeIndex(edges);
+    assert.deepEqual(edgeIndex.get("Review#class"), [edges[0]]);
+    assert.deepEqual(edgeIndex.get("Session.trim"), [edges[0]]);
+    assert.deepEqual(edgeIndex.get("renderReview"), [edges[1]]);
+    assert.deepEqual(edgeIndex.get("Review#type"), [edges[1]]);
+});
+test("buildFileFocusedSelection includes file symbols and touching neighbors", () => {
+    const fileIndex = new Map([
+        ["src/review.ts", ["Review#class", "Review#type"]],
+    ]);
+    const edges = [
+        { source: "Review#class", target: "Session.trim", kind: "references" },
+        { source: "renderReview", target: "Review#type", kind: "references" },
+        { source: "Review#class", target: "Review#type", kind: "references" },
+    ];
+    const selection = buildFileFocusedSelection({
+        filePath: "src/review.ts",
+        fileIndex,
+        edgeIndex: buildGraphEdgeIndex(edges),
+    });
+    assert.deepEqual(new Set(selection.nodeIds), new Set(["Review#class", "Review#type", "Session.trim", "renderReview"]));
+    assert.deepEqual(new Set(selection.edges.map((edge) => buildGraphEdgeId(edge))), new Set(edges.map((edge) => buildGraphEdgeId(edge))));
+});
+test("buildFileFocusedSelection excludes edges between external neighbors", () => {
+    const fileIndex = new Map([
+        ["src/review.ts", ["Review#class"]],
+    ]);
+    const reviewToSession = { source: "Review#class", target: "Session.trim", kind: "references" };
+    const reviewToRender = { source: "Review#class", target: "renderReview", kind: "references" };
+    const sessionToRender = { source: "Session.trim", target: "renderReview", kind: "references" };
+    const edges = [reviewToSession, reviewToRender, sessionToRender];
+    const selection = buildFileFocusedSelection({
+        filePath: "src/review.ts",
+        fileIndex,
+        edgeIndex: buildGraphEdgeIndex(edges),
+    });
+    assert.deepEqual(new Set(selection.nodeIds), new Set(["Review#class", "Session.trim", "renderReview"]));
+    assert.deepEqual(new Set(selection.edges.map((edge) => buildGraphEdgeId(edge))), new Set([
+        buildGraphEdgeId(reviewToSession),
+        buildGraphEdgeId(reviewToRender),
+    ]));
+});
+test("buildFileFocusedSelection returns an empty selection for unknown files", () => {
+    const selection = buildFileFocusedSelection({
+        filePath: "src/missing.ts",
+        fileIndex: new Map(),
+        edgeIndex: buildGraphEdgeIndex([]),
+    });
+    assert.deepEqual(selection, { nodeIds: [], edges: [] });
+});

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",
+    ]);
+});

package/dist/tests/home-env.test.js

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, test } from "node:test";
+import { getHomeEnvPath, upsertHomeEnvValues } from "../src/agent/home-env.js";
+const tempDirs = [];
+afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+test("upsertHomeEnvValues creates ~/.minicode/.env when missing", async () => {
+    const minicodeHome = await mkdtemp(path.join(os.tmpdir(), "minicode-home-env-"));
+    tempDirs.push(minicodeHome);
+    const result = await upsertHomeEnvValues({
+        minicodeHome,
+        values: {
+            MODEL_PROVIDER: "openai-compatible",
+            OPENAI_BASE_URL: "https://openrouter.ai/api/v1",
+            OPENROUTER_API_KEY: "sk-or-v1-test",
+        },
+    });
+    assert.equal(result.path, getHomeEnvPath(minicodeHome));
+    const contents = await readFile(result.path, "utf8");
+    assert.match(contents, /^MODEL_PROVIDER=openai-compatible/m);
+    assert.match(contents, /^OPENAI_BASE_URL=https:\/\/openrouter\.ai\/api\/v1/m);
+    assert.match(contents, /^OPENROUTER_API_KEY=sk-or-v1-test/m);
+});
+test("upsertHomeEnvValues replaces existing keys and preserves unrelated lines", async () => {
+    const minicodeHome = await mkdtemp(path.join(os.tmpdir(), "minicode-home-env-"));
+    tempDirs.push(minicodeHome);
+    const envPath = getHomeEnvPath(minicodeHome);
+    await writeFile(envPath, [
+        "# Existing config",
+        "MODEL_PROVIDER=anthropic",
+        "OPENAI_BASE_URL=https://example.invalid/v1",
+        "OPENROUTER_API_KEY=old-key",
+        "OPENROUTER_API_KEY=older-key",
+        "MODEL=existing-model",
+        "",
+    ].join("\n"), "utf8");
+    await upsertHomeEnvValues({
+        minicodeHome,
+        values: {
+            MODEL_PROVIDER: "openai-compatible",
+            OPENAI_BASE_URL: "https://openrouter.ai/api/v1",
+            OPENROUTER_API_KEY: "sk-or-v1-new",
+        },
+    });
+    const contents = await readFile(envPath, "utf8");
+    assert.match(contents, /^# Existing config/m);
+    assert.match(contents, /^MODEL_PROVIDER=openai-compatible$/m);
+    assert.match(contents, /^OPENAI_BASE_URL=https:\/\/openrouter\.ai\/api\/v1$/m);
+    assert.match(contents, /^OPENROUTER_API_KEY=sk-or-v1-new$/m);
+    assert.match(contents, /^MODEL=existing-model$/m);
+    assert.equal(contents.match(/^OPENROUTER_API_KEY=/gm)?.length, 1);
+});

package/dist/tests/indexer.test.js

@@ -232,6 +232,12 @@ export class Employee {
     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");
+    const matches = index.getSymbolMatches("Employee");
+    assert.equal(matches.length, 2, "should list every colliding symbol for ambiguous lookups");
+    assert.deepEqual(matches.map((symbol) => symbol.displayName).sort(), ["Employee (class)", "Employee (interface)"].sort());
+    assert.deepEqual(matches.map((symbol) => symbol.qualifiedName).sort(), [employeeClass.qualifiedName, employeeInterface.qualifiedName].sort());
+    assert.deepEqual(index.getSymbolMatches("Employee (class)").map((symbol) => symbol.qualifiedName), [employeeClass.qualifiedName]);
+    assert.deepEqual(index.getSymbolMatches("Employee#class").map((symbol) => symbol.qualifiedName), [employeeClass.qualifiedName]);
 });
 test("TypeScript plugin indexes class expressions assigned to variables", () => {
     const code = `const MyClass = class MyClass {

package/dist/tests/read-symbol.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 { createReadSymbolTool } from "../src/tools/read-symbol.js";
 import { createToolRegistry } from "../src/tools/registry.js";
@@ -73,6 +75,39 @@ test("read_symbol includes Referenced Types section for createToolRegistry", asy
     assert.ok(result.includes("# createToolRegistry"));
     assert.ok(result.includes("src/tools/registry.ts"));
 });
+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) {}
+}
+`, "utf8");
+    const config = createTestAgentConfig(workspaceRoot);
+    const projectIndex = await buildProjectIndex(workspaceRoot);
+    const tool = createReadSymbolTool(config, 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("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) {}
+}
+`, "utf8");
+    const config = createTestAgentConfig(workspaceRoot);
+    const projectIndex = await buildProjectIndex(workspaceRoot);
+    const tool = createReadSymbolTool(config, projectIndex);
+    const result = await tool.execute({ name: "Review#class", includeBody: false });
+    assert.ok(result.includes("# Review (class) (class)"));
+    assert.ok(result.includes("sample.ts"));
+});
 test("read_symbol is not in tool registry when projectIndex is undefined", () => {
     const config = createTestAgentConfig("/tmp");
     const registry = createToolRegistry(config);

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

@@ -0,0 +1,15 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { createLatestRequestTracker } from "../src/web/request-tracker.js";
+test("latest request tracker only accepts the most recent request token", () => {
+    const tracker = createLatestRequestTracker();
+    const first = tracker.begin();
+    const second = tracker.begin();
+    assert.equal(tracker.isCurrent(first), false);
+    assert.equal(tracker.isCurrent(second), true);
+});
+test("latest request tracker treats the current token as active until superseded", () => {
+    const tracker = createLatestRequestTracker();
+    const token = tracker.begin();
+    assert.equal(tracker.isCurrent(token), true);
+});

package/dist/tests/run-benchmarks.test.js

@@ -3,7 +3,7 @@ import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
 import path from "node:path";
 import { tmpdir } from "node:os";
 import { test } from "node:test";
-import { parseArgs, buildConfig, loadTasks } from "../scripts/run-benchmarks.js";
+import { parseArgs, buildConfig, loadTasks, getBenchmarkConfigPath } from "../scripts/run-benchmarks.js";
 // ─── parseArgs ────────────────────────────────────────────────────
 test("parseArgs: defaults to variant 'ci' with no flags", () => {
     const args = parseArgs([]);
@@ -43,52 +43,136 @@ test("parseArgs: ignores unknown flags", () => {
     assert.equal(args.variant, "test");
 });
 // ─── buildConfig ──────────────────────────────────────────────────
-test("buildConfig: returns defaults when no env vars set", () => {
-    const originalProvider = process.env.MODEL_PROVIDER;
-    const originalModel = process.env.MODEL;
-    delete process.env.MODEL_PROVIDER;
-    delete process.env.MODEL;
+test("getBenchmarkConfigPath resolves under benchmarks/", () => {
+    const repoRoot = "/tmp/minicode-repo";
+    assert.equal(getBenchmarkConfigPath(repoRoot), path.join(repoRoot, "benchmarks", "benchmark.config.json"));
+});
+test("buildConfig: reads benchmark config file defaults", async () => {
+    const tmpRoot = await mkdtemp(path.join(tmpdir(), "bench-config-root-"));
+    const configPath = path.join(tmpRoot, "benchmarks", "benchmark.config.json");
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await writeFile(configPath, JSON.stringify({
+        modelProvider: "openai-compatible",
+        model: "google/gemini-3-flash-preview",
+        openAiBaseUrl: "https://openrouter.ai/api/v1",
+        maxSteps: 42,
+        maxContextTokens: 12345,
+    }));
     try {
-        const config = buildConfig();
+        const config = buildConfig({
+            repoRoot: tmpRoot,
+            env: {},
+            homeEnvPath: path.join(tmpRoot, ".missing-home-env"),
+            configPath,
+        });
         assert.equal(config.modelProvider, "openai-compatible");
-        assert.equal(config.model, "test-model");
-        assert.equal(config.maxSteps, 50);
-        assert.equal(config.maxTokens, 4096);
+        assert.equal(config.model, "google/gemini-3-flash-preview");
+        assert.equal(config.openAiBaseUrl, "https://openrouter.ai/api/v1");
+        assert.equal(config.maxSteps, 42);
+        assert.equal(config.maxContextTokens, 12345);
+    }
+    finally {
+        await rm(tmpRoot, { recursive: true, force: true });
+    }
+});
+test("buildConfig: home .env provides benchmark API keys", async () => {
+    const tmpRoot = await mkdtemp(path.join(tmpdir(), "bench-config-home-env-"));
+    const configPath = path.join(tmpRoot, "benchmarks", "benchmark.config.json");
+    const homeEnvPath = path.join(tmpRoot, "home.env");
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await writeFile(configPath, JSON.stringify({
+        modelProvider: "openai-compatible",
+        model: "google/gemini-3-flash-preview",
+        openAiBaseUrl: "https://openrouter.ai/api/v1",
+    }));
+    await writeFile(homeEnvPath, "OPENROUTER_API_KEY=test-openrouter-key\n");
+    try {
+        const config = buildConfig({
+            repoRoot: tmpRoot,
+            env: {},
+            homeEnvPath,
+            configPath,
+        });
+        assert.equal(config.openAiApiKey, "test-openrouter-key");
+    }
+    finally {
+        await rm(tmpRoot, { recursive: true, force: true });
+    }
+});
+test("buildConfig: benchmark config wins over home .env for non-secret settings", async () => {
+    const tmpRoot = await mkdtemp(path.join(tmpdir(), "bench-config-env-"));
+    const configPath = path.join(tmpRoot, "benchmarks", "benchmark.config.json");
+    const homeEnvPath = path.join(tmpRoot, "home.env");
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await writeFile(configPath, JSON.stringify({
+        modelProvider: "openai-compatible",
+        model: "google/gemini-3-flash-preview",
+        openAiBaseUrl: "https://openrouter.ai/api/v1",
+        maxContextTokens: 32000,
+    }));
+    await writeFile(homeEnvPath, "MODEL=google/gemini-home\nOPENAI_BASE_URL=https://example.invalid/v1\nOPENROUTER_API_KEY=home-openrouter-key\n");
+    try {
+        const config = buildConfig({
+            repoRoot: tmpRoot,
+            env: {},
+            homeEnvPath,
+            configPath,
+        });
+        assert.equal(config.modelProvider, "openai-compatible");
+        assert.equal(config.model, "google/gemini-3-flash-preview");
+        assert.equal(config.openAiBaseUrl, "https://openrouter.ai/api/v1");
+        assert.equal(config.openAiApiKey, "home-openrouter-key");
         assert.equal(config.maxContextTokens, 32000);
-        assert.equal(config.confirmDestructive, false);
     }
     finally {
-        if (originalProvider !== undefined)
-            process.env.MODEL_PROVIDER = originalProvider;
-        if (originalModel !== undefined)
-            process.env.MODEL = originalModel;
+        await rm(tmpRoot, { recursive: true, force: true });
     }
 });
-test("buildConfig: reads MODEL_PROVIDER and MODEL from env", () => {
-    const originalProvider = process.env.MODEL_PROVIDER;
-    const originalModel = process.env.MODEL;
-    process.env.MODEL_PROVIDER = "anthropic";
-    process.env.MODEL = "claude-test";
+test("buildConfig: shell env overrides benchmark config and home env", async () => {
+    const tmpRoot = await mkdtemp(path.join(tmpdir(), "bench-config-shell-env-"));
+    const configPath = path.join(tmpRoot, "benchmarks", "benchmark.config.json");
+    const homeEnvPath = path.join(tmpRoot, "home.env");
+    await mkdir(path.dirname(configPath), { recursive: true });
+    await writeFile(configPath, JSON.stringify({
+        modelProvider: "openai-compatible",
+        model: "google/gemini-3-flash-preview",
+        openAiBaseUrl: "https://openrouter.ai/api/v1",
+        maxContextTokens: 32000,
+    }));
+    await writeFile(homeEnvPath, "OPENROUTER_API_KEY=home-openrouter-key\n");
     try {
-        const config = buildConfig();
+        const config = buildConfig({
+            repoRoot: tmpRoot,
+            env: {
+                MODEL_PROVIDER: "anthropic",
+                MODEL: "claude-test",
+                OPENAI_BASE_URL: "https://override.example/v1",
+                MAX_CONTEXT_TOKENS: "64000",
+            },
+            homeEnvPath,
+            configPath,
+        });
         assert.equal(config.modelProvider, "anthropic");
         assert.equal(config.model, "claude-test");
+        assert.equal(config.openAiBaseUrl, "https://override.example/v1");
+        assert.equal(config.maxContextTokens, 64000);
     }
     finally {
-        if (originalProvider !== undefined) {
-            process.env.MODEL_PROVIDER = originalProvider;
-        }
-        else {
-            delete process.env.MODEL_PROVIDER;
-        }
-        if (originalModel !== undefined) {
-            process.env.MODEL = originalModel;
-        }
-        else {
-            delete process.env.MODEL;
-        }
+        await rm(tmpRoot, { recursive: true, force: true });
     }
 });
+test("buildConfig: falls back to hardcoded defaults when config file is missing", () => {
+    const config = buildConfig({
+        repoRoot: "/tmp/bench-missing-config",
+        env: {},
+        homeEnvPath: "/tmp/bench-missing-home-env",
+        configPath: "/tmp/bench-missing-config/benchmarks/missing.json",
+    });
+    assert.equal(config.modelProvider, "openai-compatible");
+    assert.equal(config.model, "test-model");
+    assert.equal(config.openAiBaseUrl, "http://localhost:1234/v1");
+    assert.equal(config.maxSteps, 50);
+});
 // ─── loadTasks ────────────────────────────────────────────────────
 let tmpDir;
 async function setupTempTasks() {

package/dist/tests/search-code-map.test.js

@@ -45,4 +45,6 @@ export class Employee {
     const result = await tool.execute({ pattern: "Employee" });
     assert.ok(result.includes("Employee (interface)"));
     assert.ok(result.includes("Employee (class)"));
+    assert.ok(result.includes("qualified: Employee#interface"));
+    assert.ok(result.includes("qualified: Employee#class"));
 });