@sean.holung/minicode 0.3.10 → 0.4.0

package/README.md

@@ -4,9 +4,11 @@
 
 A graph-native coding agent and code exploration environment built around structural context optimization that leverages symbol-aware retrieval, dependency graphs, and targeted context. It started as a way to make local models viable under tighter context budgets, and it now also works well with hosted frontier models through the same runtime, web UI, and OpenAI-compatible serve mode. 
 
-minicode is built on a simple bet: models perform better when you give them less, but better context. Bloated context directly degrades output quality: attention dilutes, positional biases cause mid-context information loss, and inference latency grows as token count increases.
+minicode is built on a simple bet: models perform better when you give them more useful context, not less raw context. Bloated context dilutes attention; targeted context lets the model build a structural picture of the codebase before answering.
 
-Read operations dominate token usage in typical agent sessions; minicode addresses this by optimizing for **specific languages**. It indexes your project at startup with language plugins, injects a compact **code map** (signatures only) into the system prompt, and exposes symbol-level tools (`read_symbol`, `find_references`, `get_dependencies`) so the model reads only what it needs instead of entire files. This also enables the agent to walk the code structurally to gain a better understanding of the codebase at a structural level. TypeScript and JavaScript support come built-in, with custom language plugins leaving room for broader language support over time.
+Read operations dominate token usage in typical agent sessions; minicode addresses this by optimizing for **specific languages**. It indexes your project at startup with language plugins, injects a compact **code map** (signatures only) into the system prompt, and exposes symbol-level tools (`read_symbol`, `find_references`, `get_dependencies`) so the model can walk the code structurally instead of grepping and reading entire files. TypeScript and JavaScript support come built-in, with custom language plugins leaving room for broader language support over time.
+
+In our own ablation on a 25-task local benchmark suite (see [`benchmarks/RESULTS-GEMMA-4.md`](benchmarks/RESULTS-GEMMA-4.md)), turning the structural tools on raises pass rate from 47% to 61% on Gemma 4 26B-A4B — a +14.7 pp lift driven mostly by **comprehension-heavy tasks** (planning and refactor work where the agent has to trace relationships across files). The tradeoff is honest: graph tools cost about 30% more tokens per task when actually used, but they buy correctness on the kinds of questions where reading whole files just runs out the model's reasoning budget without building a structural picture.
 
 _Run `minicode serve` to get the web UI on localhost: chat, tool activity, session controls, model switching, symbol focus, annotations, and a live dependency graph._
 
@@ -118,7 +120,7 @@ For agent-loop internals (session lifecycle, tool execution, streaming, loop det
 
 For the proposed reusable package architecture and public interfaces for a standalone runtime SDK, see [docs/SDK_SPEC.md](docs/SDK_SPEC.md).
 
-minicode reduces token usage by indexing your project and providing targeted tools:
+minicode replaces grep-and-read-whole-file with symbol-level navigation:
 
 - **Code map** — A compact project skeleton (signatures only) is injected into the system prompt so the model can orient itself without reading full files.
 - `read_symbol` — Read a specific function or class by name, with referenced types.

package/dist/scripts/run-benchmarks.js

@@ -19,7 +19,7 @@ import { readFileSync, existsSync } from "node:fs";
 import path from "node:path";
 import { homedir } from "node:os";
 import { writeFile } from "node:fs/promises";
-import { createModelClient, } from "@minicode/agent-sdk";
+import { createModelClient, } from "@sean.holung/minicode-sdk";
 import { parse as parseDotenv } from "dotenv";
 import { loadBenchmarkTasks, loadBenchmarkTask } from "../src/benchmark/task-loader.js";
 import { runBenchmarkSuite } from "../src/benchmark/runner.js";
@@ -111,6 +111,12 @@ export function buildConfig(options = {}) {
         maxToolOutputChars: getNumberSetting(getShellOverride("MAX_TOOL_OUTPUT_CHARS"), fileConfig.maxToolOutputChars, 8000),
         openAiBaseUrl,
         ...(openAiApiKey ? { openAiApiKey } : {}),
+        // Explicit match to the loadAgentConfig default so benchmark runs see
+        // the same static-system-prompt behavior that real CLI/serve users
+        // get. Omitting this routes through the SDK fallback in agent.ts and,
+        // depending on its semantics, may flip behavior unintentionally — see
+        // PR #138 follow-up for the original issue.
+        enableDynamicPrompt: false,
     };
 }
 /* ------------------------------------------------------------------ */

package/dist/src/benchmark/runner.js

@@ -5,10 +5,10 @@
  * over tool-call instrumentation and trace capture.
  */
 import { execSync } from "node:child_process";
-import { cp, mkdtemp, rm } from "node:fs/promises";
+import { cp, mkdir, mkdtemp, rm, symlink, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
-import { CodingAgent, Session, ToolRegistry, } from "@minicode/agent-sdk";
+import { CodingAgent, Session, ToolRegistry, } from "@sean.holung/minicode-sdk";
 const COPY_SKIP_NAMES = new Set([
     ".git",
     "node_modules",
@@ -16,6 +16,24 @@ const COPY_SKIP_NAMES = new Set([
     "build",
     "coverage",
 ]);
+/**
+ * Narrow symlinks (relative to the source workspace) injected into the
+ * isolated workspace after the bulk copy. Goal: make `tsc --noEmit`
+ * resolve types for the post-edit diagnostic, *without* enabling the
+ * full test runner.
+ *
+ * - `node_modules/@types` lets tsc resolve `@types/node` etc. (the
+ *   typescript binary itself runs from the source workspace and finds
+ *   its lib files relative to its own install location, so we don't
+ *   need to symlink it into the temp tree.)
+ *
+ * We intentionally do NOT symlink `node_modules/.bin` or general deps,
+ * so commands like `npm test` fail fast with "tsc: not found" rather
+ * than running the full pretest+test suite and burning per-task
+ * tool-call budget on infrastructure noise. See benchmarks/RESULTS for
+ * the symlink scope conversation.
+ */
+const SYMLINK_FROM_SOURCE = ["node_modules/@types"];
 function getGitCommitSha() {
     try {
         return execSync("git rev-parse HEAD", { encoding: "utf8" }).trim();
@@ -45,6 +63,31 @@ function shouldCopyPath(src) {
     const name = path.basename(src);
     return !COPY_SKIP_NAMES.has(name);
 }
+async function linkSharedDirs(sourceRoot, workspaceRoot) {
+    for (const rel of SYMLINK_FROM_SOURCE) {
+        const sourcePath = path.join(sourceRoot, rel);
+        try {
+            const s = await stat(sourcePath);
+            if (!s.isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const linkPath = path.join(workspaceRoot, rel);
+        // Ensure parent dir exists — e.g. `node_modules/@types` requires
+        // `node_modules/` to be created first (we don't bulk-copy it).
+        await mkdir(path.dirname(linkPath), { recursive: true });
+        try {
+            await symlink(sourcePath, linkPath, "dir");
+        }
+        catch {
+            // Best-effort: a parent path may not exist or the link target
+            // already does. Skip silently — tools that need these resolve
+            // to a useful error if missing.
+        }
+    }
+}
 async function prepareTaskWorkspace(task, options) {
     const sourceWorkspaceRoot = resolveSourceWorkspaceRoot(task, options);
     if (options.isolateWorkspace === false) {
@@ -60,6 +103,7 @@ async function prepareTaskWorkspace(task, options) {
         recursive: true,
         filter: shouldCopyPath,
     });
+    await linkSharedDirs(sourceWorkspaceRoot, isolatedWorkspaceRoot);
     return {
         sourceWorkspaceRoot,
         workspaceRoot: isolatedWorkspaceRoot,
@@ -74,7 +118,26 @@ function getTrackedSymbolNames(toolName, input) {
             .filter((value) => typeof value === "string" && value.length > 0);
         return [...new Set(names)];
     }
-    const name = input.symbol ?? input.symbolName ?? input.name ?? input.query;
+    // search_code_map uses `pattern`, the other graph tools use one of
+    // `name`/`symbol`/`symbolName`/`query`. Without `pattern` in this
+    // fallback chain, a search_code_map call would fail to register a
+    // queried symbol even when the pattern is the literal symbol name —
+    // and any rubric using `expectedSymbols` would then incorrectly fail
+    // tasks that were answered correctly via the code-map search.
+    //
+    // We register the pattern verbatim without resolving it against the
+    // project index. The downstream `expectedSymbols` matcher in
+    // `evaluator.ts` uses `queried.includes(expected)`, so a too-narrow
+    // query (e.g. `"Tool"` against `expectedSymbols: ["ToolRegistry"]`)
+    // correctly fails to satisfy the rubric. A too-broad query
+    // (`"ToolRegistryFactory"` against `["ToolRegistry"]`) does satisfy
+    // it — that asymmetry is intentional and matches how a user-facing
+    // search-by-substring is normally interpreted.
+    const name = input.symbol ??
+        input.symbolName ??
+        input.name ??
+        input.query ??
+        input.pattern;
     return typeof name === "string" && name.length > 0 ? [name] : [];
 }
 function trackStructuralFileReads(toolName, projectIndex, input, filesRead) {

package/dist/src/cli/benchmark-run.js

@@ -1,7 +1,7 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
-import { CodingAgent, createModelClient, } from "@minicode/agent-sdk";
+import { CodingAgent, createModelClient, } from "@sean.holung/minicode-sdk";
 import { getConfigSetupMessage } from "../agent/config.js";
 import { buildBenchmarkAgentConfig, resolveBenchmarkEnv, } from "../benchmark/config.js";
 import { collectWorkspaceChanges, writeWorkspaceDiff, } from "../benchmark/workspace-changes.js";

package/dist/src/index.js

@@ -2,7 +2,7 @@
 import process from "node:process";
 import { writeFile } from "node:fs/promises";
 import { createInterface } from "node:readline/promises";
-import { CodingAgent, createModelClient } from "@minicode/agent-sdk";
+import { CodingAgent, createModelClient } from "@sean.holung/minicode-sdk";
 import { loadAgentConfig, getConfigSetupMessage } from "./agent/config.js";
 import { listSessions, loadSession, loadSessionByLabel, saveSession, } from "./session/session-store.js";
 import { computeFileHashes, getWorkspaceCacheDir, loadIndex, saveIndex, } from "./indexer/cache.js";

package/dist/src/indexer/code-map.js

@@ -10,6 +10,20 @@ function formatSymbol(symbol, indent, isMethod) {
     }
     return `${indent}${symbol.kind} ${getSymbolDisplayName(symbol)}\n${indent}  ${symbol.signature}`;
 }
+// Terser per-line format: "{indent}- {displayName} ({kind})". Roughly halves
+// the chars/symbol cost vs the legacy full-signature format, doubling
+// coverage at the same token budget. Default since Experiment 17 (May 2026)
+// — pooled n=6 benchmark showed +3.4pp overall and +16.7pp planning vs the
+// full format, matching the dynamic-prompt baseline with zero cache cost.
+// Opt out with MINICODE_CODE_MAP_FORMAT=full.
+function formatSymbolNamed(symbol, indent) {
+    return `${indent}- ${getSymbolDisplayName(symbol)} (${symbol.kind})`;
+}
+function selectFormatter() {
+    return process.env.MINICODE_CODE_MAP_FORMAT === "full"
+        ? formatSymbol
+        : formatSymbolNamed;
+}
 function isEntryPointFile(filePath) {
     const name = filePath.replace(/\\/g, "/");
     return /(?:^|\/)index\.[jt]sx?$/.test(name);
@@ -97,6 +111,7 @@ function createSymbolRanker(adjacency, focusSymbols) {
 export function generateCodeMap(symbolsByFile, tokenBudget = DEFAULT_TOKEN_BUDGET, dependencyEdges, focusSymbols) {
     const totalCount = [...symbolsByFile.values()].reduce((sum, syms) => sum + syms.length, 0);
     const lines = ["# Project Code Map", ""];
+    const formatter = selectFormatter();
     const adjacency = dependencyEdges
         ? buildAdjacencyMaps(dependencyEdges)
         : { byFrom: new Map(), byTo: new Map() };
@@ -137,7 +152,7 @@ export function generateCodeMap(symbolsByFile, tokenBudget = DEFAULT_TOKEN_BUDGE
             else if (!isMethod) {
                 currentClass = null;
             }
-            const block = formatSymbol(symbol, indent, isMethod);
+            const block = formatter(symbol, indent, isMethod);
             const blockTokens = estimateTokens(block);
             if (totalTokens + blockTokens > tokenBudget) {
                 truncatedSymbols += 1;

package/dist/src/serve/agent-bridge.js

@@ -1,4 +1,4 @@
-import { CodingAgent, createModelClient } from "@minicode/agent-sdk";
+import { CodingAgent, createModelClient } from "@sean.holung/minicode-sdk";
 import { randomUUID } from "node:crypto";
 import { isGatedTool, shouldAutoAllow, } from "../auto-allow.js";
 import { readFile } from "node:fs/promises";

package/dist/src/session/session-store.js

@@ -1,7 +1,7 @@
 import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { Session } from "@minicode/agent-sdk";
+import { Session } from "@sean.holung/minicode-sdk";
 let sessionsDir = path.join(os.homedir(), ".minicode", "sessions");
 export class DuplicateSessionLabelError extends Error {
     label;

package/dist/src/shared/symbol-resolution.js

@@ -12,13 +12,34 @@ export function resolveSymbolInput(projectIndex, name) {
 export function formatSymbolMatch(match) {
     return `${getSymbolDisplayName(match)} (${match.kind}) — ${match.filePath}:${match.startLine} — qualified: ${match.qualifiedName}`;
 }
+/**
+ * Cap on how many disambiguation entries we render. The output flows
+ * through the agent's generic tool-output truncator, which clips by
+ * character count — including in the middle of a qualified name. That
+ * leaves the model with an unparseable lookup key, which it then
+ * guesses at, producing a "not found" loop. Bounding by entry count
+ * here means each shown match has its full qualified name intact, and
+ * generic char-truncation never has occasion to fire on the result.
+ *
+ * 12 covers virtually every real ambiguity (a name that genuinely
+ * matches more is too generic to be useful — the agent should refine
+ * regardless). Each entry is ~150-300 chars, so 12 entries fit
+ * comfortably under typical maxToolOutputChars caps.
+ */
+const MAX_AMBIGUOUS_MATCHES = 12;
 export function formatAmbiguousSymbolMatches(toolName, name, matches) {
-    return [
+    const shown = matches.slice(0, MAX_AMBIGUOUS_MATCHES);
+    const elided = matches.length - shown.length;
+    const lines = [
         `Symbol "${name}" is ambiguous; ${matches.length} matches were found.`,
         `Re-run ${toolName} with one of these qualified or disambiguated names:`,
         "",
-        ...matches.map((match) => `- ${formatSymbolMatch(match)}`),
-    ].join("\n");
+        ...shown.map((match) => `- ${formatSymbolMatch(match)}`),
+    ];
+    if (elided > 0) {
+        lines.push("", `[... and ${elided} more match(es) not shown. Refine the name (e.g. include the file path or use the qualified form like "Foo#class@path/to/file.ts") to narrow further.]`);
+    }
+    return lines.join("\n");
 }
 export function serializeSymbolMatch(match) {
     return {

package/dist/src/tools/find-path.js

@@ -1,4 +1,4 @@
-import { expectNonEmptyString, expectOptionalNumber } from "@minicode/agent-sdk";
+import { expectNonEmptyString, expectOptionalNumber } from "@sean.holung/minicode-sdk";
 import { getSymbolDisplayName } from "../indexer/symbol-names.js";
 import { formatAmbiguousSymbolMatches, resolveSymbolInput, } from "../shared/symbol-resolution.js";
 export function createFindPathTool(projectIndex) {

package/dist/src/tools/find-references.js

@@ -1,4 +1,4 @@
-import { expectNonEmptyString, expectOptionalNumber } from "@minicode/agent-sdk";
+import { expectNonEmptyString, expectOptionalNumber } from "@sean.holung/minicode-sdk";
 import { getSymbolDisplayName } from "../indexer/symbol-names.js";
 import { formatAmbiguousSymbolMatches, resolveSymbolInput, } from "../shared/symbol-resolution.js";
 const DEFAULT_LIMIT = 50;

package/dist/src/tools/get-dependencies.js

@@ -1,4 +1,4 @@
-import { expectNonEmptyString, expectOptionalNumber } from "@minicode/agent-sdk";
+import { expectNonEmptyString, expectOptionalNumber } from "@sean.holung/minicode-sdk";
 import { getSymbolDisplayName } from "../indexer/symbol-names.js";
 import { formatAmbiguousSymbolMatches, resolveSymbolInput, } from "../shared/symbol-resolution.js";
 export function createGetDependenciesTool(projectIndex) {

package/dist/src/tools/post-edit-diagnostics.js

@@ -0,0 +1,185 @@
+import { spawn } from "node:child_process";
+import { mkdir, stat } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { getWorkspaceCacheDir } from "../indexer/cache.js";
+const require = createRequire(import.meta.url);
+let cachedTscPath;
+function resolveTscPath() {
+    if (cachedTscPath !== undefined)
+        return cachedTscPath;
+    try {
+        cachedTscPath = require.resolve("typescript/bin/tsc");
+    }
+    catch {
+        cachedTscPath = null;
+    }
+    return cachedTscPath;
+}
+const TS_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"]);
+const MAX_PER_FILE = 20;
+const TSC_TIMEOUT_MS = 15_000;
+const DISABLE_ENV = "MINICODE_DISABLE_POST_EDIT_DIAGNOSTICS";
+/**
+ * Walk up from `startDir` looking for the nearest tsconfig.json. Stops at
+ * `workspaceRoot` (inclusive). Returns null if none found.
+ */
+async function findNearestTsconfig(startDir, workspaceRoot) {
+    const root = path.resolve(workspaceRoot);
+    let dir = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(dir, "tsconfig.json");
+        try {
+            const s = await stat(candidate);
+            if (s.isFile())
+                return candidate;
+        }
+        catch {
+            // not present, keep walking
+        }
+        if (dir === root)
+            return null;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+const TSC_LINE_RE = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+(TS\d+):\s*(.*)$/;
+function parseTscOutput(output, projectDir) {
+    const lines = output.split(/\r?\n/);
+    const out = [];
+    for (const line of lines) {
+        const m = line.match(TSC_LINE_RE);
+        if (!m)
+            continue;
+        const [, rawFile, ln, col, sev, code, msg] = m;
+        if (!rawFile || !ln || !col || !sev || !code || msg === undefined)
+            continue;
+        const absFile = path.isAbsolute(rawFile)
+            ? rawFile
+            : path.resolve(projectDir, rawFile);
+        out.push({
+            file: absFile,
+            line: Number(ln),
+            col: Number(col),
+            severity: sev === "error" ? "error" : "warning",
+            code,
+            message: msg.trim(),
+        });
+    }
+    return out;
+}
+async function runTsc(tsconfigPath, workspaceRoot) {
+    const cacheDir = path.join(getWorkspaceCacheDir(workspaceRoot), "diagnostics");
+    await mkdir(cacheDir, { recursive: true });
+    const tsbuildinfo = path.join(cacheDir, `${path.basename(path.dirname(tsconfigPath))}.tsbuildinfo`);
+    const tscPath = resolveTscPath();
+    if (!tscPath)
+        return null;
+    return await new Promise((resolve) => {
+        const child = spawn(process.execPath, [
+            tscPath,
+            "--noEmit",
+            "--pretty",
+            "false",
+            "--incremental",
+            "--tsBuildInfoFile",
+            tsbuildinfo,
+            "-p",
+            tsconfigPath,
+        ], {
+            cwd: workspaceRoot,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: process.env,
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            child.kill("SIGKILL");
+            resolve(null);
+        }, TSC_TIMEOUT_MS);
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString("utf8");
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        child.on("error", () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(null);
+        });
+        child.on("close", () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            const combined = stdout + (stderr ? `\n${stderr}` : "");
+            resolve({
+                diagnostics: parseTscOutput(combined, path.dirname(tsconfigPath)),
+            });
+        });
+    });
+}
+function formatDiagnostics(filePath, diags) {
+    const errors = diags.filter((d) => d.severity === "error");
+    if (errors.length === 0)
+        return undefined;
+    const limited = errors.slice(0, MAX_PER_FILE);
+    const more = errors.length - MAX_PER_FILE;
+    const suffix = more > 0 ? `\n... and ${more} more` : "";
+    const body = limited
+        .map((d) => `ERROR [${d.line}:${d.col}] ${d.message}`)
+        .join("\n");
+    return `<diagnostics file="${filePath}">\n${body}${suffix}\n</diagnostics>`;
+}
+/**
+ * Serialize diagnostic runs per workspace+tsconfig so concurrent edits don't
+ * trigger overlapping tsc processes that fight over the same .tsbuildinfo.
+ */
+const inflightByKey = new Map();
+function serializedRun(tsconfigPath, workspaceRoot) {
+    const key = `${workspaceRoot}::${tsconfigPath}`;
+    const prev = inflightByKey.get(key) ?? Promise.resolve(null);
+    const next = prev.then(() => runTsc(tsconfigPath, workspaceRoot));
+    inflightByKey.set(key, next.finally(() => {
+        if (inflightByKey.get(key) === next)
+            inflightByKey.delete(key);
+    }));
+    return next;
+}
+/**
+ * Run tsc against the nearest tsconfig and return an opencode-style
+ * `<diagnostics file="...">` block listing errors in the touched file. Returns
+ * undefined when there are no errors, when the file is not a TypeScript-family
+ * file, when no tsconfig is found, or when the run fails. Never throws.
+ */
+export async function buildPostEditDiagnostic(filePath, workspaceRoot) {
+    if (process.env[DISABLE_ENV] === "1")
+        return undefined;
+    const ext = path.extname(filePath).toLowerCase();
+    if (!TS_EXTENSIONS.has(ext))
+        return undefined;
+    try {
+        const tsconfig = await findNearestTsconfig(path.dirname(filePath), workspaceRoot);
+        if (!tsconfig)
+            return undefined;
+        const result = await serializedRun(tsconfig, workspaceRoot);
+        if (!result)
+            return undefined;
+        const absTouched = path.resolve(filePath);
+        const forFile = result.diagnostics.filter((d) => path.resolve(d.file) === absTouched);
+        const displayPath = path.relative(workspaceRoot, absTouched) || filePath;
+        return formatDiagnostics(displayPath, forFile);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/src/tools/read-symbol.js

@@ -1,5 +1,5 @@
 import { readFile, stat } from "node:fs/promises";
-import { resolveWorkspacePath, validateFileReadSize, expectNonEmptyString, expectOptionalBoolean, } from "@minicode/agent-sdk";
+import { resolveWorkspacePath, validateFileReadSize, expectNonEmptyString, expectOptionalBoolean, } from "@sean.holung/minicode-sdk";
 import { getSymbolDisplayName } from "../indexer/symbol-names.js";
 import { formatAmbiguousSymbolMatches, resolveSymbolInput, } from "../shared/symbol-resolution.js";
 const LEADING_CONTEXT_LINES = 3;
@@ -30,7 +30,7 @@ export function createReadSymbolTool(config, projectIndex) {
             const includeBody = expectOptionalBoolean(input, "includeBody") ?? true;
             const resolution = resolveSymbolInput(projectIndex, name);
             if (resolution.status === "missing") {
-                return `Symbol "${name}" not found in the project index. Try using search to find it, or use read_file to read the full file.`;
+                return `Symbol "${name}" not found in the project index. Try search_code_map first (grep over symbol signatures), then fall back to search (text/regex) or read_file (whole file) only if symbol-based retrieval can't find what you need.`;
             }
             if (resolution.status === "ambiguous") {
                 return formatAmbiguousSymbolMatches("read_symbol", name, resolution.matches);

package/dist/src/tools/registry.js

@@ -1,9 +1,11 @@
-import { ToolRegistry, createReadFileTool, createWriteFileTool, createEditFileTool, createSearchTool, createListFilesTool, createRunCommandTool, } from "@minicode/agent-sdk";
+import path from "node:path";
+import { ToolRegistry, createReadFileTool, createWriteFileTool, createEditFileTool, createSearchTool, createListFilesTool, createRunCommandTool, } from "@sean.holung/minicode-sdk";
 import { createFindReferencesTool } from "./find-references.js";
 import { createGetDependenciesTool } from "./get-dependencies.js";
 import { createReadSymbolTool } from "./read-symbol.js";
 import { createFindPathTool } from "./find-path.js";
 import { createSearchCodeMapTool } from "./search-code-map.js";
+import { buildPostEditDiagnostic } from "./post-edit-diagnostics.js";
 export { ToolRegistry };
 async function reindexBestEffort(projectIndex, relPath, content) {
     try {
@@ -16,12 +18,23 @@ async function reindexBestEffort(projectIndex, relPath, content) {
 /**
  * Create a ToolRegistry with the SDK's core tools plus indexer-specific tools
  * when a ProjectIndex is available.
+ *
+ * Set `MINICODE_TOOL_PROFILE=file-search-only` (or pass it via the env to a
+ * benchmark run) to omit the five graph-aware tools (`read_symbol`,
+ * `find_references`, `get_dependencies`, `find_path`, `search_code_map`).
+ * The code map remains in the system prompt — only the interactive tools
+ * are gated. This is the right shape for an `all-tools` vs.
+ * `file-search-only` ablation per `benchmarks/STRATEGY.md`.
  */
 export function createToolRegistry(config, projectIndex) {
     const hooks = projectIndex
         ? {
             afterWrite: (relPath, content) => reindexBestEffort(projectIndex, relPath, content),
-            afterEdit: (relPath, content) => reindexBestEffort(projectIndex, relPath, content),
+            afterEdit: async (absPath, content) => {
+                const relPath = path.relative(config.workspaceRoot, absPath);
+                await reindexBestEffort(projectIndex, relPath, content);
+                return await buildPostEditDiagnostic(absPath, config.workspaceRoot);
+            },
             afterCommand: async () => {
                 await projectIndex.refreshFromWorkspace();
             },
@@ -35,7 +48,9 @@ export function createToolRegistry(config, projectIndex) {
         createListFilesTool(config),
         createRunCommandTool(config, hooks ? { afterCommand: hooks.afterCommand } : undefined),
     ];
-    if (projectIndex) {
+    const includeGraphTools = projectIndex !== undefined &&
+        process.env.MINICODE_TOOL_PROFILE !== "file-search-only";
+    if (includeGraphTools && projectIndex) {
         tools.splice(1, 0, createReadSymbolTool(config, projectIndex));
         tools.splice(2, 0, createFindReferencesTool(projectIndex));
         tools.splice(3, 0, createGetDependenciesTool(projectIndex));