@@ -66,8 +66,8 @@ describe('the base3-fast root', () => {
     })
     expect(root.toolNames).toEqual([...plain.toolNames!, 'spawn_agents'])
     expect(root.spawnableAgents).toEqual([...BASE3_FAST_SPAWNABLE_AGENTS])
-    // Pickers and searchers for context, in parallel; the worker for slices.
-    expect(root.spawnableAgents).toContain('file-picker')
+    // Searchers for context, in parallel; the worker for slices.
+    expect(root.spawnableAgents).not.toContain('file-picker')
     expect(root.spawnableAgents).toContain('code-searcher')
     expect(root.spawnableAgents).toContain(FREEBUFF_BASE3_FAST_WORKER_AGENT_ID)
     // The base3 levers the runtime reads are untouched.
@@ -99,7 +99,7 @@ describe('the base3-fast root', () => {
     expect(guidance.split(/\s+/).length).toBeLessThan(600)
     // Firm about parallel helpers, and about reconciling what they produce.
     expect(guidance).toContain('really, really helpful')
-    expect(guidance).toContain('file-pickers')
+    expect(guidance).not.toContain('file-picker')
     expect(guidance).toContain('code-searchers')
     expect(guidance).toContain('coherence is your job')
     expect(guidance).toContain('names the files it edited')
 
@@ -9,9 +9,9 @@ import type { SecretAgentDefinition } from './types/secret-agent-definition'
 /**
  * base3-fast: base3's loop with a fan-out on top.
  *
- * The root is a base3 CLI root plus `spawn_agents` and three things to spawn:
- * `file-picker` and `code-searcher` for context, in parallel, and the worker
- * below for the one shape of work worth splitting — a large mechanical change
+ * The root is a base3 CLI root plus `spawn_agents` and two things to spawn:
+ * `code-searcher` for context, in parallel, and the worker below for the one
+ * shape of work worth splitting — a large mechanical change
  * repeated across many independent files. The root implements everything
  * else itself: across five 62-task runs the tasks it split were the ones it
  * did worst on and no faster than base3 (docs/benchmarks/base3-fast/). Every
@@ -34,11 +34,11 @@ import type { SecretAgentDefinition } from './types/secret-agent-definition'
  * FREEBUFF_FAST_MODE_MODEL_IDS (common/src/constants/freebuff-model-ids.ts).
  */
 
-/** Everything the root may spawn: pickers and searchers for context, the
- *  worker for slices. The code-searcher is programmatic — a batch of ripgrep
- *  queries and no model call — so it needs no free-mode allowlist entry. */
+/** Everything the root may spawn: searchers for context, the worker for
+ *  slices. The code-searcher is programmatic — a batch of ripgrep queries and
+ *  no model call — so it needs no free-mode allowlist entry. No file-picker
+ *  since 2026-10-16: the 62-task bench without it (2026-10-05) was a wash. */
 export const BASE3_FAST_SPAWNABLE_AGENTS = [
-  'file-picker',
   'code-searcher',
   FREEBUFF_BASE3_FAST_WORKER_AGENT_ID,
 ] as const
@@ -77,7 +77,7 @@ export function buildBase3FastGuidance(
 
 You are running in fast mode: besides your own tools you can spawn helpers with spawn_agents, and everything named in one spawn_agents call runs at the same time. Spawning context helpers in parallel is really, really helpful here and strongly encouraged. The notes below are the shape that works, not a script: when the user is asking a question, thinking something through or wants a small change, just answer or make it.
 
-**Context.** When a task needs you to understand code you have not read, start with one spawn_agents call that spawns several file-pickers, each prompted from a different angle (the feature itself, its callers and tests, the conventions it should match), together with code-searchers, each carrying a batch of ripgrep queries for the names and patterns involved — put every query you can already think of into that first round. Then read generously: one read_files call with every path that looked relevant, rather than one file per step. Follow up with another round of code-searchers when the first points somewhere specific; a second round of file-pickers is rarely worth it. Everything you need is in the repository in front of you: do not search the web for this project's own code, history or packages.
+**Context.** When a task needs you to understand code you have not read, start with one spawn_agents call that spawns several code-searchers, each carrying a batch of ripgrep queries from a different angle (the feature itself, its callers and tests, the conventions it should match) — put every query you can already think of into that first round. Then read generously: one read_files call with every path that looked relevant, rather than one file per step. Follow up with another round of code-searchers when the first points somewhere specific. Everything you need is in the repository in front of you: do not search the web for this project's own code, history or packages.
 
 **Implementing.** Make the change yourself. A change you hold in your head comes out coherent, and the slow part of any delegation is reading, reconciling and repairing what came back. Workers exist for one shape of work: a large, mechanical change repeated across many independent files, where each slice can be written without seeing the others, such as a rename across a tree or the same migration applied to dozens of modules. Only then spawn one ${workerAgentId} per slice, all in one spawn_agents call, after writing any piece the slices must agree on (a new type, signature or helper) yourself. Give each worker a short assignment that opens with "${BASE3_FAST_WORKER_ASSIGNMENT_OPENING}", then names the files it owns, the shared names it must use, and what belongs to another worker. Never give two workers the same file.
 
@@ -132,7 +132,7 @@ export function createBase3FastCliRoot(
     ...root,
     displayName: 'Buffy (fast mode)',
     spawnerPrompt:
-      'Fast-mode coding agent: gathers context with parallel file-pickers and code-searchers, implements the change itself, and can split a large mechanical change across parallel prompt-cached workers that report which files they changed',
+      'Fast-mode coding agent: gathers context with parallel code-searchers, implements the change itself, and can split a large mechanical change across parallel prompt-cached workers that report which files they changed',
     toolNames: [...root.toolNames!, 'spawn_agents'],
     spawnableAgents: BASE3_FAST_SPAWNABLE_AGENTS.map((id) =>
       id === FREEBUFF_BASE3_FAST_WORKER_AGENT_ID ? workerAgentId : id,
 
@@ -23,8 +23,7 @@ import type { SecretAgentDefinition } from './types/secret-agent-definition'
  *
  * At most FREEBUFF_PROJECTS_MAX_LIVE_SUBAGENTS run at once under one root,
  * nested ones included (the agent runtime's spawn_agents handler). The helpers
- * one of them spawns (file-picker and its file-lister, code-searcher,
- * researcher-web) count against that subagent's own MAX_LIVE_SUBAGENTS_PER_ROOT,
+ * one of them spawns (code-searcher, researcher-web) count against that subagent's own MAX_LIVE_SUBAGENTS_PER_ROOT,
  * apart from the root's and its siblings', so they neither starve nor are
  * starved by the rest of the tree. Every spawn_agents call is held to
  * MAX_SPAWN_AGENTS_PER_CALL. Every agent also has its step budget, and
 
@@ -176,7 +176,7 @@ export const FREEBUFF_DESKTOP_THREAD_AGENT_IDS = [
 /**
  * The base3-fast root and its worker subagent (agents/base3-fast.ts), one pair
  * for the one model that runs fast mode today. The root is a base3 root with
- * a fan-out: it spawns file-pickers in parallel, then
+ * a fan-out: it spawns code-searchers in parallel, then
  * splits the implementation across parallel workers that inherit its system
  * prompt and history (so their requests are prompt-cache hits), and verifies
  * the combined result itself. The worker is pinned to the same model as the
@@ -228,7 +228,7 @@ export const FREEBUFF_WEB_BASE3_AGENT_ID_BY_MODEL: Record<string, string> = {
   [FREEBUFF_DEEPSEEK_V4_PRO_MODEL_ID]: 'base3-free-deepseek',
   [FREEBUFF_DEEPSEEK_V4_FLASH_MODEL_ID]: 'base3-free-deepseek-flash',
   // Fast mode runs the base3-FAST harness (agents/base3-fast.ts): base3's
-  // loop plus parallel file-pickers and prompt-cached worker
+  // loop plus parallel code-searchers and prompt-cached worker
   // subagents. Registered in the base3 maps because it is the base3 family's
   // rollout shape (windowed reads, mechanical compaction, no instructions
   // prompt) with a fan-out on top; the no-subagents assertions on this map
 
@@ -4,6 +4,8 @@ All notable changes to the @codebuff/sdk package will be documented in this file
 
 ## [Unreleased]
 
+- New `skipSymbolIndex` run option: a fresh session builds the file tree but skips the tree-sitter parse of every project file, leaving `fileTokenScores` and `tokenCallers` empty. Set it when your agents do not use the file-picker, `read_subtree` symbols or `read_files`' `referencedBy`.
+
 - `compactRunState` now rewrites a run's history into at most 12k tokens (`MECHANICAL_HISTORY_TOKENS`) of summary plus a working set of file reads, whatever `maxContextLength` allows; it used to fill the budget. The newest read of each file not edited since comes back whole and every other read becomes an outline stub, so expect a much smaller `nextTokens`. The live request and the newest tool results are kept whole on top of the cap.
 
 - **Security:** `read_url` now connects only to an address it has just validated. Resolution and the private/reserved-address check happen in the connection's own `lookup`, and the host is refused if any answer is blocked, so a hostname can no longer pass the check with one answer and connect with another. Every redirect hop is validated the same way. More non-routable ranges are refused: IPv4-compatible IPv6 (`::a.b.c.d`), 198.18.0.0/15, `fec0::/10` and `64:ff9b:1::/48`. The tool call passes only `url` and `max_chars` through to `readUrl`. Under Bun with a proxy variable set, Bun's `fetch` is still used so the proxy keeps working.
 
@@ -5,6 +5,8 @@ import path from 'path'
 import { describe, expect, test, beforeEach, spyOn } from 'bun:test'
 import { z } from 'zod/v4'
 
+import { getAllFilePaths } from '@codebuff/common/project-file-tree'
+
 import { initialSessionState } from '../run-state'
 
 import type { MockStatResult } from '@codebuff/common/testing/mock-types'
@@ -160,6 +162,42 @@ describe('Initial Session State', () => {
     expect(readFilePaths.some((p) => p.endsWith('AGENTS.md'))).toBe(true)
   })
 
+  test('skipSymbolIndex builds the file tree without reading a source file', async () => {
+    mockFs.readdir = (async (dirPath: string) => {
+      if (dirPath === '/test-project') return ['src', '.gitignore']
+      if (dirPath === '/test-project/src') return ['index.ts', 'utils.ts']
+      return []
+    }) as CodebuffFileSystem['readdir']
+    mockFs.stat = (async (filePath: string) =>
+      ({
+        isDirectory: () => filePath === '/test-project/src',
+        isFile: () => filePath !== '/test-project/src',
+        size: 100,
+      }) as MockStatResult & { size: number }) as CodebuffFileSystem['stat']
+    const readFilePaths: string[] = []
+    const originalReadFile = mockFs.readFile
+    mockFs.readFile = (async (filePath: string, encoding?: BufferEncoding) => {
+      readFilePaths.push(filePath)
+      return originalReadFile(filePath, encoding)
+    }) as CodebuffFileSystem['readFile']
+
+    const sessionState = await initialSessionState({
+      cwd: '/test-project',
+      knowledgeFiles: {},
+      skipSymbolIndex: true,
+      fs: mockFs,
+      logger: mockLogger,
+    })
+
+    expect(getAllFilePaths(sessionState.fileContext.fileTree).sort()).toEqual(
+      ['.gitignore', 'src/index.ts', 'src/utils.ts'],
+    )
+    expect(sessionState.fileContext.fileTokenScores).toEqual({})
+    expect(sessionState.fileContext.tokenCallers).toEqual({})
+    // Only the walk's ignore files are read, never a file to parse.
+    expect(readFilePaths.some((p) => p.endsWith('.ts'))).toBe(false)
+  })
+
   test('derives knowledgeFiles from projectFiles when not provided', async () => {
     const projectFiles = {
       'src/index.ts': 'console.log("Hello world");',
 
@@ -116,6 +116,11 @@ export type InitialSessionStateOptions = {
   /** Precomputed index for exactly these `projectFiles` (see
    *  ComputedProjectIndex). Ignored when `projectFiles` is absent. */
   projectIndex?: ComputedProjectIndex
+  /** Build the file tree but skip the tree-sitter parse (it reads every
+   *  project file before the first request), leaving `fileTokenScores` and
+   *  `tokenCallers` empty. Only the file-picker's tree prompt, `read_subtree`
+   *  and `read_files`' `referencedBy` read them. */
+  skipSymbolIndex?: boolean
   knowledgeFiles?: Record<string, string>
   /** User-provided knowledge files that will be merged with home directory files */
   userKnowledgeFiles?: Record<string, string>
@@ -945,7 +950,9 @@ export async function initialSessionState(
           discoveredProject,
         })
       : undefined
-    if (projectIndex) {
+    if (projectIndex && params.skipSymbolIndex) {
+      fileTree = projectIndex.fileTree
+    } else if (projectIndex) {
       const result = await computeProjectIndex(projectIndex)
       fileTree = result.fileTree
       fileTokenScores = result.fileTokenScores
 
@@ -200,6 +200,8 @@ export type CodebuffClientOptions = {
    *  `computeProjectIndexFromFiles`). Skips the per-run tree-sitter parse;
    *  ignored when `projectFiles` is absent. */
   projectIndex?: ComputedProjectIndex
+  /** See `InitialSessionStateOptions.skipSymbolIndex`. */
+  skipSymbolIndex?: boolean
   knowledgeFiles?: Record<string, string>
   agentDefinitions?: AgentDefinition[]
   maxAgentSteps?: number
@@ -569,6 +571,7 @@ async function runOnce({
   includeHomeSkills,
   projectFiles,
   projectIndex,
+  skipSymbolIndex,
   knowledgeFiles,
   agentDefinitions,
   maxAgentSteps = MAX_AGENT_STEPS_DEFAULT,
@@ -661,6 +664,7 @@ async function runOnce({
       customToolDefinitions,
       projectFiles,
       projectIndex,
+      skipSymbolIndex,
       maxAgentSteps,
       fs,
       spawn,