token-pilot 0.10.0 → 0.13.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. 16 MCP tools for structural code reading, symbol navigation, and cross-file search.",
-  "version": "0.10.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.13.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.10.0",
+  "version": "0.13.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,41 @@ 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.13.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

package/README.md

@@ -175,6 +175,8 @@ For more control, you can add rules to your project:
 | `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
 
@@ -355,6 +357,8 @@ src/
     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

@@ -127,6 +127,18 @@ export interface ExploreAreaArgs {
     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

@@ -337,6 +337,50 @@ export function validateExploreAreaArgs(args) {
     }
     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.js

@@ -102,7 +102,7 @@ async function buildImportsSection(codeFiles, absPath, projectRoot, astIndex) {
             if (source.startsWith('.') || source.startsWith('/')) {
                 // Internal import — track if it's outside this area
                 const resolved = resolve(absPath, source);
-                if (!resolved.startsWith(absPath)) {
+                if (!resolved.startsWith(absPath + '/') && resolved !== absPath) {
                     const relImport = relative(projectRoot, resolved).replace(/\.[^.]+$/, '');
                     internalDeps.add(relImport);
                 }
@@ -129,7 +129,7 @@ async function buildImportsSection(codeFiles, absPath, projectRoot, astIndex) {
                     continue;
                 const relFile = relative(projectRoot, impFile);
                 // Only include files outside this area
-                if (!relFile.startsWith(relDir)) {
+                if (!relFile.startsWith(relDir + '/') && relFile !== relDir) {
                     importedBy.add(relFile.replace(/\.[^.]+$/, ''));
                 }
             }

package/dist/handlers/outline.js

@@ -6,6 +6,7 @@ export const CODE_EXTENSIONS = new Set([
     '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'];

package/dist/handlers/smart-diff.js

@@ -11,7 +11,7 @@ const MAX_FILES = 50;
 const MAX_OUTPUT_LINES = 500;
 export async function handleSmartDiff(args, projectRoot, astIndex) {
     // 1. Build git command
-    const gitArgs = buildGitArgs(args, projectRoot);
+    const gitArgs = buildGitArgs(args);
     // 2. Execute git diff
     let rawDiff;
     try {
@@ -71,21 +71,21 @@ export async function handleSmartDiff(args, projectRoot, astIndex) {
 // ──────────────────────────────────────────────
 // Git command builder
 // ──────────────────────────────────────────────
-function buildGitArgs(args, projectRoot) {
+function buildGitArgs(args) {
     const base = [];
     switch (args.scope) {
         case 'staged':
-            base.push('diff', '--cached');
+            base.push('diff', '--cached', '--no-color');
             break;
         case 'commit':
-            base.push('show', '--format=', args.ref);
+            base.push('show', '--format=', '--no-color', args.ref);
             break;
         case 'branch':
-            base.push('diff', `${args.ref}...HEAD`);
+            base.push('diff', '--no-color', `${args.ref}...HEAD`);
             break;
         case 'unstaged':
         default:
-            base.push('diff');
+            base.push('diff', '--no-color');
             break;
     }
     if (args.path) {
@@ -182,16 +182,27 @@ function flattenSymbols(symbols, prefix = '') {
 export function mapHunksToSymbols(hunks, structure) {
     const allSymbols = flattenSymbols(structure.symbols);
     const changedSymbols = new Map();
+    // Classify hunks: all-added, all-removed, or mixed
+    const hasAdded = hunks.some(h => h.lines.some(l => l.startsWith('+')));
+    const hasRemoved = hunks.some(h => h.lines.some(l => l.startsWith('-')));
     for (const hunk of hunks) {
         const hunkStart = hunk.newStart;
-        const hunkEnd = hunk.newStart + hunk.newCount - 1;
+        const hunkEnd = hunk.newCount > 0
+            ? hunk.newStart + hunk.newCount - 1
+            : hunk.newStart; // pure deletion: use newStart as point
         for (const sym of allSymbols) {
             if (hunkStart <= sym.end && hunkEnd >= sym.start) {
                 if (!changedSymbols.has(sym.name)) {
+                    // Determine changeType from hunk content
+                    let changeType = 'MODIFIED';
+                    if (hasAdded && !hasRemoved)
+                        changeType = 'ADDED';
+                    else if (hasRemoved && !hasAdded)
+                        changeType = 'REMOVED';
                     changedSymbols.set(sym.name, {
                         name: sym.name,
                         kind: sym.kind,
-                        changeType: 'MODIFIED',
+                        changeType,
                         lineRange: `[L${sym.start}-${sym.end}]`,
                     });
                 }
@@ -228,7 +239,8 @@ function formatSmartDiff(allFiles, processedFiles, symbolChanges, args, rawToken
         const symbols = symbolChanges.get(fd.path);
         if (symbols && symbols.length > 0) {
             for (const sc of symbols) {
-                lines.push(`  ${sc.changeType}: ${sc.name}() ${sc.lineRange}`);
+                const parens = ['function', 'method'].includes(sc.kind) ? '()' : '';
+                lines.push(`  ${sc.changeType}: ${sc.name}${parens} ${sc.lineRange}`);
             }
         }
         // Small diff: include actual hunks

package/dist/handlers/smart-log.d.ts

@@ -0,0 +1,21 @@
+import type { SmartLogArgs } from '../core/validation.js';
+export interface LogEntry {
+    hash: string;
+    date: string;
+    author: string;
+    message: string;
+    category: 'feat' | 'fix' | 'refactor' | 'docs' | 'test' | 'chore' | 'style' | 'perf' | 'other';
+    files: string[];
+    insertions: number;
+    deletions: number;
+}
+export declare function handleSmartLog(args: SmartLogArgs, projectRoot: string): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    rawTokens: number;
+}>;
+export declare function parseGitLog(raw: string): LogEntry[];
+export declare function categorizeCommit(message: string): LogEntry['category'];
+//# sourceMappingURL=smart-log.d.ts.map

package/dist/handlers/smart-log.js

@@ -0,0 +1,200 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { estimateTokens } from '../core/token-estimator.js';
+const execFileAsync = promisify(execFile);
+// ──────────────────────────────────────────────
+// Constants
+// ──────────────────────────────────────────────
+const RECORD_SEPARATOR = '<<<SEP>>>';
+const FIELD_SEPARATOR = '<<<F>>>';
+const MAX_COUNT = 50;
+// ──────────────────────────────────────────────
+// Handler
+// ──────────────────────────────────────────────
+export async function handleSmartLog(args, projectRoot) {
+    const count = Math.min(args.count ?? 10, MAX_COUNT);
+    const ref = args.ref ?? 'HEAD';
+    // Build git log command with --numstat for file stats
+    const gitArgs = [
+        'log',
+        `--format=${RECORD_SEPARATOR}%h${FIELD_SEPARATOR}%ad${FIELD_SEPARATOR}%an${FIELD_SEPARATOR}%s`,
+        '--date=short',
+        '--numstat',
+        `-n`, `${count}`,
+        '--', ref,
+    ];
+    if (args.path) {
+        gitArgs.push('--', args.path);
+    }
+    let rawOutput;
+    try {
+        const { stdout } = await execFileAsync('git', gitArgs, {
+            cwd: projectRoot,
+            timeout: 10000,
+            maxBuffer: 5 * 1024 * 1024,
+        });
+        rawOutput = stdout;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: 'text', text: `git log failed: ${msg}` }],
+            rawTokens: 0,
+        };
+    }
+    if (!rawOutput.trim()) {
+        return {
+            content: [{ type: 'text', text: 'No commits found.' }],
+            rawTokens: 0,
+        };
+    }
+    const rawTokens = estimateTokens(rawOutput);
+    const entries = parseGitLog(rawOutput);
+    const formatted = formatSmartLog(entries, args.path);
+    return {
+        content: [{ type: 'text', text: formatted }],
+        rawTokens,
+    };
+}
+// ──────────────────────────────────────────────
+// Parser
+// ──────────────────────────────────────────────
+export function parseGitLog(raw) {
+    const records = raw.split(RECORD_SEPARATOR).filter(r => r.trim());
+    const entries = [];
+    for (const record of records) {
+        const lines = record.trim().split('\n');
+        if (lines.length === 0)
+            continue;
+        const headerLine = lines[0];
+        const fields = headerLine.split(FIELD_SEPARATOR);
+        if (fields.length < 4)
+            continue;
+        const [hash, date, author, message] = fields;
+        // Parse numstat lines (insertions\tdeletions\tfile)
+        const files = [];
+        let insertions = 0;
+        let deletions = 0;
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            const parts = line.split('\t');
+            if (parts.length >= 3) {
+                const ins = parts[0] === '-' ? 0 : parseInt(parts[0], 10) || 0;
+                const del = parts[1] === '-' ? 0 : parseInt(parts[1], 10) || 0;
+                insertions += ins;
+                deletions += del;
+                files.push(parts.slice(2).join('\t'));
+            }
+        }
+        entries.push({
+            hash,
+            date,
+            author,
+            message,
+            category: categorizeCommit(message),
+            files,
+            insertions,
+            deletions,
+        });
+    }
+    return entries;
+}
+// ──────────────────────────────────────────────
+// Categorizer
+// ──────────────────────────────────────────────
+export function categorizeCommit(message) {
+    const lower = message.toLowerCase();
+    // Conventional commits prefix
+    if (/^feat[:(!\s]/.test(lower))
+        return 'feat';
+    if (/^fix[:(!\s]/.test(lower))
+        return 'fix';
+    if (/^refactor[:(!\s]/.test(lower))
+        return 'refactor';
+    if (/^docs?[:(!\s]/.test(lower))
+        return 'docs';
+    if (/^tests?[:(!\s]/.test(lower))
+        return 'test';
+    if (/^chore[:(!\s]/.test(lower))
+        return 'chore';
+    if (/^style[:(!\s]/.test(lower))
+        return 'style';
+    if (/^perf[:(!\s]/.test(lower))
+        return 'perf';
+    // Version bumps
+    if (/^v?\d+\.\d+/.test(lower))
+        return 'feat';
+    // Keyword heuristics with word boundaries (order matters — more specific first)
+    if (/\b(fix|bug|hotfix)\b/.test(lower) || /\bpatch\b/.test(lower))
+        return 'fix';
+    if (/\b(tests?|specs?|coverage)\b/.test(lower))
+        return 'test';
+    if (/\b(refactor|restructure|rename|extract)\b/.test(lower) || /\bmove\b/.test(lower))
+        return 'refactor';
+    if (/\b(docs?|documentation|readme|changelog)\b/.test(lower))
+        return 'docs';
+    if (/\b(add|new|implement|feature)\b/.test(lower))
+        return 'feat';
+    if (/\b(style|format|lint)\b/.test(lower))
+        return 'style';
+    if (/\b(perf|optimiz\w*|speed|faster?)\b/.test(lower))
+        return 'perf';
+    if (/\b(chore|bump|deps)\b/.test(lower) || /\bci\b/.test(lower) || /\bbuild\b/.test(lower))
+        return 'chore';
+    return 'other';
+}
+// ──────────────────────────────────────────────
+// Formatter
+// ──────────────────────────────────────────────
+function formatSmartLog(entries, pathFilter) {
+    if (entries.length === 0)
+        return 'No commits found.';
+    const lines = [];
+    // Header
+    const filterInfo = pathFilter ? ` (filtered: ${pathFilter})` : '';
+    lines.push(`GIT LOG: ${entries.length} commits${filterInfo}`);
+    lines.push('');
+    // Summary stats
+    const authors = new Map();
+    const categories = new Map();
+    let totalIns = 0;
+    let totalDel = 0;
+    for (const e of entries) {
+        authors.set(e.author, (authors.get(e.author) ?? 0) + 1);
+        categories.set(e.category, (categories.get(e.category) ?? 0) + 1);
+        totalIns += e.insertions;
+        totalDel += e.deletions;
+    }
+    // Category summary
+    const catParts = [];
+    for (const [cat, count] of Array.from(categories.entries()).sort((a, b) => b[1] - a[1])) {
+        catParts.push(`${cat}:${count}`);
+    }
+    lines.push(`BREAKDOWN: ${catParts.join(', ')} | +${totalIns}/-${totalDel} lines`);
+    // Authors
+    const authorParts = Array.from(authors.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([name, cnt]) => authors.size > 1 ? `${name} (${cnt})` : name);
+    lines.push(`AUTHORS: ${authorParts.join(', ')}`);
+    lines.push('');
+    // Entries
+    for (const e of entries) {
+        const filesSummary = e.files.length <= 3
+            ? e.files.join(', ')
+            : `${e.files.slice(0, 3).join(', ')} +${e.files.length - 3} more`;
+        const stats = e.insertions + e.deletions > 0
+            ? ` (+${e.insertions}/-${e.deletions})`
+            : '';
+        lines.push(`${e.hash} ${e.date} [${e.category}] ${e.message}${stats}`);
+        if (e.files.length > 0) {
+            lines.push(`  → ${filesSummary}`);
+        }
+    }
+    lines.push('');
+    lines.push('HINT: Use smart_diff(scope="commit", ref="<hash>") to see structural changes for a specific commit.');
+    return lines.join('\n');
+}
+//# sourceMappingURL=smart-log.js.map

package/dist/handlers/test-summary.d.ts

@@ -0,0 +1,25 @@
+import type { TestSummaryArgs } from '../core/validation.js';
+export interface TestResult {
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    duration?: string;
+    failures: FailedTest[];
+    suites?: number;
+}
+export interface FailedTest {
+    name: string;
+    file?: string;
+    error: string;
+}
+export declare function handleTestSummary(args: TestSummaryArgs, projectRoot: string): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    rawTokens: number;
+}>;
+export declare function detectRunner(command: string, output: string): string;
+export declare function parseTestOutput(output: string, runner: string): TestResult;
+//# sourceMappingURL=test-summary.d.ts.map

package/dist/handlers/test-summary.js

@@ -0,0 +1,321 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { estimateTokens } from '../core/token-estimator.js';
+const execFileAsync = promisify(execFile);
+// ──────────────────────────────────────────────
+// Handler
+// ──────────────────────────────────────────────
+export async function handleTestSummary(args, projectRoot) {
+    const command = args.command;
+    const parts = command.match(/(?:[^\s"]+|"[^"]*")+/g) ?? [command];
+    const bin = parts[0];
+    const binArgs = parts.slice(1).map(a => a.replace(/^"|"$/g, ''));
+    let rawOutput;
+    let exitCode = 0;
+    try {
+        const { stdout, stderr } = await execFileAsync(bin, binArgs, {
+            cwd: projectRoot,
+            timeout: args.timeout ?? 60000,
+            maxBuffer: 10 * 1024 * 1024,
+            env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1', CI: '1' },
+        });
+        rawOutput = stdout + '\n' + stderr;
+    }
+    catch (err) {
+        // Test runners exit with non-zero when tests fail — that's expected
+        const execErr = err;
+        rawOutput = (execErr.stdout ?? '') + '\n' + (execErr.stderr ?? '');
+        exitCode = execErr.code ?? 1;
+        // If no output at all, it's a real error
+        if (!rawOutput.trim()) {
+            return {
+                content: [{ type: 'text', text: `Command failed: ${command}\n${err instanceof Error ? err.message : String(err)}` }],
+                rawTokens: 0,
+            };
+        }
+    }
+    const rawTokens = estimateTokens(rawOutput);
+    const runner = args.runner ?? detectRunner(command, rawOutput);
+    const result = parseTestOutput(rawOutput, runner);
+    const formatted = formatTestSummary(result, command, runner, rawTokens);
+    return {
+        content: [{ type: 'text', text: formatted }],
+        rawTokens,
+    };
+}
+// ──────────────────────────────────────────────
+// Runner detection
+// ──────────────────────────────────────────────
+export function detectRunner(command, output) {
+    const cmd = command.toLowerCase();
+    if (cmd.includes('vitest'))
+        return 'vitest';
+    if (cmd.includes('jest'))
+        return 'jest';
+    if (cmd.includes('pytest') || cmd.includes('python -m pytest'))
+        return 'pytest';
+    if (cmd.includes('phpunit'))
+        return 'phpunit';
+    if (cmd.includes('cargo test'))
+        return 'cargo';
+    if (cmd.includes('go test'))
+        return 'go';
+    if (cmd.includes('rspec'))
+        return 'rspec';
+    if (cmd.includes('mocha'))
+        return 'mocha';
+    // Detect from output
+    const lower = output.toLowerCase();
+    if (lower.includes('vitest') || lower.includes('vite'))
+        return 'vitest';
+    if (lower.includes('jest'))
+        return 'jest';
+    if (lower.includes('pytest') || (lower.includes('=== ') && lower.includes(' passed')))
+        return 'pytest';
+    if (lower.includes('phpunit'))
+        return 'phpunit';
+    if (lower.includes('--- fail:') || lower.includes('--- pass:') || lower.includes('ok  \t'))
+        return 'go';
+    return 'generic';
+}
+// ──────────────────────────────────────────────
+// Parsers
+// ──────────────────────────────────────────────
+export function parseTestOutput(output, runner) {
+    switch (runner) {
+        case 'vitest':
+        case 'jest':
+            return parseVitestJest(output);
+        case 'pytest':
+            return parsePytest(output);
+        case 'phpunit':
+            return parsePhpunit(output);
+        case 'go':
+            return parseGoTest(output);
+        case 'cargo':
+            return parseCargoTest(output);
+        default:
+            return parseGeneric(output);
+    }
+}
+function parseVitestJest(output) {
+    const result = { total: 0, passed: 0, failed: 0, skipped: 0, failures: [] };
+    // Test Files  12 passed (12)  OR  Tests  170 passed (170)  OR  Tests  3 failed (3)
+    const testsLine = output.match(/Tests?\s+(?:(\d+)\s+failed\s*\|?\s*)?(?:(\d+)\s+passed\s*)?(?:\|?\s*(\d+)\s+skipped)?\s*\((\d+)\)/);
+    if (testsLine) {
+        result.failed = parseInt(testsLine[1] ?? '0', 10);
+        result.passed = parseInt(testsLine[2] ?? '0', 10);
+        result.skipped = parseInt(testsLine[3] ?? '0', 10);
+        result.total = parseInt(testsLine[4], 10);
+    }
+    // Test Files count
+    const suitesLine = output.match(/Test Files\s+(?:\d+\s+failed\s*\|?\s*)?(\d+)\s+passed\s*\((\d+)\)/);
+    if (suitesLine) {
+        result.suites = parseInt(suitesLine[2], 10);
+    }
+    // Duration
+    const duration = output.match(/Duration\s+([\d.]+\w?\s*(?:\([^)]+\))?)/);
+    if (duration) {
+        result.duration = duration[1].trim();
+    }
+    // Parse failures
+    // FAIL  tests/foo.test.ts > describe > test name
+    const failBlocks = output.split(/(?:FAIL|✕|×)\s+/).slice(1);
+    for (const block of failBlocks.slice(0, 10)) {
+        const lines = block.split('\n');
+        const firstLine = lines[0]?.trim() ?? '';
+        const errorLines = [];
+        for (let i = 1; i < Math.min(lines.length, 8); i++) {
+            const line = lines[i]?.trim();
+            if (!line)
+                continue;
+            if (line.startsWith('at ') || line.startsWith('❯'))
+                continue;
+            if (line.startsWith('⎯') || line.startsWith('─'))
+                break;
+            errorLines.push(line);
+        }
+        if (firstLine) {
+            result.failures.push({
+                name: firstLine.substring(0, 200),
+                error: errorLines.join('\n').substring(0, 300),
+            });
+        }
+    }
+    return result;
+}
+function parsePytest(output) {
+    const result = { total: 0, passed: 0, failed: 0, skipped: 0, failures: [] };
+    // === 5 passed, 1 failed, 2 skipped in 1.23s ===
+    const summary = output.match(/=+\s*(.*?)\s*=+\s*$/m);
+    if (summary) {
+        const parts = summary[1];
+        const passed = parts.match(/(\d+)\s+passed/);
+        const failed = parts.match(/(\d+)\s+failed/);
+        const skipped = parts.match(/(\d+)\s+skipped/);
+        const duration = parts.match(/in\s+([\d.]+s)/);
+        result.passed = parseInt(passed?.[1] ?? '0', 10);
+        result.failed = parseInt(failed?.[1] ?? '0', 10);
+        result.skipped = parseInt(skipped?.[1] ?? '0', 10);
+        result.total = result.passed + result.failed + result.skipped;
+        if (duration)
+            result.duration = duration[1];
+    }
+    // FAILED tests/test_foo.py::test_bar - AssertionError
+    const failedPattern = /^FAILED\s+(\S+)\s*-?\s*(.*)/gm;
+    let match;
+    while ((match = failedPattern.exec(output)) !== null) {
+        const [, name, error] = match;
+        result.failures.push({
+            name: name.substring(0, 200),
+            error: (error || '').substring(0, 300),
+        });
+    }
+    return result;
+}
+function parsePhpunit(output) {
+    const result = { total: 0, passed: 0, failed: 0, skipped: 0, failures: [] };
+    // OK (5 tests, 10 assertions) or  FAILURES! Tests: 5, Assertions: 10, Failures: 2, Errors: 1
+    const ok = output.match(/OK\s*\((\d+)\s+test/);
+    if (ok) {
+        result.total = parseInt(ok[1], 10);
+        result.passed = result.total;
+    }
+    const failures = output.match(/Tests:\s*(\d+).*?Failures:\s*(\d+)/);
+    if (failures) {
+        result.total = parseInt(failures[1], 10);
+        result.failed = parseInt(failures[2], 10);
+        // PHPUnit also reports Errors separately from Failures
+        const errors = output.match(/Errors:\s*(\d+)/);
+        if (errors) {
+            result.failed += parseInt(errors[1], 10);
+        }
+        result.passed = result.total - result.failed - result.skipped;
+    }
+    const duration = output.match(/Time:\s*([\d.:]+\s*\w*)/);
+    if (duration)
+        result.duration = duration[1].trim();
+    // 1) TestClass::testMethod
+    const failPattern = /^\d+\)\s+(\S+::\S+)/gm;
+    let match;
+    while ((match = failPattern.exec(output)) !== null) {
+        result.failures.push({
+            name: match[1].substring(0, 200),
+            error: '',
+        });
+    }
+    return result;
+}
+function parseGoTest(output) {
+    const result = { total: 0, passed: 0, failed: 0, skipped: 0, failures: [] };
+    const passLines = output.match(/^---\s+PASS:/gm);
+    const failLines = output.match(/^---\s+FAIL:/gm);
+    const skipLines = output.match(/^---\s+SKIP:/gm);
+    result.passed = passLines?.length ?? 0;
+    result.failed = failLines?.length ?? 0;
+    result.skipped = skipLines?.length ?? 0;
+    result.total = result.passed + result.failed + result.skipped;
+    // --- FAIL: TestFoo (0.00s)
+    const failPattern = /^---\s+FAIL:\s+(\S+)\s+\(([^)]+)\)/gm;
+    let match;
+    while ((match = failPattern.exec(output)) !== null) {
+        result.failures.push({
+            name: match[1],
+            error: `duration: ${match[2]}`,
+        });
+    }
+    // If zero counted, try "ok" / "FAIL" summary lines
+    if (result.total === 0) {
+        const okCount = (output.match(/^ok\s+/gm) ?? []).length;
+        const failCount = (output.match(/^FAIL\s+/gm) ?? []).length;
+        result.passed = okCount;
+        result.failed = failCount;
+        result.total = okCount + failCount;
+    }
+    return result;
+}
+function parseCargoTest(output) {
+    const result = { total: 0, passed: 0, failed: 0, skipped: 0, failures: [] };
+    // test result: ok. 5 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out
+    const summary = output.match(/test result:\s*\w+\.\s*(\d+)\s+passed;\s*(\d+)\s+failed;\s*(\d+)\s+ignored/);
+    if (summary) {
+        result.passed = parseInt(summary[1], 10);
+        result.failed = parseInt(summary[2], 10);
+        result.skipped = parseInt(summary[3], 10);
+        result.total = result.passed + result.failed + result.skipped;
+    }
+    // Cargo outputs two "failures:" sections:
+    // 1. Detail section: "failures:\n\n---- test_name stdout ----\n..."
+    // 2. Name-list section: "failures:\n    test_name_1\n    test_name_2\n"
+    // We want the name-list section (the last one before "test result:")
+    const failSections = output.split(/^failures:\s*$/m).slice(1);
+    for (const section of failSections) {
+        // The name-list section has indented test names without "---- ... ----"
+        const lines = section.split('\n').filter(l => l.trim());
+        const isNameList = lines.length > 0 && lines.every(l => /^\s+\S+/.test(l) && !l.includes('----'));
+        if (isNameList) {
+            for (const line of lines.slice(0, 10)) {
+                result.failures.push({ name: line.trim(), error: '' });
+            }
+            break;
+        }
+    }
+    return result;
+}
+function parseGeneric(output) {
+    const result = { total: 0, passed: 0, failed: 0, skipped: 0, failures: [] };
+    // Try common patterns
+    const passedMatch = output.match(/(\d+)\s+(?:passed|passing|ok|success)/i);
+    const failedMatch = output.match(/(\d+)\s+(?:failed|failing|error|fail)/i);
+    const skippedMatch = output.match(/(\d+)\s+(?:skipped|pending|ignored)/i);
+    const totalMatch = output.match(/(\d+)\s+(?:total|tests?|specs?)\b/i);
+    result.passed = parseInt(passedMatch?.[1] ?? '0', 10);
+    result.failed = parseInt(failedMatch?.[1] ?? '0', 10);
+    result.skipped = parseInt(skippedMatch?.[1] ?? '0', 10);
+    result.total = totalMatch
+        ? parseInt(totalMatch[1], 10)
+        : result.passed + result.failed + result.skipped;
+    return result;
+}
+// ──────────────────────────────────────────────
+// Formatter
+// ──────────────────────────────────────────────
+function formatTestSummary(result, command, runner, rawTokens) {
+    const lines = [];
+    const status = result.failed > 0 ? '❌ FAIL' : '✅ PASS';
+    lines.push(`TEST RESULT: ${status} (${runner})`);
+    lines.push('');
+    // Stats line
+    const parts = [];
+    parts.push(`${result.total} total`);
+    parts.push(`${result.passed} passed`);
+    if (result.failed > 0)
+        parts.push(`${result.failed} failed`);
+    if (result.skipped > 0)
+        parts.push(`${result.skipped} skipped`);
+    if (result.duration)
+        parts.push(`${result.duration}`);
+    if (result.suites)
+        parts.push(`${result.suites} suites`);
+    lines.push(parts.join(' | '));
+    // Failed tests detail
+    if (result.failures.length > 0) {
+        lines.push('');
+        lines.push('FAILURES:');
+        for (const f of result.failures.slice(0, 10)) {
+            lines.push(`  ✗ ${f.name}`);
+            if (f.error) {
+                for (const errLine of f.error.split('\n').slice(0, 3)) {
+                    lines.push(`    ${errLine}`);
+                }
+            }
+        }
+        if (result.failures.length > 10) {
+            lines.push(`  ... and ${result.failures.length - 10} more failures`);
+        }
+    }
+    lines.push('');
+    lines.push(`RAW OUTPUT: ~${rawTokens} tokens → test_summary: ~${estimateTokens(lines.join('\n'))} tokens`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=test-summary.js.map

package/dist/index.js

@@ -5,7 +5,8 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { createServer } from './server.js';
 import { installHook, uninstallHook } from './hooks/installer.js';
-import { findBinary, installBinary } from './ast-index/binary-manager.js';
+import { findBinary, installBinary, checkBinaryUpdate, isNewerVersion } from './ast-index/binary-manager.js';
+import { loadConfig } from './config/loader.js';
 import { isDangerousRoot } from './core/validation.js';
 const execFileAsync = promisify(execFile);
 const HOOK_DENY_THRESHOLD = 500;
@@ -14,6 +15,7 @@ const CODE_EXTENSIONS = new Set([
     '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',
 ]);
 function getVersion() {
     try {
@@ -114,12 +116,10 @@ async function startServer() {
             `  Fix: pass project path explicitly — token-pilot /path/to/project\n` +
             `  Or configure mcpServers with "args": ["/path/to/project"]`);
     }
-    // Non-blocking update check (logs to stderr, never blocks startup)
-    checkLatestVersion().then(latest => {
-        if (latest && latest !== getVersion()) {
-            console.error(`[token-pilot] Update available: ${getVersion()} → ${latest}. Run: npx token-pilot@latest`);
-        }
-    }).catch(() => { });
+    // Non-blocking update check for all components (logs to stderr, never blocks startup)
+    const config = await loadConfig(projectRoot);
+    const binaryStatus = await findBinary(config.astIndex.binaryPath);
+    checkAllUpdates(config, binaryStatus).catch(() => { });
     // Auto-install PreToolUse hook (non-blocking, Claude Code only)
     installHook(projectRoot).then(result => {
         if (result.installed) {
@@ -236,8 +236,15 @@ async function handleUninstallHook(projectRoot) {
 async function handleInstallAstIndex() {
     const status = await findBinary();
     if (status.available) {
-        console.log(`ast-index ${status.version} already available at ${status.path} (${status.source})`);
-        process.exit(0);
+        // Check if update is available
+        const update = await checkBinaryUpdate(status.path);
+        if (update.updateAvailable) {
+            console.log(`ast-index ${update.current} installed, updating to ${update.latest}...`);
+        }
+        else {
+            console.log(`ast-index ${status.version} already up to date at ${status.path} (${status.source})`);
+            process.exit(0);
+        }
     }
     try {
         const result = await installBinary((msg) => console.log(msg));
@@ -251,43 +258,69 @@ async function handleInstallAstIndex() {
 }
 async function handleDoctor() {
     const version = getVersion();
-    console.log(`token-pilot v${version}\n`);
-    // Check Node.js version
+    const { existsSync } = await import('node:fs');
+    const { join } = await import('node:path');
+    const cwd = process.cwd();
+    console.log(`token-pilot doctor v${version}\n`);
+    // ── Environment ──
     const nodeVersion = process.version;
     const nodeMajor = parseInt(nodeVersion.slice(1), 10);
-    console.log(`Node.js:      ${nodeVersion} ${nodeMajor >= 18 ? '✓' : '✗ (requires >=18)'}`);
-    // Check ast-index
-    const astStatus = await findBinary();
-    if (astStatus.available) {
-        console.log(`ast-index:    ${astStatus.version} ✓ (${astStatus.source}: ${astStatus.path})`);
+    console.log(`Node.js:        ${nodeVersion} ${nodeMajor >= 18 ? '✓' : '✗ (requires >=18)'}`);
+    const configPath = join(cwd, '.token-pilot.json');
+    console.log(`config:         ${existsSync(configPath) ? configPath + ' ✓' : 'default (no .token-pilot.json)'}`);
+    const gitDir = join(cwd, '.git');
+    console.log(`git repo:       ${existsSync(gitDir) ? 'yes ✓' : 'no (read_diff/git features unavailable)'}`);
+    console.log('');
+    // ── token-pilot ──
+    console.log('── token-pilot ──');
+    console.log(`  installed:    ${version}`);
+    const tpLatest = await checkNpmLatest('token-pilot');
+    if (tpLatest) {
+        if (isNewerVersion(version, tpLatest)) {
+            console.log(`  latest:       ${tpLatest} (update available!)`);
+            console.log(`  run:          npx clear-npx-cache && npx -y token-pilot@latest`);
+        }
+        else {
+            console.log(`  latest:       ${tpLatest} ✓ (up to date)`);
+        }
     }
     else {
-        console.log(`ast-index:    not found ✗`);
-        console.log(`              Run: npx token-pilot install-ast-index`);
-    }
-    // Check for updates
-    const latest = await checkLatestVersion();
-    if (latest) {
-        if (latest !== version) {
-            console.log(`npm version:  ${latest} (current: ${version} — update available!)`);
-            console.log(`              Run: npx clear-npx-cache && npx -y token-pilot@latest`);
+        console.log(`  latest:       could not check (network error)`);
+    }
+    console.log('');
+    // ── ast-index ──
+    console.log('── ast-index ──');
+    const astStatus = await findBinary();
+    if (astStatus.available) {
+        console.log(`  installed:    ${astStatus.version} (${astStatus.source}: ${astStatus.path})`);
+        const astUpdate = await checkBinaryUpdate(astStatus.path);
+        if (astUpdate.updateAvailable) {
+            console.log(`  latest:       ${astUpdate.latest} (update available!)`);
+            console.log(`  run:          npx token-pilot install-ast-index`);
         }
-        else {
-            console.log(`npm version:  ${latest} ✓ (up to date)`);
+        else if (astUpdate.latest) {
+            console.log(`  latest:       ${astUpdate.latest} ✓ (up to date)`);
         }
+        const config = await loadConfig(cwd);
+        console.log(`  auto-update:  ${config.updates.autoUpdate ? 'enabled ✓' : 'disabled (set updates.autoUpdate=true in .token-pilot.json)'}`);
     }
     else {
-        console.log(`npm version:  could not check (network error)`);
+        console.log(`  installed:    not found ✗`);
+        console.log(`  run:          npx token-pilot install-ast-index`);
+    }
+    console.log('');
+    // ── context-mode ──
+    console.log('── context-mode ──');
+    const { detectContextMode } = await import('./integration/context-mode-detector.js');
+    const cmStatus = await detectContextMode(cwd);
+    console.log(`  detected:     ${cmStatus.detected ? `yes (${cmStatus.source})` : 'no'}`);
+    const cmLatest = await checkNpmLatest('claude-context-mode');
+    if (cmLatest) {
+        console.log(`  latest npm:   ${cmLatest}`);
+    }
+    if (!cmStatus.detected) {
+        console.log(`  setup:        npx token-pilot init`);
     }
-    // Check config
-    const { existsSync } = await import('node:fs');
-    const { join } = await import('node:path');
-    const cwd = process.cwd();
-    const configPath = join(cwd, '.token-pilot.json');
-    console.log(`config:       ${existsSync(configPath) ? configPath + ' ✓' : 'default (no .token-pilot.json)'}`);
-    // Check git
-    const gitDir = join(cwd, '.git');
-    console.log(`git repo:     ${existsSync(gitDir) ? 'yes ✓' : 'no (read_diff/git features unavailable)'}`);
     console.log('');
     process.exit(0);
 }
@@ -343,11 +376,14 @@ async function handleInit(targetDir) {
     console.log(`\nRestart your AI assistant to activate.`);
     process.exit(0);
 }
-async function checkLatestVersion() {
+// ──────────────────────────────────────────────
+// Update checking
+// ──────────────────────────────────────────────
+async function checkNpmLatest(packageName) {
     try {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), 3000);
-        const resp = await fetch('https://registry.npmjs.org/token-pilot/latest', {
+        const resp = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
             signal: controller.signal,
         });
         clearTimeout(timeout);
@@ -360,6 +396,37 @@ async function checkLatestVersion() {
         return null;
     }
 }
+async function checkAllUpdates(config, binaryStatus) {
+    if (!config.updates.checkOnStartup)
+        return;
+    const [tpLatest, astUpdate, cmLatest] = await Promise.allSettled([
+        checkNpmLatest('token-pilot'),
+        binaryStatus.available ? checkBinaryUpdate(binaryStatus.path) : Promise.resolve(null),
+        checkNpmLatest('claude-context-mode'),
+    ]);
+    // token-pilot
+    const tpVersion = getVersion();
+    if (tpLatest.status === 'fulfilled' && tpLatest.value && isNewerVersion(tpVersion, tpLatest.value)) {
+        console.error(`[token-pilot] Update available: ${tpVersion} → ${tpLatest.value}. Run: npx token-pilot@latest`);
+    }
+    // ast-index
+    if (astUpdate.status === 'fulfilled' && astUpdate.value?.updateAvailable) {
+        const { current, latest } = astUpdate.value;
+        if (config.updates.autoUpdate) {
+            console.error(`[token-pilot] Auto-updating ast-index: ${current} → ${latest}...`);
+            installBinary(msg => console.error(`[token-pilot] ${msg}`)).catch(() => { });
+        }
+        else {
+            console.error(`[token-pilot] ast-index update: ${current} → ${latest}. Run: token-pilot install-ast-index`);
+        }
+    }
+    // context-mode (notification only — runs as separate MCP server)
+    if (cmLatest.status === 'fulfilled' && cmLatest.value) {
+        // We can't reliably detect the currently installed version of context-mode
+        // (it runs as separate process via npx). Just log latest available for doctor.
+        // On startup, we only notify if explicitly useful.
+    }
+}
 function printHelp() {
     console.log(`token-pilot v${getVersion()} — MCP server for token-efficient code reading
 
@@ -376,10 +443,10 @@ Usage:
 Quick start:
   npx token-pilot init              Setup .mcp.json (token-pilot + context-mode)
 
-MCP Tools (12):
-  smart_read, read_symbol, read_range, read_diff, smart_read_many, read_for_edit,
-  find_usages, find_unused, related_files, outline,
-  project_overview, session_analytics
+MCP Tools (18):
+  smart_read, read_symbol, read_range, read_diff, read_for_edit, smart_read_many,
+  find_usages, find_unused, related_files, outline, project_overview, session_analytics,
+  code_audit, module_info, smart_diff, explore_area, smart_log, test_summary
 `);
     process.exit(0);
 }

package/dist/server.js

@@ -30,9 +30,11 @@ import { handleCodeAudit } from './handlers/code-audit.js';
 import { handleModuleInfo } from './handlers/module-info.js';
 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 { detectContextMode } from './integration/context-mode-detector.js';
 import { estimateTokens } from './core/token-estimator.js';
-import { resolveSafePath, validateSmartReadArgs, validateReadSymbolArgs, validateReadRangeArgs, validateReadDiffArgs, validateFindUsagesArgs, validateSmartReadManyArgs, validateReadForEditArgs, validateRelatedFilesArgs, validateOutlineArgs, validateFindUnusedArgs, validateCodeAuditArgs, validateProjectOverviewArgs, validateModuleInfoArgs, validateSmartDiffArgs, validateExploreAreaArgs, } from './core/validation.js';
+import { resolveSafePath, validateSmartReadArgs, validateReadSymbolArgs, validateReadRangeArgs, validateReadDiffArgs, validateFindUsagesArgs, validateSmartReadManyArgs, validateReadForEditArgs, validateRelatedFilesArgs, validateOutlineArgs, validateFindUnusedArgs, validateCodeAuditArgs, validateProjectOverviewArgs, validateModuleInfoArgs, validateSmartDiffArgs, validateExploreAreaArgs, validateSmartLogArgs, validateTestSummaryArgs, } from './core/validation.js';
 export async function createServer(projectRoot, options) {
     const config = await loadConfig(projectRoot);
     const astIndex = new AstIndexClient(projectRoot, config.astIndex.timeout, {
@@ -187,6 +189,8 @@ export async function createServer(projectRoot, options) {
             '• Code quality audit → code_audit (TODOs, deprecated, structural code patterns)',
             '• Reviewing git changes → smart_diff (structural diff with symbol mapping, not raw patch)',
             '• Starting work on an area → explore_area (outline + imports + tests + git log in one call)',
+            '• Understanding commit history → smart_log (structured git log with categories, not raw output)',
+            '• Running tests → test_summary (structured pass/fail summary, not 200 lines of raw output)',
             '',
             'WHEN TO USE DEFAULT TOOLS (Token Pilot adds no value):',
             '• Small files (≤200 lines) → smart_read returns full content anyway, same as Read',
@@ -434,6 +438,31 @@ export async function createServer(projectRoot, options) {
                     required: ['path'],
                 },
             },
+            {
+                name: 'smart_log',
+                description: 'Use INSTEAD OF raw git log. Structured commit history with category detection (feat/fix/refactor/docs), file stats, author breakdown. Filters by path and ref.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Filter to specific file or directory' },
+                        count: { type: 'number', description: 'Number of commits (default: 10, max: 50)' },
+                        ref: { type: 'string', description: 'Git ref — branch, tag, or commit (default: HEAD)' },
+                    },
+                },
+            },
+            {
+                name: 'test_summary',
+                description: 'Run tests and return structured summary: total/passed/failed/skipped + failure details. 200 lines of raw output → 10-15 lines. Supports vitest, jest, pytest, phpunit, go test, cargo test.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        command: { type: 'string', description: 'Test command to run (e.g., "npm test", "pytest", "go test ./...")' },
+                        runner: { type: 'string', enum: ['vitest', 'jest', 'pytest', 'phpunit', 'go', 'cargo', 'rspec', 'mocha'], description: 'Force specific parser (auto-detected if omitted)' },
+                        timeout: { type: 'number', description: 'Timeout in ms (default: 60000, max: 300000)' },
+                    },
+                    required: ['command'],
+                },
+            },
         ],
     }));
     // Helper: get real full-file token count for honest analytics
@@ -604,6 +633,22 @@ export async function createServer(projectRoot, options) {
                     analytics.record({ tool: 'explore_area', path: eaArgs.path, tokensReturned: eaTokens, tokensWouldBe: eaWouldBe, timestamp: Date.now() });
                     return eaResult;
                 }
+                case 'smart_log': {
+                    const slArgs = validateSmartLogArgs(args);
+                    const slResult = await handleSmartLog(slArgs, projectRoot);
+                    const slText = slResult.content[0]?.text ?? '';
+                    const slTokens = estimateTokens(slText);
+                    analytics.record({ tool: 'smart_log', path: slArgs.path ?? 'all', tokensReturned: slTokens, tokensWouldBe: slResult.rawTokens || slTokens, timestamp: Date.now() });
+                    return { content: slResult.content };
+                }
+                case 'test_summary': {
+                    const tsArgs = validateTestSummaryArgs(args);
+                    const tsResult = await handleTestSummary(tsArgs, projectRoot);
+                    const tsText = tsResult.content[0]?.text ?? '';
+                    const tsTokens = estimateTokens(tsText);
+                    analytics.record({ tool: 'test_summary', path: tsArgs.command, tokensReturned: tsTokens, tokensWouldBe: tsResult.rawTokens || tsTokens, timestamp: Date.now() });
+                    return { content: tsResult.content };
+                }
                 default:
                     return {
                         content: [{ type: 'text', text: `Unknown tool: ${name}` }],

package/dist/types.d.ts

@@ -115,6 +115,10 @@ export interface TokenPilotConfig {
         adviseDelegation: boolean;
         largeNonCodeThreshold: number;
     };
+    updates: {
+        checkOnStartup: boolean;
+        autoUpdate: boolean;
+    };
     ignore: string[];
 }
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "token-pilot",
-  "version": "0.10.0",
+  "version": "0.13.0",
   "description": "Save 60-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",