token-pilot 0.9.0 → 0.12.0

package/.claude-plugin/marketplace.json

@@ -1,8 +1,8 @@
 {
   "name": "token-pilot",
   "displayName": "Token Pilot",
-  "description": "Reduces token consumption by 80-95% via AST-aware lazy file reading. 14 MCP tools for structural code reading, symbol navigation, and cross-file search.",
-  "version": "0.9.0",
+  "description": "Reduces token consumption by 80-95% via AST-aware lazy file reading. 18 MCP tools for structural code reading, symbol navigation, and cross-file search.",
+  "version": "0.12.0",
   "author": "Digital-Threads",
   "repository": "https://github.com/Digital-Threads/token-pilot",
   "license": "MIT",

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "token-pilot",
-  "version": "0.9.0",
+  "version": "0.12.0",
   "description": "Reduces token consumption by 80-95% via AST-aware lazy file reading. Returns structural overviews instead of full files.",
   "author": "token-pilot",
   "license": "MIT",

package/CHANGELOG.md

@@ -5,6 +5,53 @@ 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.12.0] - 2026-03-14
+
+### Added
+- **Version check for all components** — on startup, checks token-pilot (npm), ast-index (GitHub releases), and context-mode (npm) in parallel. Non-blocking, fire-and-forget. Shows update notifications in stderr.
+- **`autoUpdate` config flag** — `updates.autoUpdate: true` in `.token-pilot.json` auto-downloads new ast-index binary on startup. Default: `false` (notify only). token-pilot and context-mode only notify (separate processes).
+- **`checkBinaryUpdate()`** — compares installed ast-index version vs latest GitHub release.
+- **`isNewerVersion()` utility** — semver comparison: strip `v` prefix, compare segments. Handles different lengths (`1.0` vs `1.0.1`).
+- **Common Lisp extensions** — `.lisp`, `.lsp`, `.cl`, `.asd` added to `CODE_EXTENSIONS` for ast-index v3.28+ compatibility.
+- **9 new tests** — `isNewerVersion()` covering major/minor/patch, same version, older, `v` prefix, different segment lengths, large numbers, real-world versions. Total: 217 tests.
+
+### Changed
+- **`doctor` command** — now shows 3 sections: token-pilot (installed/latest), ast-index (installed/latest/auto-update status), context-mode (detected/latest npm). Previously only showed ast-index binary status.
+- **`install-ast-index` command** — now also updates existing binary if newer version available on GitHub.
+- **`printHelp()`** — fixed tool count: 18 (was incorrectly showing 12 since v0.8.0).
+- **Startup update check** — replaced single `checkLatestVersion()` with `checkAllUpdates()` covering all 3 components via `Promise.allSettled`.
+
+### Fixed
+- **`test_summary` PHPUnit parser** — now counts both `Failures:` and `Errors:` (was only counting failures).
+- **`test_summary` cargo parser** — correctly identifies failure name-list section (no `----` markers) vs detail section.
+- **`test_summary` token estimation** — uses shared `estimateTokens()` instead of local duplicate.
+- **`smart_log` category detection** — `documentation` now matches docs pattern, `tests` (plural) matches test pattern, `optimize`/`optimization` match perf pattern.
+- **`explore_area` path boundary** — `startsWith(path + '/')` prevents `src/auth` matching `src/authorize/`.
+- **Validation consistency** — `validateSmartLogArgs` and `validateTestSummaryArgs` now use `optionalString`/`optionalNumber` helpers, reject empty strings, check integers.
+
+## [0.11.0] - 2026-03-14
+
+### Added
+- **`smart_log` tool** — structured git log with commit category detection (feat/fix/refactor/docs/test/chore/style/perf). Shows author breakdown, file stats (+/-), per-commit file list. Filters by path and ref. Raw git log → compact summary.
+- **`test_summary` tool** — runs test command and returns structured summary: total/passed/failed/skipped + failure details. Parsers for vitest, jest, pytest, phpunit, go test, cargo test, rspec, mocha + generic fallback. 200 lines of raw output → 10-15 lines.
+- **38 new tests** — smart_log parser (5), categorizer (4), test_summary parsers (17), runner detection (8), validation (4). Total: 208 tests (was 170).
+
+### Changed
+- **18 tools** (was 16) — added `smart_log`, `test_summary`
+- **MCP instructions** — added smart_log and test_summary to workflow guidance
+
+## [0.10.0] - 2026-03-14
+
+### Added
+- **`smart_diff` tool** — structural git diff with AST symbol mapping. Shows which functions/classes were modified/added/removed instead of raw patch output. Supports scopes: `unstaged`, `staged`, `commit` (ref required), `branch` (ref required). Small diffs (<=30 lines) include actual hunks, large diffs show summary. Returns `rawTokens` for precise savings analytics.
+- **`explore_area` tool** — one-call directory exploration combining outline + imports + tests + git changes. Replaces 3-5 separate tool calls when starting work on an area. Sections: `outline` (recursive depth 2), `imports` (external deps + who imports this area), `tests` (matching test/spec files), `changes` (recent git log). All sections run in parallel via `Promise.allSettled`.
+- **26 new tests** — smart_diff parser (10), symbol mapping (5), validation (11). Total: 170 tests (was 144).
+
+### Changed
+- **16 tools** (was 14) — added `smart_diff`, `explore_area`
+- **MCP instructions** — updated workflow: `project_overview → explore_area → smart_read → read_symbol → read_for_edit → edit → smart_diff`
+- **`outlineDir` and `CODE_EXTENSIONS` exported** from outline.ts for reuse by explore_area
+
 ## [0.9.0] - 2026-03-08
 
 ### Added

package/README.md

@@ -173,6 +173,10 @@ For more control, you can add rules to your project:
 | `find_unused` | manual | Detect dead code — unused functions, classes, variables. |
 | `code_audit` | multiple `Grep` | Code quality issues in one call: TODO/FIXME comments, deprecated symbols, structural code patterns (via ast-grep), decorator search. |
 | `module_info` | manual analysis | Module dependency analysis: dependencies, dependents, public API, unused deps. Use for architecture understanding and dependency cleanup. |
+| `smart_diff` | raw `git diff` | Structural diff with AST symbol mapping — shows which functions/classes changed instead of raw patch. Scopes: unstaged, staged, commit, branch. |
+| `explore_area` | outline + related_files + git log | One-call directory exploration: structure, imports, tests, recent changes. Replaces 3-5 separate calls. |
+| `smart_log` | raw `git log` | Structured commit history with category detection (feat/fix/refactor/docs), file stats, author breakdown. Filters by path and ref. |
+| `test_summary` | raw test output | Run tests and get structured summary: total/passed/failed + failure details. Supports vitest, jest, pytest, phpunit, go, cargo, rspec, mocha. |
 
 ### Analytics
 
@@ -351,6 +355,10 @@ src/
     code-audit.ts       — code_audit handler (TODOs, deprecated, patterns)
     project-overview.ts — project_overview (dual-detection + confidence)
     module-info.ts      — module_info handler (deps, dependents, API, unused)
+    smart-diff.ts       — smart_diff handler (structural git diff + symbol mapping)
+    explore-area.ts     — explore_area handler (outline + imports + tests + changes)
+    smart-log.ts        — smart_log handler (structured git log + category detection)
+    test-summary.ts     — test_summary handler (run tests + parse output)
     non-code.ts         — JSON/YAML/MD/TOML structural summaries
     export-ast-index.ts — AST export for context-mode BM25
   git/

package/dist/ast-index/binary-manager.d.ts

@@ -12,4 +12,17 @@ export declare function findBinary(configPath?: string | null): Promise<BinarySt
  * Download and install ast-index binary from GitHub releases.
  */
 export declare function installBinary(onProgress?: (msg: string) => void): Promise<BinaryStatus>;
+/**
+ * Check if a newer version of ast-index is available on GitHub.
+ * Non-blocking, returns null values on any error.
+ */
+export declare function checkBinaryUpdate(currentPath: string | null): Promise<{
+    current: string | null;
+    latest: string | null;
+    updateAvailable: boolean;
+}>;
+/**
+ * Compare two semver strings. Returns true if `latest` is newer than `current`.
+ */
+export declare function isNewerVersion(current: string, latest: string): boolean;
 //# sourceMappingURL=binary-manager.d.ts.map

package/dist/ast-index/binary-manager.js

@@ -86,6 +86,49 @@ export async function installBinary(onProgress) {
         throw err;
     }
 }
+/**
+ * Check if a newer version of ast-index is available on GitHub.
+ * Non-blocking, returns null values on any error.
+ */
+export async function checkBinaryUpdate(currentPath) {
+    if (!currentPath) {
+        return { current: null, latest: null, updateAvailable: false };
+    }
+    try {
+        const [current, release] = await Promise.all([
+            getBinaryVersion(currentPath),
+            fetchLatestRelease(),
+        ]);
+        const latest = release.tag.replace(/^v/, '');
+        if (!current) {
+            return { current: null, latest, updateAvailable: false };
+        }
+        return {
+            current,
+            latest,
+            updateAvailable: isNewerVersion(current, latest),
+        };
+    }
+    catch {
+        return { current: null, latest: null, updateAvailable: false };
+    }
+}
+/**
+ * Compare two semver strings. Returns true if `latest` is newer than `current`.
+ */
+export function isNewerVersion(current, latest) {
+    const c = current.replace(/^v/, '').split('.').map(Number);
+    const l = latest.replace(/^v/, '').split('.').map(Number);
+    for (let i = 0; i < Math.max(c.length, l.length); i++) {
+        const cv = c[i] ?? 0;
+        const lv = l[i] ?? 0;
+        if (lv > cv)
+            return true;
+        if (lv < cv)
+            return false;
+    }
+    return false;
+}
 // --- Internal helpers ---
 function getPlatform() {
     switch (platform()) {

package/dist/config/defaults.js

@@ -38,6 +38,10 @@ export const DEFAULT_CONFIG = {
         adviseDelegation: true,
         largeNonCodeThreshold: 200,
     },
+    updates: {
+        checkOnStartup: true,
+        autoUpdate: false,
+    },
     ignore: [
         'node_modules/**',
         'dist/**',

package/dist/core/validation.d.ts

@@ -110,6 +110,35 @@ export interface ModuleInfoArgs {
     check?: 'deps' | 'dependents' | 'api' | 'unused-deps' | 'all';
 }
 export declare function validateModuleInfoArgs(args: unknown): ModuleInfoArgs;
+/**
+ * Validate smart_diff arguments.
+ */
+export interface SmartDiffArgs {
+    scope?: 'unstaged' | 'staged' | 'commit' | 'branch';
+    path?: string;
+    ref?: string;
+}
+export declare function validateSmartDiffArgs(args: unknown): SmartDiffArgs;
+/**
+ * Validate explore_area arguments.
+ */
+export interface ExploreAreaArgs {
+    path: string;
+    include?: Array<'outline' | 'imports' | 'tests' | 'changes'>;
+}
+export declare function validateExploreAreaArgs(args: unknown): ExploreAreaArgs;
+export interface SmartLogArgs {
+    path?: string;
+    count?: number;
+    ref?: string;
+}
+export declare function validateSmartLogArgs(args: unknown): SmartLogArgs;
+export interface TestSummaryArgs {
+    command: string;
+    runner?: string;
+    timeout?: number;
+}
+export declare function validateTestSummaryArgs(args: unknown): TestSummaryArgs;
 /** 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

@@ -293,6 +293,94 @@ export function validateModuleInfoArgs(args) {
         check: check ?? 'all',
     };
 }
+export function validateSmartDiffArgs(args) {
+    if (!args || typeof args !== 'object')
+        return { scope: 'unstaged' };
+    const a = args;
+    let scope;
+    if (a.scope !== undefined && a.scope !== null) {
+        const validScopes = ['unstaged', 'staged', 'commit', 'branch'];
+        if (typeof a.scope !== 'string' || !validScopes.includes(a.scope)) {
+            throw new Error(`"scope" must be one of: ${validScopes.join(', ')}`);
+        }
+        scope = a.scope;
+    }
+    const ref = optionalString(a.ref, 'ref');
+    if ((scope === 'commit' || scope === 'branch') && !ref) {
+        throw new Error(`"ref" is required when scope="${scope}".`);
+    }
+    return {
+        scope: scope ?? 'unstaged',
+        path: optionalString(a.path, 'path'),
+        ref,
+    };
+}
+const VALID_EXPLORE_SECTIONS = ['outline', 'imports', 'tests', 'changes'];
+export function validateExploreAreaArgs(args) {
+    if (!args || typeof args !== 'object') {
+        throw new Error('Arguments must be an object with a "path" parameter.');
+    }
+    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 (a.include !== undefined && a.include !== null) {
+        if (!Array.isArray(a.include)) {
+            throw new Error('"include" must be an array of section names.');
+        }
+        for (const item of a.include) {
+            if (typeof item !== 'string' || !VALID_EXPLORE_SECTIONS.includes(item)) {
+                throw new Error(`Each element of "include" must be one of: ${VALID_EXPLORE_SECTIONS.join(', ')}. Got: "${item}"`);
+            }
+        }
+        return { path: a.path, include: a.include };
+    }
+    return { path: a.path };
+}
+export function validateSmartLogArgs(args) {
+    if (!args || typeof args !== 'object')
+        return {};
+    const a = args;
+    const path = optionalString(a.path, 'path');
+    if (path !== undefined && path.length === 0) {
+        throw new Error('"path" must be a non-empty string.');
+    }
+    const count = optionalNumber(a.count, 'count');
+    if (count !== undefined) {
+        if (!Number.isInteger(count) || count < 1 || count > 50) {
+            throw new Error('"count" must be an integer between 1 and 50.');
+        }
+    }
+    const ref = optionalString(a.ref, 'ref');
+    if (ref !== undefined && ref.length === 0) {
+        throw new Error('"ref" must be a non-empty string.');
+    }
+    return { path, count, ref };
+}
+const VALID_RUNNERS = ['vitest', 'jest', 'pytest', 'phpunit', 'go', 'cargo', 'rspec', 'mocha'];
+export function validateTestSummaryArgs(args) {
+    if (!args || typeof args !== 'object') {
+        throw new Error('Arguments must be an object with a "command" parameter.');
+    }
+    const a = args;
+    if (typeof a.command !== 'string' || a.command.length === 0) {
+        throw new Error('Required parameter "command" must be a non-empty string.');
+    }
+    let runner;
+    if (a.runner !== undefined && a.runner !== null) {
+        if (typeof a.runner !== 'string' || !VALID_RUNNERS.includes(a.runner)) {
+            throw new Error(`"runner" must be one of: ${VALID_RUNNERS.join(', ')}`);
+        }
+        runner = a.runner;
+    }
+    const timeout = optionalNumber(a.timeout, 'timeout');
+    if (timeout !== undefined) {
+        if (!Number.isInteger(timeout) || timeout < 1000 || timeout > 300000) {
+            throw new Error('"timeout" must be an integer between 1000 and 300000 (ms).');
+        }
+    }
+    return { command: a.command, runner, timeout };
+}
 /** Detect roots that would cause ast-index to scan the entire filesystem */
 export function isDangerousRoot(root) {
     const normalized = root.replace(/\/+$/, '') || '/';

package/dist/handlers/explore-area.d.ts

@@ -0,0 +1,9 @@
+import type { AstIndexClient } from '../ast-index/client.js';
+import type { ExploreAreaArgs } from '../core/validation.js';
+export declare function handleExploreArea(args: ExploreAreaArgs, projectRoot: string, astIndex: AstIndexClient): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
+//# sourceMappingURL=explore-area.d.ts.map

package/dist/handlers/explore-area.js

@@ -0,0 +1,280 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readdir, stat } from 'node:fs/promises';
+import { resolve, relative, basename, dirname } from 'node:path';
+import { resolveSafePath } from '../core/validation.js';
+import { outlineDir, CODE_EXTENSIONS } from './outline.js';
+const execFileAsync = promisify(execFile);
+// ──────────────────────────────────────────────
+// Constants
+// ──────────────────────────────────────────────
+const MAX_IMPORT_FILES = 20;
+const MAX_OUTPUT_LINES = 500;
+// ──────────────────────────────────────────────
+// Handler
+// ──────────────────────────────────────────────
+export async function handleExploreArea(args, projectRoot, astIndex) {
+    // Resolve path — if it points to a file, use its parent directory
+    let absPath = resolveSafePath(projectRoot, args.path);
+    const pathStat = await stat(absPath).catch(() => null);
+    if (!pathStat) {
+        return {
+            content: [{ type: 'text', text: `Path "${args.path}" not found.` }],
+        };
+    }
+    if (!pathStat.isDirectory()) {
+        absPath = dirname(absPath);
+    }
+    const relDir = relative(projectRoot, absPath) || '.';
+    const include = args.include ?? ['outline', 'imports', 'tests', 'changes'];
+    // Collect code files for import/test analysis
+    const codeFiles = await listCodeFiles(absPath);
+    // Run all sections in parallel
+    const [outlineSection, importsSection, testsSection, changesSection] = await Promise.allSettled([
+        include.includes('outline') ? buildOutlineSection(absPath, projectRoot, astIndex) : Promise.resolve(null),
+        include.includes('imports') ? buildImportsSection(codeFiles, absPath, projectRoot, astIndex) : Promise.resolve(null),
+        include.includes('tests') ? buildTestsSection(codeFiles, absPath, projectRoot) : Promise.resolve(null),
+        include.includes('changes') ? buildChangesSection(relDir, projectRoot) : Promise.resolve(null),
+    ]);
+    // Assemble output
+    const lines = [];
+    const subdirCount = await countSubdirs(absPath);
+    lines.push(`AREA: ${relDir}/ (${codeFiles.length} code files${subdirCount > 0 ? `, ${subdirCount} subdirs` : ''})`);
+    lines.push('');
+    // Outline
+    const outlineLines = extractResult(outlineSection);
+    if (outlineLines) {
+        lines.push('STRUCTURE:');
+        lines.push(...outlineLines);
+        lines.push('');
+    }
+    // Imports
+    const importLines = extractResult(importsSection);
+    if (importLines) {
+        lines.push(...importLines);
+    }
+    // Tests
+    const testLines = extractResult(testsSection);
+    if (testLines) {
+        lines.push(...testLines);
+    }
+    // Changes
+    const changeLines = extractResult(changesSection);
+    if (changeLines) {
+        lines.push(...changeLines);
+    }
+    // Truncate if needed
+    if (lines.length > MAX_OUTPUT_LINES) {
+        lines.length = MAX_OUTPUT_LINES;
+        lines.push('... truncated. Use outline() on specific subdirectories for details.');
+    }
+    lines.push('HINT: Use smart_read(file) for details, read_symbol(path, symbol) for source code, find_usages(symbol) for references.');
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+// ──────────────────────────────────────────────
+// Outline section — reuses outlineDir from outline.ts
+// ──────────────────────────────────────────────
+async function buildOutlineSection(absPath, projectRoot, astIndex) {
+    const sections = [];
+    await outlineDir(absPath, sections, 0, 2, projectRoot, astIndex);
+    return sections;
+}
+// ──────────────────────────────────────────────
+// Imports section — aggregate external deps + who imports this area
+// ──────────────────────────────────────────────
+async function buildImportsSection(codeFiles, absPath, projectRoot, astIndex) {
+    if (!astIndex.isAvailable() || astIndex.isDisabled() || astIndex.isOversized()) {
+        return [];
+    }
+    const filesToAnalyze = codeFiles.slice(0, MAX_IMPORT_FILES);
+    const externalDeps = new Set();
+    const internalDeps = new Set();
+    const relDir = relative(projectRoot, absPath) || '.';
+    // Get imports for each file
+    const importResults = await Promise.allSettled(filesToAnalyze.map(f => astIndex.fileImports(f)));
+    for (const result of importResults) {
+        if (result.status !== 'fulfilled' || !result.value)
+            continue;
+        for (const imp of result.value) {
+            const source = imp.source;
+            if (!source)
+                continue;
+            if (source.startsWith('.') || source.startsWith('/')) {
+                // Internal import — track if it's outside this area
+                const resolved = resolve(absPath, source);
+                if (!resolved.startsWith(absPath + '/') && resolved !== absPath) {
+                    const relImport = relative(projectRoot, resolved).replace(/\.[^.]+$/, '');
+                    internalDeps.add(relImport);
+                }
+            }
+            else {
+                // External package
+                const pkg = source.startsWith('@') ? source.split('/').slice(0, 2).join('/') : source.split('/')[0];
+                externalDeps.add(pkg);
+            }
+        }
+    }
+    // Find who imports files from this area (reverse dependencies)
+    const importedBy = new Set();
+    const fileBasenames = filesToAnalyze.map(f => basename(f).replace(/\.[^.]+$/, ''));
+    const refResults = await Promise.allSettled(fileBasenames.slice(0, 10).map(name => astIndex.refs(name, 10)));
+    for (const result of refResults) {
+        if (result.status !== 'fulfilled' || !result.value)
+            continue;
+        const refs = result.value;
+        if (refs.imports) {
+            for (const imp of refs.imports) {
+                const impFile = imp.path;
+                if (!impFile)
+                    continue;
+                const relFile = relative(projectRoot, impFile);
+                // Only include files outside this area
+                if (!relFile.startsWith(relDir + '/') && relFile !== relDir) {
+                    importedBy.add(relFile.replace(/\.[^.]+$/, ''));
+                }
+            }
+        }
+    }
+    const lines = [];
+    if (externalDeps.size > 0) {
+        const deps = Array.from(externalDeps).sort().slice(0, 20);
+        lines.push(`IMPORTS: ${deps.join(', ')}${externalDeps.size > 20 ? ` ... (${externalDeps.size} total)` : ''}`);
+    }
+    if (internalDeps.size > 0) {
+        const deps = Array.from(internalDeps).sort().slice(0, 10);
+        lines.push(`INTERNAL DEPS: ${deps.join(', ')}${internalDeps.size > 10 ? ` ... (${internalDeps.size} total)` : ''}`);
+    }
+    if (importedBy.size > 0) {
+        const importers = Array.from(importedBy).sort().slice(0, 10);
+        lines.push(`IMPORTED BY: ${importers.join(', ')}${importedBy.size > 10 ? ` ... (${importedBy.size} total)` : ''}`);
+    }
+    if (lines.length > 0)
+        lines.push('');
+    return lines;
+}
+// ──────────────────────────────────────────────
+// Tests section — find test/spec files matching area files
+// ──────────────────────────────────────────────
+async function buildTestsSection(codeFiles, absPath, projectRoot) {
+    const testFiles = [];
+    const areaFileNames = new Set(codeFiles.map(f => basename(f).replace(/\.[^.]+$/, '')));
+    // Scan for test files: check area dir + common test dirs
+    const dirsToScan = [absPath];
+    // Check for sibling __tests__ or tests directory
+    const parent = dirname(absPath);
+    const areaName = basename(absPath);
+    const testDirCandidates = [
+        resolve(absPath, '__tests__'),
+        resolve(absPath, 'tests'),
+        resolve(absPath, 'test'),
+        resolve(parent, '__tests__', areaName),
+        resolve(parent, 'tests', areaName),
+    ];
+    for (const testDir of testDirCandidates) {
+        const testDirStat = await stat(testDir).catch(() => null);
+        if (testDirStat?.isDirectory()) {
+            dirsToScan.push(testDir);
+        }
+    }
+    // Also check project-level test directories
+    const projectTestDirs = [
+        resolve(projectRoot, 'tests'),
+        resolve(projectRoot, 'test'),
+        resolve(projectRoot, '__tests__'),
+    ];
+    for (const testDir of projectTestDirs) {
+        if (dirsToScan.includes(testDir))
+            continue;
+        const testDirStat = await stat(testDir).catch(() => null);
+        if (testDirStat?.isDirectory()) {
+            dirsToScan.push(testDir);
+        }
+    }
+    for (const dir of dirsToScan) {
+        try {
+            const entries = await readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isFile())
+                    continue;
+                const name = entry.name;
+                if (name.includes('.test.') || name.includes('.spec.') || name.includes('_test.') || name.includes('_spec.')) {
+                    // Check if this test corresponds to an area file
+                    const testBase = name
+                        .replace(/\.(test|spec)\./, '.')
+                        .replace(/_(test|spec)\./, '.')
+                        .replace(/\.[^.]+$/, '');
+                    if (areaFileNames.has(testBase) || dir !== absPath) {
+                        const relPath = relative(projectRoot, resolve(dir, name));
+                        if (!testFiles.includes(relPath)) {
+                            testFiles.push(relPath);
+                        }
+                    }
+                }
+            }
+        }
+        catch { /* skip unreadable dirs */ }
+    }
+    if (testFiles.length === 0)
+        return [];
+    const lines = [];
+    lines.push(`TESTS: ${testFiles.join(', ')}`);
+    lines.push('');
+    return lines;
+}
+// ──────────────────────────────────────────────
+// Changes section — recent git log for this area
+// ──────────────────────────────────────────────
+async function buildChangesSection(relDir, projectRoot) {
+    try {
+        const { stdout } = await execFileAsync('git', ['log', '--oneline', '-5', '--', relDir], { cwd: projectRoot, timeout: 5000 });
+        if (!stdout.trim())
+            return [];
+        const lines = [];
+        lines.push('RECENT CHANGES:');
+        for (const line of stdout.trim().split('\n')) {
+            lines.push(`  ${line}`);
+        }
+        lines.push('');
+        return lines;
+    }
+    catch {
+        return [];
+    }
+}
+// ──────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────
+function extractResult(settled) {
+    if (settled.status === 'fulfilled' && settled.value && settled.value.length > 0) {
+        return settled.value;
+    }
+    return null;
+}
+async function listCodeFiles(dirPath) {
+    try {
+        const entries = await readdir(dirPath, { withFileTypes: true });
+        const files = [];
+        for (const entry of entries) {
+            if (entry.isFile()) {
+                const ext = entry.name.split('.').pop()?.toLowerCase() ?? '';
+                if (CODE_EXTENSIONS.has(ext)) {
+                    files.push(resolve(dirPath, entry.name));
+                }
+            }
+        }
+        return files.sort();
+    }
+    catch {
+        return [];
+    }
+}
+async function countSubdirs(dirPath) {
+    try {
+        const entries = await readdir(dirPath, { withFileTypes: true });
+        return entries.filter(e => e.isDirectory()).length;
+    }
+    catch {
+        return 0;
+    }
+}
+//# sourceMappingURL=explore-area.js.map

package/dist/handlers/outline.d.ts

@@ -1,9 +1,15 @@
 import type { AstIndexClient } from '../ast-index/client.js';
 import type { OutlineArgs } from '../core/validation.js';
+export declare const CODE_EXTENSIONS: Set<string>;
 export declare function handleOutline(args: OutlineArgs, projectRoot: string, astIndex: AstIndexClient): Promise<{
     content: Array<{
         type: 'text';
         text: string;
     }>;
 }>;
+/**
+ * Outline a single directory. When depth < maxDepth and recursive,
+ * recurse into subdirectories. Otherwise show file counts only.
+ */
+export declare function outlineDir(absPath: string, sections: string[], depth: number, maxDepth: number, projectRoot: string, astIndex: AstIndexClient): Promise<void>;
 //# sourceMappingURL=outline.d.ts.map

package/dist/handlers/outline.js

@@ -1,11 +1,12 @@
 import { readdir, stat } from 'node:fs/promises';
 import { resolve, basename, relative } from 'node:path';
 import { resolveSafePath } from '../core/validation.js';
-const CODE_EXTENSIONS = new Set([
+export const CODE_EXTENSIONS = new Set([
     'ts', 'tsx', 'js', 'jsx', 'mjs', 'py', 'go', 'rs', 'java', 'kt', 'kts',
     'swift', 'cs', 'cpp', 'cc', 'cxx', 'hpp', 'c', 'h', 'php', 'rb', 'scala',
     'dart', 'lua', 'sh', 'bash', 'sql', 'r', 'vue', 'svelte', 'pl', 'pm',
     'ex', 'exs', 'groovy', 'm', 'proto', 'bsl',
+    'lisp', 'lsp', 'cl', 'asd',
 ]);
 // Standard HTTP verbs — protocol-level, not framework-specific
 const HTTP_VERBS = ['Get', 'Post', 'Put', 'Delete', 'Patch', 'Head', 'Options', 'All'];
@@ -35,7 +36,7 @@ const MAX_OUTLINE_LINES = 500;
  * Outline a single directory. When depth < maxDepth and recursive,
  * recurse into subdirectories. Otherwise show file counts only.
  */
-async function outlineDir(absPath, sections, depth, maxDepth, projectRoot, astIndex) {
+export async function outlineDir(absPath, sections, depth, maxDepth, projectRoot, astIndex) {
     // Guard: stop if output is already too large
     if (sections.length >= MAX_OUTLINE_LINES) {
         if (!sections[sections.length - 1]?.startsWith('⚠')) {