token-pilot 0.17.0 → 0.18.0

package/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to Token Pilot will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.18.0] - 2026-04-05
+
+### Added
+- **`read_section` tool** — read a specific section from Markdown, YAML, JSON, or CSV files. Markdown: by heading name. YAML/JSON: by top-level key. CSV: by row range (`rows:1-50`). Much cheaper than reading the whole file.
+- **`read_for_edit` section parameter** — prepare edit context for non-code file sections. Works with all 4 formats.
+- **Markdown outline with line ranges** — `smart_read` on `.md` files now shows `[L5-20]` ranges and hints for `read_section`.
+- **YAML/JSON section ranges** — `smart_read` on `.yaml`/`.json` shows top-level key ranges.
+- **CSV smart_read** — shows columns, row count, sample rows, and hints for row-range reading.
+- **4 section parsers** — `markdown-sections.ts`, `yaml-sections.ts`, `json-sections.ts`, `csv-sections.ts`.
+
+### Changed
+- **20 tools** (was 19) — added `read_section`.
+- **492 tests** (was 441).
+
+### Fixed
+- `npm audit` — resolved brace-expansion, path-to-regexp, picomatch vulnerabilities.
+
 ## [0.17.0] - 2026-04-02
 
 ### Added

package/dist/core/validation.d.ts

@@ -80,6 +80,7 @@ export declare function validateReadForEditArgs(args: unknown): {
     include_callers?: boolean;
     include_tests?: boolean;
     include_changes?: boolean;
+    section?: string;
 };
 /**
  * Validate related_files arguments.
@@ -155,6 +156,10 @@ export interface TestSummaryArgs {
     timeout?: number;
 }
 export declare function validateTestSummaryArgs(args: unknown): TestSummaryArgs;
+export declare function validateReadSectionArgs(args: unknown): {
+    path: string;
+    heading: string;
+};
 /** Detect roots that would cause ast-index to scan the entire filesystem */
 export declare function isDangerousRoot(root: string): boolean;
 //# sourceMappingURL=validation.d.ts.map

package/dist/core/validation.js

@@ -228,8 +228,8 @@ export function validateReadForEditArgs(args) {
     if (typeof a.path !== 'string' || a.path.length === 0) {
         throw new Error('Required parameter "path" must be a non-empty string.');
     }
-    if (!a.symbol && !a.line && (!Array.isArray(a.symbols) || a.symbols.length === 0)) {
-        throw new Error('Either "symbol", "symbols", or "line" must be provided.');
+    if (!a.symbol && !a.line && (!Array.isArray(a.symbols) || a.symbols.length === 0) && !a.section) {
+        throw new Error('Either "symbol", "symbols", "line", or "section" must be provided.');
     }
     // Validate symbols array (batch mode)
     let symbols;
@@ -256,6 +256,7 @@ export function validateReadForEditArgs(args) {
         include_callers: optionalBool(a.include_callers, 'include_callers'),
         include_tests: optionalBool(a.include_tests, 'include_tests'),
         include_changes: optionalBool(a.include_changes, 'include_changes'),
+        section: optionalString(a.section, 'section'),
     };
 }
 /**
@@ -453,6 +454,19 @@ export function validateTestSummaryArgs(args) {
     }
     return { command: a.command, runner, timeout };
 }
+export function validateReadSectionArgs(args) {
+    if (!args || typeof args !== 'object') {
+        throw new Error('Arguments must be an object.');
+    }
+    const a = args;
+    if (typeof a.path !== 'string' || a.path.length === 0) {
+        throw new Error('Required parameter "path" must be a non-empty string.');
+    }
+    if (typeof a.heading !== 'string' || a.heading.length === 0) {
+        throw new Error('Required parameter "heading" must be a non-empty string.');
+    }
+    return { path: a.path, heading: a.heading };
+}
 /** Detect roots that would cause ast-index to scan the entire filesystem */
 export function isDangerousRoot(root) {
     const normalized = root.replace(/\/+$/, '') || '/';

package/dist/handlers/csv-sections.d.ts

@@ -0,0 +1,35 @@
+/**
+ * CSV parser — column-aware reading with row/column subsetting.
+ */
+export interface CsvOutline {
+    columns: string[];
+    rowCount: number;
+    sampleRows: string[][];
+}
+export interface CsvSection {
+    heading: string;
+    startLine: number;
+    endLine: number;
+    lineCount: number;
+}
+/**
+ * Parse CSV into an outline: columns, row count, sample.
+ * Simple parser — handles quoted fields with commas.
+ */
+export declare function parseCsvOutline(content: string): CsvOutline;
+/**
+ * Parse a row range specification into a CsvSection.
+ * Supported formats:
+ *   "rows:1-50" — row range (1-indexed, refers to data rows, not header)
+ *   "rows:1-50" with column filter isn't supported at section level
+ */
+export declare function parseCsvSectionSpec(heading: string, totalDataRows: number): CsvSection | null;
+/**
+ * Extract CSV rows for a section. Returns header + requested rows.
+ */
+export declare function extractCsvSectionContent(lines: string[], section: CsvSection): string;
+/**
+ * Format CSV outline for smart_read output.
+ */
+export declare function formatCsvOutline(filePath: string, outline: CsvOutline, lineCount: number): string;
+//# sourceMappingURL=csv-sections.d.ts.map

package/dist/handlers/csv-sections.js

@@ -0,0 +1,129 @@
+/**
+ * CSV parser — column-aware reading with row/column subsetting.
+ */
+/**
+ * Parse CSV into an outline: columns, row count, sample.
+ * Simple parser — handles quoted fields with commas.
+ */
+export function parseCsvOutline(content) {
+    const lines = content.split('\n').filter(l => l.trim());
+    if (lines.length === 0)
+        return { columns: [], rowCount: 0, sampleRows: [] };
+    const columns = parseCsvRow(lines[0]);
+    const dataLines = lines.slice(1);
+    const sampleRows = dataLines.slice(0, 5).map(parseCsvRow);
+    return {
+        columns,
+        rowCount: dataLines.length,
+        sampleRows,
+    };
+}
+/**
+ * Parse a row range specification into a CsvSection.
+ * Supported formats:
+ *   "rows:1-50" — row range (1-indexed, refers to data rows, not header)
+ *   "rows:1-50" with column filter isn't supported at section level
+ */
+export function parseCsvSectionSpec(heading, totalDataRows) {
+    // rows:N-M format
+    const rowMatch = heading.match(/^rows?:\s*(\d+)\s*-\s*(\d+)$/i);
+    if (rowMatch) {
+        const start = Math.max(1, parseInt(rowMatch[1], 10));
+        const end = Math.min(totalDataRows, parseInt(rowMatch[2], 10));
+        if (start > end || start > totalDataRows)
+            return null;
+        // +1 for header line offset
+        return {
+            heading: `rows ${start}-${end}`,
+            startLine: start + 1, // +1 because line 1 is header
+            endLine: end + 1,
+            lineCount: end - start + 1,
+        };
+    }
+    // Single row number
+    const singleMatch = heading.match(/^rows?:\s*(\d+)$/i);
+    if (singleMatch) {
+        const row = parseInt(singleMatch[1], 10);
+        if (row < 1 || row > totalDataRows)
+            return null;
+        return {
+            heading: `row ${row}`,
+            startLine: row + 1,
+            endLine: row + 1,
+            lineCount: 1,
+        };
+    }
+    return null;
+}
+/**
+ * Extract CSV rows for a section. Returns header + requested rows.
+ */
+export function extractCsvSectionContent(lines, section) {
+    const header = lines[0]; // always include header
+    const dataRows = lines.slice(section.startLine - 1, section.endLine);
+    return [header, ...dataRows].join('\n');
+}
+/**
+ * Parse a single CSV row handling quoted fields.
+ */
+function parseCsvRow(line) {
+    const fields = [];
+    let current = '';
+    let inQuote = false;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (inQuote) {
+            if (ch === '"') {
+                if (i + 1 < line.length && line[i + 1] === '"') {
+                    current += '"';
+                    i++; // skip escaped quote
+                }
+                else {
+                    inQuote = false;
+                }
+            }
+            else {
+                current += ch;
+            }
+        }
+        else {
+            if (ch === '"') {
+                inQuote = true;
+            }
+            else if (ch === ',') {
+                fields.push(current.trim());
+                current = '';
+            }
+            else {
+                current += ch;
+            }
+        }
+    }
+    fields.push(current.trim());
+    return fields;
+}
+/**
+ * Format CSV outline for smart_read output.
+ */
+export function formatCsvOutline(filePath, outline, lineCount) {
+    const lines = [
+        `FILE: ${filePath} (${lineCount} lines, CSV)`,
+        '',
+        `COLUMNS (${outline.columns.length}): ${outline.columns.join(', ')}`,
+        `ROWS: ${outline.rowCount}`,
+        '',
+    ];
+    if (outline.sampleRows.length > 0) {
+        lines.push(`SAMPLE (first ${outline.sampleRows.length} rows):`);
+        for (const row of outline.sampleRows) {
+            // Format as: col1=val1, col2=val2, ...
+            const pairs = outline.columns.map((col, i) => `${col}=${row[i] ?? ''}`);
+            lines.push(`  ${pairs.join(', ')}`);
+        }
+    }
+    lines.push('');
+    lines.push(`HINT: Use read_section("${filePath}", heading="rows:1-50") to load specific rows.`);
+    lines.push(`      Use read_section("${filePath}", heading="rows:${outline.rowCount}") for last row.`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=csv-sections.js.map

package/dist/handlers/json-sections.d.ts

@@ -0,0 +1,17 @@
+/**
+ * JSON section parser — parses top-level keys with line ranges.
+ */
+export interface JsonSection {
+    heading: string;
+    startLine: number;
+    endLine: number;
+    lineCount: number;
+}
+/**
+ * Parse JSON into sections based on top-level keys.
+ * Works with formatted JSON (pretty-printed). For minified JSON, returns empty.
+ */
+export declare function parseJsonSections(content: string): JsonSection[];
+export declare function findJsonSection(sections: JsonSection[], heading: string): JsonSection | undefined;
+export declare function extractJsonSectionContent(lines: string[], section: JsonSection): string;
+//# sourceMappingURL=json-sections.d.ts.map

package/dist/handlers/json-sections.js

@@ -0,0 +1,66 @@
+/**
+ * JSON section parser — parses top-level keys with line ranges.
+ */
+/**
+ * Parse JSON into sections based on top-level keys.
+ * Works with formatted JSON (pretty-printed). For minified JSON, returns empty.
+ */
+export function parseJsonSections(content) {
+    if (!content.trim())
+        return [];
+    const lines = content.split('\n');
+    if (lines.length < 3)
+        return []; // minified or trivial
+    // Find top-level keys: lines matching /^\s{0,2}"key":/ (0-2 spaces indent = top level)
+    const topKeys = [];
+    // Track brace depth to identify top-level
+    let depth = 0;
+    let inString = false;
+    let lineIdx = 0;
+    for (lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const line = lines[lineIdx];
+        // Simple top-level key detection: at depth 1 (inside root object)
+        // Match: "key": or "key" : at the beginning of a line (with indent)
+        if (depth === 1) {
+            const keyMatch = line.match(/^\s*"([^"]+)"\s*:/);
+            if (keyMatch) {
+                topKeys.push({ key: keyMatch[1], line: lineIdx + 1 });
+            }
+        }
+        // Track depth (simplified — doesn't handle strings perfectly but good enough for formatted JSON)
+        for (let ci = 0; ci < line.length; ci++) {
+            const ch = line[ci];
+            if (ch === '"' && (ci === 0 || line[ci - 1] !== '\\')) {
+                inString = !inString;
+            }
+            if (!inString) {
+                if (ch === '{' || ch === '[')
+                    depth++;
+                if (ch === '}' || ch === ']')
+                    depth--;
+            }
+        }
+    }
+    if (topKeys.length === 0)
+        return [];
+    const sections = [];
+    for (let i = 0; i < topKeys.length; i++) {
+        const start = topKeys[i].line;
+        const end = i + 1 < topKeys.length ? topKeys[i + 1].line - 1 : lines.length - 1; // -1 to exclude closing }
+        sections.push({
+            heading: topKeys[i].key,
+            startLine: start,
+            endLine: end,
+            lineCount: end - start + 1,
+        });
+    }
+    return sections;
+}
+export function findJsonSection(sections, heading) {
+    const normalized = heading.trim().toLowerCase();
+    return sections.find(s => s.heading.toLowerCase() === normalized);
+}
+export function extractJsonSectionContent(lines, section) {
+    return lines.slice(section.startLine - 1, section.endLine).join('\n');
+}
+//# sourceMappingURL=json-sections.js.map

package/dist/handlers/markdown-sections.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Markdown section parser — shared helper for section-aware tools.
+ * Parses heading structure with line ranges for targeted reading.
+ */
+export interface MarkdownSection {
+    heading: string;
+    level: number;
+    startLine: number;
+    endLine: number;
+    lineCount: number;
+}
+export declare function parseMarkdownSections(content: string): MarkdownSection[];
+export declare function findSection(sections: MarkdownSection[], heading: string): MarkdownSection | undefined;
+export declare function extractSectionContent(lines: string[], section: MarkdownSection): string;
+//# sourceMappingURL=markdown-sections.d.ts.map

package/dist/handlers/markdown-sections.js

@@ -0,0 +1,49 @@
+/**
+ * Markdown section parser — shared helper for section-aware tools.
+ * Parses heading structure with line ranges for targeted reading.
+ */
+export function parseMarkdownSections(content) {
+    if (!content.trim())
+        return [];
+    const lines = content.split('\n');
+    const headings = [];
+    for (let i = 0; i < lines.length; i++) {
+        const match = lines[i].match(/^(#{1,6})\s+(.+)/);
+        if (match) {
+            headings.push({
+                heading: match[2].trim(),
+                level: match[1].length,
+                line: i + 1,
+            });
+        }
+    }
+    if (headings.length === 0)
+        return [];
+    const sections = [];
+    for (let i = 0; i < headings.length; i++) {
+        const current = headings[i];
+        let endLine = lines.length;
+        for (let j = i + 1; j < headings.length; j++) {
+            if (headings[j].level <= current.level) {
+                endLine = headings[j].line - 1;
+                break;
+            }
+        }
+        sections.push({
+            heading: current.heading,
+            level: current.level,
+            startLine: current.line,
+            endLine,
+            lineCount: endLine - current.line + 1,
+        });
+    }
+    return sections;
+}
+export function findSection(sections, heading) {
+    const normalized = heading.replace(/^#+\s*/, '').trim().toLowerCase();
+    return sections.find(s => s.heading.toLowerCase() === normalized);
+}
+export function extractSectionContent(lines, section) {
+    return lines.slice(section.startLine - 1, section.endLine).join('\n');
+}
+//# sourceMappingURL=markdown-sections.js.map

package/dist/handlers/non-code.js

@@ -2,12 +2,16 @@ import { readFile } from 'node:fs/promises';
 import { extname } from 'node:path';
 import { estimateTokens } from '../core/token-estimator.js';
 import { resolveSafePath } from '../core/validation.js';
+import { parseMarkdownSections } from './markdown-sections.js';
+import { parseYamlSections } from './yaml-sections.js';
+import { parseJsonSections } from './json-sections.js';
+import { parseCsvOutline, formatCsvOutline } from './csv-sections.js';
 /**
  * Detect if a file is a non-code structured file (JSON, YAML, Markdown, etc.)
  */
 export function isNonCodeStructured(filePath) {
     const ext = extname(filePath).toLowerCase();
-    return ['.json', '.yaml', '.yml', '.md', '.markdown', '.toml'].includes(ext);
+    return ['.json', '.yaml', '.yml', '.md', '.markdown', '.toml', '.csv'].includes(ext);
 }
 /**
  * Generate a structural summary for non-code files.
@@ -37,6 +41,9 @@ export async function handleNonCodeRead(filePath, projectRoot, contextRegistry,
         case '.toml':
             summary = summarizeToml(filePath, content, lines.length);
             break;
+        case '.csv':
+            summary = summarizeCsv(filePath, content, lines.length);
+            break;
         default:
             return null;
     }
@@ -87,14 +94,34 @@ function summarizeJson(filePath, content, lineCount) {
     catch {
         lines.push('(Invalid JSON — parse error)');
     }
+    // Add section line ranges for navigation
+    const jsonSections = parseJsonSections(content);
+    if (jsonSections.length > 0) {
+        lines.push('');
+        lines.push('SECTION RANGES:');
+        for (const sec of jsonSections) {
+            lines.push(`  "${sec.heading}" [L${sec.startLine}-${sec.endLine}] (${sec.lineCount} lines)`);
+        }
+    }
+    lines.push('');
+    lines.push(`HINT: Use read_section("${filePath}", heading="<key>") to load a specific section.`);
     return lines.join('\n');
 }
 function summarizeYaml(filePath, content, lineCount) {
     const lines = [
         `FILE: ${filePath} (${lineCount} lines, YAML)`,
         '',
-        'STRUCTURE:',
     ];
+    // Add top-level section overview with line ranges
+    const yamlSections = parseYamlSections(content);
+    if (yamlSections.length > 0) {
+        lines.push('SECTIONS:');
+        for (const sec of yamlSections) {
+            lines.push(`  ${sec.heading}: [L${sec.startLine}-${sec.endLine}] (${sec.lineCount} lines)`);
+        }
+        lines.push('');
+    }
+    lines.push('STRUCTURE:');
     const rawLines = content.split('\n');
     const roots = [];
     // Stack tracks parent nodes at each indent level
@@ -159,6 +186,8 @@ function summarizeYaml(filePath, content, lineCount) {
             formatYamlNode(root, lines, 1, 3); // max 3 levels deep
         }
     }
+    lines.push('');
+    lines.push(`HINT: Use read_section("${filePath}", heading="<key>") to load a specific section.`);
     return lines.join('\n');
 }
 function formatYamlNode(node, lines, depth, maxDepth) {
@@ -194,16 +223,17 @@ function summarizeMarkdown(filePath, content, lineCount) {
     const lines = [
         `FILE: ${filePath} (${lineCount} lines, Markdown)`,
         '',
-        'TABLE OF CONTENTS:',
     ];
-    // Extract headings
-    for (const line of content.split('\n')) {
-        const match = line.match(/^(#{1,6})\s+(.+)/);
-        if (match) {
-            const level = match[1].length;
-            const indent = '  '.repeat(level - 1);
-            lines.push(`${indent}${match[2]}`);
-        }
+    const sections = parseMarkdownSections(content);
+    if (sections.length === 0) {
+        lines.push('(No headings found)');
+        return lines.join('\n');
+    }
+    lines.push('SECTIONS:');
+    for (const sec of sections) {
+        const indent = '  '.repeat(sec.level);
+        const hashes = '#'.repeat(sec.level);
+        lines.push(`${indent}${hashes} ${sec.heading} [L${sec.startLine}-${sec.endLine}] (${sec.lineCount} lines)`);
     }
     // Count code blocks
     const codeBlocks = (content.match(/```/g) || []).length / 2;
@@ -211,6 +241,9 @@ function summarizeMarkdown(filePath, content, lineCount) {
         lines.push('');
         lines.push(`Code blocks: ${Math.floor(codeBlocks)}`);
     }
+    lines.push('');
+    lines.push(`HINT: Use read_section("${filePath}", heading="<name>") to load a specific section.`);
+    lines.push(`      Use read_for_edit("${filePath}", section="<name>") for edit context.`);
     return lines.join('\n');
 }
 function summarizeToml(filePath, content, lineCount) {
@@ -228,4 +261,8 @@ function summarizeToml(filePath, content, lineCount) {
     }
     return lines.join('\n');
 }
+function summarizeCsv(filePath, content, lineCount) {
+    const outline = parseCsvOutline(content);
+    return formatCsvOutline(filePath, outline, lineCount);
+}
 //# sourceMappingURL=non-code.js.map

package/dist/handlers/read-for-edit.d.ts

@@ -11,6 +11,7 @@ export interface ReadForEditArgs {
     include_callers?: boolean;
     include_tests?: boolean;
     include_changes?: boolean;
+    section?: string;
 }
 export declare function handleReadForEdit(args: ReadForEditArgs, projectRoot: string, symbolResolver: SymbolResolver, fileCache: FileCache, contextRegistry: ContextRegistry, astIndex: AstIndexClient, options?: {
     actionableHints?: boolean;

package/dist/handlers/read-for-edit.js

@@ -2,7 +2,11 @@ import { readFile, stat, access } from 'node:fs/promises';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { createHash } from 'node:crypto';
-import { relative, join } from 'node:path';
+import { relative, join, extname } from 'node:path';
+import { parseMarkdownSections, findSection, extractSectionContent } from './markdown-sections.js';
+import { parseYamlSections, findYamlSection, extractYamlSectionContent } from './yaml-sections.js';
+import { parseJsonSections, findJsonSection, extractJsonSectionContent } from './json-sections.js';
+import { parseCsvOutline, parseCsvSectionSpec, extractCsvSectionContent } from './csv-sections.js';
 import { estimateTokens } from '../core/token-estimator.js';
 import { resolveSafePath } from '../core/validation.js';
 import { assessConfidence, formatConfidence } from '../core/confidence.js';
@@ -11,6 +15,108 @@ const DEFAULT_CONTEXT = 5;
 export async function handleReadForEdit(args, projectRoot, symbolResolver, fileCache, contextRegistry, astIndex, options) {
     const absPath = resolveSafePath(projectRoot, args.path);
     const ctx = args.context ?? DEFAULT_CONTEXT;
+    // Section mode: markdown/YAML section extraction for edit
+    if (args.section) {
+        const ext = extname(absPath).toLowerCase();
+        const supportedExts = new Set(['.md', '.markdown', '.yaml', '.yml', '.json', '.csv']);
+        if (!supportedExts.has(ext)) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `"section" parameter only works with Markdown, YAML, or JSON files. Got: ${ext}. Use "symbol" for code files.`,
+                    }],
+            };
+        }
+        const fileContent = await readFile(absPath, 'utf-8');
+        const fileLines = fileContent.split('\n');
+        // Cache file in fileCache for read_diff baseline
+        if (!fileCache.get(absPath)) {
+            const fileStat = await stat(absPath);
+            const hash = createHash('sha256').update(fileContent).digest('hex');
+            const language = ext === '.csv' ? 'csv' : ext === '.json' ? 'json' : (ext === '.md' || ext === '.markdown') ? 'markdown' : 'yaml';
+            fileCache.set(absPath, {
+                structure: { path: absPath, language, meta: { lines: fileLines.length, bytes: fileContent.length, lastModified: fileStat.mtimeMs, contentHash: hash }, imports: [], exports: [], symbols: [] },
+                content: fileContent, lines: fileLines, mtime: fileStat.mtimeMs, hash, lastAccess: Date.now(),
+            });
+        }
+        let sectionResult = null;
+        if (ext === '.md' || ext === '.markdown') {
+            const sections = parseMarkdownSections(fileContent);
+            const section = findSection(sections, args.section);
+            if (!section) {
+                const available = sections.map(s => s.heading).join(', ');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Section "${args.section}" not found in ${args.path}.\nAvailable: ${available}`,
+                        }],
+                };
+            }
+            const hashes = '#'.repeat(section.level);
+            sectionResult = { ...section, rawContent: extractSectionContent(fileLines, section), label: `${hashes} ${section.heading}` };
+        }
+        else if (ext === '.yaml' || ext === '.yml') {
+            const sections = parseYamlSections(fileContent);
+            const section = findYamlSection(sections, args.section);
+            if (!section) {
+                const available = sections.map(s => s.heading).join(', ');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Section "${args.section}" not found in ${args.path}.\nAvailable: ${available}`,
+                        }],
+                };
+            }
+            sectionResult = { ...section, rawContent: extractYamlSectionContent(fileLines, section), label: section.heading };
+        }
+        else if (ext === '.json') {
+            const sections = parseJsonSections(fileContent);
+            const section = findJsonSection(sections, args.section);
+            if (!section) {
+                const available = sections.map(s => s.heading).join(', ');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Section "${args.section}" not found in ${args.path}.\nAvailable: ${available}`,
+                        }],
+                };
+            }
+            sectionResult = { ...section, rawContent: extractJsonSectionContent(fileLines, section), label: section.heading };
+        }
+        else if (ext === '.csv') {
+            const outline = parseCsvOutline(fileContent);
+            const section = parseCsvSectionSpec(args.section, outline.rowCount);
+            if (!section) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Invalid section "${args.section}" for CSV. Use: rows:1-50 or row:5\nTotal rows: ${outline.rowCount}`,
+                        }],
+                };
+            }
+            sectionResult = { ...section, rawContent: extractCsvSectionContent(fileLines, section), label: section.heading };
+        }
+        if (!sectionResult) {
+            return { content: [{ type: 'text', text: `Unsupported file type: ${ext}` }] };
+        }
+        const outputLines = [
+            `FILE: ${args.path}`,
+            `EDIT SECTION: ${sectionResult.label} [L${sectionResult.startLine}-${sectionResult.endLine}] (${sectionResult.lineCount} lines)`,
+            '',
+            sectionResult.rawContent,
+            '',
+            `AFTER EDIT: Use read_diff("${args.path}") to verify changes (90% cheaper than re-reading).`,
+        ];
+        const output = outputLines.join('\n');
+        const tokens = estimateTokens(output);
+        contextRegistry.trackLoad(absPath, {
+            type: 'range',
+            startLine: sectionResult.startLine,
+            endLine: sectionResult.endLine,
+            tokens,
+        });
+        return { content: [{ type: 'text', text: output }] };
+    }
     // Get file content — also cache for read_diff baseline
     const cached = fileCache.get(absPath);
     let lines;

package/dist/handlers/read-section.d.ts

@@ -0,0 +1,12 @@
+import type { ContextRegistry } from '../core/context-registry.js';
+export interface ReadSectionArgs {
+    path: string;
+    heading: string;
+}
+export declare function handleReadSection(args: ReadSectionArgs, projectRoot: string, contextRegistry: ContextRegistry): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+//# sourceMappingURL=read-section.d.ts.map

package/dist/handlers/read-section.js

@@ -0,0 +1,96 @@
+import { readFile } from 'node:fs/promises';
+import { extname } from 'node:path';
+import { estimateTokens } from '../core/token-estimator.js';
+import { resolveSafePath } from '../core/validation.js';
+import { parseMarkdownSections, findSection, extractSectionContent } from './markdown-sections.js';
+import { parseYamlSections, findYamlSection, extractYamlSectionContent } from './yaml-sections.js';
+import { parseJsonSections, findJsonSection, extractJsonSectionContent } from './json-sections.js';
+import { parseCsvOutline, parseCsvSectionSpec, extractCsvSectionContent } from './csv-sections.js';
+export async function handleReadSection(args, projectRoot, contextRegistry) {
+    const absPath = resolveSafePath(projectRoot, args.path);
+    const ext = extname(absPath).toLowerCase();
+    const content = await readFile(absPath, 'utf-8');
+    const lines = content.split('\n');
+    // Dispatch to format-specific parser
+    let sectionData = null;
+    if (ext === '.md' || ext === '.markdown') {
+        const sections = parseMarkdownSections(content);
+        const section = findSection(sections, args.heading);
+        if (!section) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Section "${args.heading}" not found in ${args.path}.\nAvailable sections: ${sections.map(s => s.heading).join(', ')}`,
+                    }],
+            };
+        }
+        const hashes = '#'.repeat(section.level);
+        sectionData = { ...section, content: extractSectionContent(lines, section), label: `${hashes} ${section.heading}` };
+    }
+    else if (ext === '.yaml' || ext === '.yml') {
+        const sections = parseYamlSections(content);
+        const section = findYamlSection(sections, args.heading);
+        if (!section) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Section "${args.heading}" not found in ${args.path}.\nAvailable sections: ${sections.map(s => s.heading).join(', ')}`,
+                    }],
+            };
+        }
+        sectionData = { ...section, content: extractYamlSectionContent(lines, section), label: section.heading };
+    }
+    else if (ext === '.json') {
+        const sections = parseJsonSections(content);
+        const section = findJsonSection(sections, args.heading);
+        if (!section) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Section "${args.heading}" not found in ${args.path}.\nAvailable sections: ${sections.map(s => s.heading).join(', ')}`,
+                    }],
+            };
+        }
+        sectionData = { ...section, content: extractJsonSectionContent(lines, section), label: section.heading };
+    }
+    else if (ext === '.csv') {
+        const outline = parseCsvOutline(content);
+        const section = parseCsvSectionSpec(args.heading, outline.rowCount);
+        if (!section) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Invalid section spec "${args.heading}" for CSV. Use format: rows:1-50 or row:5\nTotal rows: ${outline.rowCount}`,
+                    }],
+            };
+        }
+        sectionData = { ...section, content: extractCsvSectionContent(lines, section), label: section.heading };
+    }
+    else {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `read_section supports: .md, .yaml, .yml, .json, .csv. Got: ${ext}`,
+                }],
+        };
+    }
+    const outputLines = [
+        `FILE: ${args.path}`,
+        `SECTION: ${sectionData.label} [L${sectionData.startLine}-${sectionData.endLine}] (${sectionData.lineCount} lines)`,
+        '',
+        sectionData.content,
+        '',
+        `HINT: Use read_for_edit("${args.path}", section="${sectionData.heading}") for edit context.`,
+        'CONTEXT TRACKED.',
+    ];
+    const output = outputLines.join('\n');
+    const tokens = estimateTokens(output);
+    contextRegistry.trackLoad(absPath, {
+        type: 'range',
+        startLine: sectionData.startLine,
+        endLine: sectionData.endLine,
+        tokens,
+    });
+    return { content: [{ type: 'text', text: output }] };
+}
+//# sourceMappingURL=read-section.js.map

package/dist/handlers/yaml-sections.d.ts

@@ -0,0 +1,17 @@
+/**
+ * YAML section parser — parses top-level keys with line ranges.
+ */
+export interface YamlSection {
+    heading: string;
+    startLine: number;
+    endLine: number;
+    lineCount: number;
+}
+/**
+ * Parse YAML into sections based on top-level keys.
+ * A top-level key is a key at indent level 0.
+ */
+export declare function parseYamlSections(content: string): YamlSection[];
+export declare function findYamlSection(sections: YamlSection[], heading: string): YamlSection | undefined;
+export declare function extractYamlSectionContent(lines: string[], section: YamlSection): string;
+//# sourceMappingURL=yaml-sections.d.ts.map

package/dist/handlers/yaml-sections.js

@@ -0,0 +1,46 @@
+/**
+ * YAML section parser — parses top-level keys with line ranges.
+ */
+/**
+ * Parse YAML into sections based on top-level keys.
+ * A top-level key is a key at indent level 0.
+ */
+export function parseYamlSections(content) {
+    if (!content.trim())
+        return [];
+    const lines = content.split('\n');
+    const topKeys = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Skip comments and empty lines
+        if (!line.trim() || line.trim().startsWith('#'))
+            continue;
+        // Top-level key: starts at column 0, has format "key:" or "key: value"
+        const match = line.match(/^([a-zA-Z_][a-zA-Z0-9_.-]*):/);
+        if (match) {
+            topKeys.push({ key: match[1], line: i + 1 });
+        }
+    }
+    if (topKeys.length === 0)
+        return [];
+    const sections = [];
+    for (let i = 0; i < topKeys.length; i++) {
+        const start = topKeys[i].line;
+        const end = i + 1 < topKeys.length ? topKeys[i + 1].line - 1 : lines.length;
+        sections.push({
+            heading: topKeys[i].key,
+            startLine: start,
+            endLine: end,
+            lineCount: end - start + 1,
+        });
+    }
+    return sections;
+}
+export function findYamlSection(sections, heading) {
+    const normalized = heading.trim().toLowerCase().replace(/:$/, '');
+    return sections.find(s => s.heading.toLowerCase() === normalized);
+}
+export function extractYamlSectionContent(lines, section) {
+    return lines.slice(section.startLine - 1, section.endLine).join('\n');
+}
+//# sourceMappingURL=yaml-sections.js.map

package/dist/server/tool-definitions.d.ts

@@ -38,12 +38,14 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             limit?: undefined;
@@ -104,12 +106,14 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             limit?: undefined;
@@ -170,12 +174,14 @@ export declare const TOOL_DEFINITIONS: ({
             include_edit_context?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             limit?: undefined;
@@ -226,12 +232,69 @@ export declare const TOOL_DEFINITIONS: ({
             show?: undefined;
             include_edit_context?: undefined;
             symbols?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
+            paths?: undefined;
+            kind?: undefined;
+            limit?: undefined;
+            lang?: undefined;
+            mode?: undefined;
+            include?: undefined;
+            recursive?: undefined;
+            max_depth?: undefined;
+            verbose?: undefined;
+            module?: undefined;
+            export_only?: undefined;
+            check?: undefined;
+            pattern?: undefined;
+            name?: undefined;
+            ref?: undefined;
+            count?: undefined;
+            command?: undefined;
+            runner?: undefined;
+            timeout?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            heading: {
+                type: string;
+                description: string;
+            };
+            show_imports?: undefined;
+            show_docs?: undefined;
+            depth?: undefined;
+            scope?: undefined;
+            symbol?: undefined;
+            context_before?: undefined;
+            context_after?: undefined;
+            show?: undefined;
+            include_edit_context?: undefined;
+            symbols?: undefined;
+            start_line?: undefined;
+            end_line?: undefined;
+            context_lines?: undefined;
+            line?: undefined;
+            context?: undefined;
+            include_callers?: undefined;
+            include_tests?: undefined;
+            include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             limit?: undefined;
@@ -280,11 +343,13 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             limit?: undefined;
@@ -348,6 +413,10 @@ export declare const TOOL_DEFINITIONS: ({
                 type: string;
                 description: string;
             };
+            section: {
+                type: string;
+                description: string;
+            };
             show_imports?: undefined;
             show_docs?: undefined;
             depth?: undefined;
@@ -358,6 +427,7 @@ export declare const TOOL_DEFINITIONS: ({
             include_edit_context?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             paths?: undefined;
             kind?: undefined;
@@ -407,12 +477,14 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             kind?: undefined;
             limit?: undefined;
             lang?: undefined;
@@ -482,11 +554,13 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             include?: undefined;
             recursive?: undefined;
@@ -532,12 +606,14 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             limit?: undefined;
@@ -581,12 +657,14 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             limit?: undefined;
@@ -639,12 +717,14 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             limit?: undefined;
@@ -688,12 +768,14 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             limit?: undefined;
@@ -746,12 +828,14 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             lang?: undefined;
@@ -811,12 +895,14 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             mode?: undefined;
@@ -862,12 +948,14 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             limit?: undefined;
@@ -918,12 +1006,14 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             limit?: undefined;
@@ -975,12 +1065,14 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             limit?: undefined;
@@ -1032,12 +1124,14 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             limit?: undefined;
@@ -1090,12 +1184,14 @@ export declare const TOOL_DEFINITIONS: ({
             symbols?: undefined;
             start_line?: undefined;
             end_line?: undefined;
+            heading?: undefined;
             context_lines?: undefined;
             line?: undefined;
             context?: undefined;
             include_callers?: undefined;
             include_tests?: undefined;
             include_changes?: undefined;
+            section?: undefined;
             paths?: undefined;
             kind?: undefined;
             limit?: undefined;

package/dist/server/tool-definitions.js

@@ -27,12 +27,15 @@ export const MCP_INSTRUCTIONS = [
     '15. Code quality → code_audit (TODOs, deprecated, structural patterns)',
     '16. Dead code → find_unused (unreferenced symbols across project)',
     '17. Module architecture → module_info (deps, dependents, public API)',
+    '18. Read markdown/yaml/json/csv section → read_section (loads one heading/key/row-range, NOT the whole file)',
+    '   - For editing sections: read_for_edit(path, section="Section Name")',
     '',
     'USE DEFAULT TOOLS ONLY FOR: regex text search → Grep | exact raw content → Read | non-code configs → Read',
     '',
     'WORKFLOWS:',
     '• Explore: project_overview → explore_area → smart_read → read_symbol',
     '• Edit: smart_read → read_symbol(include_edit_context=true) → Edit → read_diff',
+    '• Docs: smart_read (outline) → read_section → read_for_edit(section=) → Edit → read_diff',
     '• Refactor: find_usages → read_symbols → read_for_edit → Edit → test_summary',
     '• Audit: code_audit + find_unused + Grep (for regex patterns)',
 ].join('\n');
@@ -108,6 +111,18 @@ export const TOOL_DEFINITIONS = [
             required: ['path', 'start_line', 'end_line'],
         },
     },
+    {
+        name: 'read_section',
+        description: 'Read a specific section from Markdown, YAML, JSON, or CSV files. Markdown: by heading name. YAML/JSON: by top-level key. CSV: by row range (rows:1-50). Much cheaper than reading the whole file.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to .md, .yaml, .yml, .json, or .csv file' },
+                heading: { type: 'string', description: 'Section heading (Markdown), top-level key (YAML/JSON), or row range "rows:1-50" (CSV). Case-insensitive.' },
+            },
+            required: ['path', 'heading'],
+        },
+    },
     {
         name: 'read_diff',
         description: 'Use INSTEAD OF re-reading whole file after edits. Shows only changed hunks. REQUIRES: call smart_read or read_for_edit BEFORE editing to create baseline snapshot.',
@@ -138,6 +153,10 @@ export const TOOL_DEFINITIONS = [
                 include_callers: { type: 'boolean', description: 'Show top callers of this symbol (saves a separate find_usages call)' },
                 include_tests: { type: 'boolean', description: 'Show related test file and test names' },
                 include_changes: { type: 'boolean', description: 'Show recent git changes in the target region' },
+                section: {
+                    type: 'string',
+                    description: 'Section to edit: heading (Markdown), top-level key (YAML/JSON), or "rows:1-50" (CSV). Returns raw section content for Edit old_string.',
+                },
             },
             required: ['path'],
         },

package/dist/server.js

@@ -36,12 +36,13 @@ import { handleSmartDiff } from './handlers/smart-diff.js';
 import { handleExploreArea } from './handlers/explore-area.js';
 import { handleSmartLog } from './handlers/smart-log.js';
 import { handleTestSummary } from './handlers/test-summary.js';
+import { handleReadSection } from './handlers/read-section.js';
 import { detectContextMode } from './integration/context-mode-detector.js';
 import { estimateTokens } from './core/token-estimator.js';
 import { checkPolicy, isFullReadTool } from './core/policy-engine.js';
 import { MCP_INSTRUCTIONS, TOOL_DEFINITIONS } from './server/tool-definitions.js';
 import { createTokenEstimates } from './server/token-estimates.js';
-import { validateSmartReadArgs, validateReadSymbolArgs, validateReadSymbolsArgs, validateReadRangeArgs, validateReadDiffArgs, validateFindUsagesArgs, validateSmartReadManyArgs, validateReadForEditArgs, validateRelatedFilesArgs, validateOutlineArgs, validateFindUnusedArgs, validateCodeAuditArgs, validateProjectOverviewArgs, validateModuleInfoArgs, validateSmartDiffArgs, validateExploreAreaArgs, validateSmartLogArgs, validateTestSummaryArgs, } from './core/validation.js';
+import { validateSmartReadArgs, validateReadSymbolArgs, validateReadSymbolsArgs, validateReadRangeArgs, validateReadDiffArgs, validateFindUsagesArgs, validateSmartReadManyArgs, validateReadForEditArgs, validateRelatedFilesArgs, validateOutlineArgs, validateFindUnusedArgs, validateCodeAuditArgs, validateProjectOverviewArgs, validateModuleInfoArgs, validateSmartDiffArgs, validateExploreAreaArgs, validateSmartLogArgs, validateTestSummaryArgs, validateReadSectionArgs, } from './core/validation.js';
 export async function createServer(projectRoot, options) {
     const config = await loadConfig(projectRoot);
     const astIndex = new AstIndexClient(projectRoot, config.astIndex.timeout, {
@@ -310,6 +311,20 @@ export async function createServer(projectRoot, options) {
                     recordWithTrace({ tool: 'read_range', path: rangeArgs.path, tokensReturned: rangeTokens, tokensWouldBe: fullTokensRange || rangeTokens, timestamp: Date.now(), savingsCategory: detectSavingsCategory(rangeText), absPath: resolve(projectRoot, rangeArgs.path), args: rangeArgs });
                     return rangeResult;
                 }
+                case 'read_section': {
+                    const secArgs = validateReadSectionArgs(args);
+                    const secResult = await handleReadSection(secArgs, projectRoot, contextRegistry);
+                    const secText = secResult.content[0]?.text ?? '';
+                    const secTokens = estimateTokens(secText);
+                    const fullTokensSec = await fullFileTokens(secArgs.path);
+                    recordWithTrace({
+                        tool: 'read_section', path: secArgs.path,
+                        tokensReturned: secTokens, tokensWouldBe: fullTokensSec || secTokens,
+                        timestamp: Date.now(), savingsCategory: 'compression',
+                        absPath: resolve(projectRoot, secArgs.path), args: secArgs,
+                    });
+                    return secResult;
+                }
                 case 'read_diff': {
                     const diffArgs = validateReadDiffArgs(args);
                     const diffResult = await handleReadDiff(diffArgs, projectRoot, fileCache, contextRegistry);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "token-pilot",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Save up to 80% tokens when AI reads code — MCP server for token-efficient code navigation, AST-aware structural reading instead of dumping full files into context window",
   "type": "module",
   "main": "dist/index.js",