token-pilot 0.14.1 → 0.15.0

package/dist/ast-index/regex-parser.js

@@ -0,0 +1,118 @@
+/**
+ * Regex-based fallback parser for TypeScript/JavaScript.
+ * Used when the ast-index binary is unavailable.
+ * Extracts top-level symbols and class/interface members.
+ */
+const RESERVED = new Set([
+    'if', 'else', 'for', 'while', 'do', 'switch', 'return', 'throw', 'try', 'catch',
+    'const', 'let', 'var', 'import', 'export', 'default', 'new', 'typeof', 'instanceof',
+    'await', 'yield', 'delete', 'void', 'in', 'of', 'case', 'break', 'continue',
+]);
+// Top-level declaration patterns (matched against trimmed line at indent 0)
+const TOP_LEVEL = [
+    { re: /^(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(\w+)/, kind: 'class' },
+    { re: /^(?:export\s+)?interface\s+(\w+)/, kind: 'interface' },
+    { re: /^(?:export\s+)?(?:declare\s+)?(?:const\s+)?enum\s+(\w+)/, kind: 'enum' },
+    { re: /^(?:export\s+)?type\s+(\w+)\s*[=<]/, kind: 'type' },
+    { re: /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s*(\w+)/, kind: 'function' },
+    // const/let arrow or function expression: export const foo = (async)? (fn | arrow)
+    { re: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*(?::[^=\n]+)?\s*=\s*(?:async\s+)?(?:function|\([^)]*\)\s*=>|\w+\s*=>|<)/, kind: 'function' },
+];
+// Method pattern inside class/interface body (indented 2+ spaces)
+const METHOD_RE = /^(\s{2,})(?:(?:public|private|protected|static|abstract|override|readonly|async)\s+)*(?:get\s+|set\s+)?(\w+)\s*(?:<[^(]*>)?\s*\(/;
+export function parseTypeScriptRegex(content) {
+    const lines = content.split('\n');
+    const entries = [];
+    // Track which class/interface we're currently inside using brace depth
+    let braceDepth = 0;
+    let currentClass = null;
+    let classOpenDepth = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Count brace changes on this line (skip strings/comments roughly)
+        for (let j = 0; j < line.length; j++) {
+            const ch = line[j];
+            if (ch === '/' && line[j + 1] === '/')
+                break; // line comment
+            if (ch === '{')
+                braceDepth++;
+            else if (ch === '}')
+                braceDepth--;
+        }
+        // Close current class when we return to its opening depth
+        if (currentClass && braceDepth <= classOpenDepth) {
+            currentClass.end_line = lineNum;
+            currentClass = null;
+            classOpenDepth = -1;
+        }
+        if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*'))
+            continue;
+        const indent = line.match(/^(\s*)/)?.[1].length ?? 0;
+        // Top-level declarations (indent 0 only)
+        if (indent === 0) {
+            let hit = false;
+            for (const p of TOP_LEVEL) {
+                const m = trimmed.match(p.re);
+                if (!m)
+                    continue;
+                const name = m[1];
+                if (!name || RESERVED.has(name))
+                    continue;
+                const entry = {
+                    name,
+                    kind: p.kind,
+                    start_line: lineNum,
+                    end_line: 0,
+                    signature: trimmed.slice(0, 120),
+                    children: p.kind === 'class' || p.kind === 'interface' || p.kind === 'enum' ? [] : undefined,
+                };
+                entries.push(entry);
+                if (entry.children !== undefined) {
+                    currentClass = entry;
+                    // Class opens on this line — brace depth after counting this line
+                    classOpenDepth = braceDepth - 1;
+                }
+                hit = true;
+                break;
+            }
+            if (hit)
+                continue;
+        }
+        // Method declarations inside class/interface body
+        if (currentClass && indent >= 2) {
+            const m = line.match(METHOD_RE);
+            if (m) {
+                const name = m[2];
+                if (name && !RESERVED.has(name)) {
+                    // Exclude arrow assignments (those have = before the ()
+                    // and plain function calls like this.foo() or obj.method()
+                    const beforeParen = line.indexOf('(');
+                    const segment = line.slice(0, beforeParen);
+                    if (!segment.includes('.') && !segment.includes('=')) {
+                        currentClass.children.push({
+                            name,
+                            kind: 'method',
+                            start_line: lineNum,
+                            end_line: lineNum + 5,
+                            signature: trimmed.slice(0, 120),
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // Fill in end_line for top-level entries that didn't close via brace tracking
+    for (let i = 0; i < entries.length; i++) {
+        if (entries[i].end_line === 0) {
+            entries[i].end_line = i < entries.length - 1
+                ? entries[i + 1].start_line - 1
+                : lines.length;
+        }
+    }
+    return entries;
+}
+//# sourceMappingURL=regex-parser.js.map

package/dist/config/defaults.js

@@ -21,6 +21,7 @@ export const DEFAULT_CONFIG = {
         enabled: true,
         interceptRead: true,
         autoInstall: true,
+        denyThreshold: 300,
     },
     context: {
         estimateTokens: true,

package/dist/core/session-analytics.d.ts

@@ -26,7 +26,7 @@ export declare class SessionAnalytics {
     setContextModeStatus(status: ContextModeStatus): void;
     record(call: ToolCall): void;
     /**
-     * Generate a session report.
+     * Generate a compact session report (~5 lines).
      */
     report(): string;
     reset(): void;

package/dist/core/session-analytics.js

@@ -1,5 +1,4 @@
 import { formatDuration } from './format-duration.js';
-import { ALL_INTENTS } from './intent-classifier.js';
 /**
  * Tracks token savings and tool usage across a session.
  * When context-mode is detected, includes unified reporting.
@@ -15,150 +14,62 @@ export class SessionAnalytics {
         this.calls.push(call);
     }
     /**
-     * Generate a session report.
+     * Generate a compact session report (~5 lines).
      */
     report() {
         const duration = formatDuration(Date.now() - this.sessionStart);
         const totalReturned = this.calls.reduce((s, c) => s + c.tokensReturned, 0);
         const totalWouldBe = this.calls.reduce((s, c) => s + c.tokensWouldBe, 0);
         const saved = totalWouldBe > 0 ? Math.round((1 - totalReturned / totalWouldBe) * 100) : 0;
-        // Group by tool
-        const byTool = new Map();
-        for (const c of this.calls) {
-            const existing = byTool.get(c.tool) ?? { count: 0, tokens: 0, saved: 0, wouldBe: 0 };
-            existing.count++;
-            existing.tokens += c.tokensReturned;
-            existing.saved += Math.max(0, c.tokensWouldBe - c.tokensReturned);
-            existing.wouldBe += c.tokensWouldBe;
-            byTool.set(c.tool, existing);
-        }
         const lines = [
             `SESSION ANALYTICS (${duration})`,
-            '',
-            `Total tool calls: ${this.calls.length}`,
-            `Tokens returned: ~${totalReturned}`,
-            `Tokens saved: ~${totalWouldBe - totalReturned} (${saved}% reduction)`,
-            '',
-            'By tool:',
+            `Calls: ${this.calls.length}  ·  Tokens returned: ~${totalReturned}  ·  Saved: ~${totalWouldBe - totalReturned} (${saved}%)`,
         ];
-        const sortedTools = Array.from(byTool.entries()).sort((a, b) => b[1].saved - a[1].saved);
-        for (const [tool, stats] of sortedTools) {
-            const reduction = stats.wouldBe > 0
-                ? Math.round((1 - stats.tokens / stats.wouldBe) * 100)
-                : 0;
-            lines.push(`  ${tool}: ${stats.count} calls, ~${stats.tokens} tokens returned, ~${stats.saved} saved (${reduction}% reduction)`);
+        // By tool — top 5 by savings, all on one line
+        if (this.calls.length > 0) {
+            const byTool = new Map();
+            for (const c of this.calls) {
+                const e = byTool.get(c.tool) ?? { count: 0, tokens: 0, wouldBe: 0 };
+                e.count++;
+                e.tokens += c.tokensReturned;
+                e.wouldBe += c.tokensWouldBe;
+                byTool.set(c.tool, e);
+            }
+            const sorted = Array.from(byTool.entries())
+                .sort((a, b) => (b[1].wouldBe - b[1].tokens) - (a[1].wouldBe - a[1].tokens))
+                .slice(0, 5);
+            const toolParts = sorted.map(([tool, s]) => {
+                const pct = s.wouldBe > 0 ? Math.round((1 - s.tokens / s.wouldBe) * 100) : 0;
+                return `${tool} ${s.count}× (${pct}%)`;
+            });
+            lines.push(`Tools: ${toolParts.join('  ·  ')}`);
         }
-        // Top files by savings
+        // Top files by savings (top 3)
         const byFile = new Map();
         for (const c of this.calls) {
             if (c.path) {
-                const current = byFile.get(c.path) ?? 0;
-                byFile.set(c.path, current + Math.max(0, c.tokensWouldBe - c.tokensReturned));
+                byFile.set(c.path, (byFile.get(c.path) ?? 0) + Math.max(0, c.tokensWouldBe - c.tokensReturned));
             }
         }
         const topFiles = Array.from(byFile.entries())
             .sort((a, b) => b[1] - a[1])
-            .slice(0, 5);
+            .slice(0, 3);
         if (topFiles.length > 0) {
-            lines.push('');
-            lines.push('Top files by savings:');
-            for (const [file, saved] of topFiles) {
-                lines.push(`  ${file}: ~${saved} tokens saved`);
-            }
-        }
-        const lowValueTools = sortedTools
-            .map(([tool, stats]) => ({
-            tool,
-            reduction: stats.wouldBe > 0 ? Math.round((1 - stats.tokens / stats.wouldBe) * 100) : 0,
-            count: stats.count,
-        }))
-            .filter((tool) => tool.reduction < 20);
-        if (lowValueTools.length > 0) {
-            lines.push('');
-            lines.push('Needs improvement:');
-            for (const tool of lowValueTools.slice(0, 5)) {
-                lines.push(`  ${tool.tool}: only ${tool.reduction}% reduction across ${tool.count} call${tool.count === 1 ? '' : 's'}`);
-            }
-        }
-        // Savings breakdown by category
-        const byCategory = { compression: 0, cache: 0, dedup: 0, none: 0 };
-        for (const c of this.calls) {
-            const cat = c.savingsCategory ?? 'none';
-            byCategory[cat] += Math.max(0, c.tokensWouldBe - c.tokensReturned);
-        }
-        if (totalWouldBe > totalReturned) {
-            lines.push('');
-            lines.push('Savings breakdown:');
-            if (byCategory.compression > 0)
-                lines.push(`  Compression (AST/structured): ~${byCategory.compression} tokens`);
-            if (byCategory.cache > 0)
-                lines.push(`  Cache hits (session cache): ~${byCategory.cache} tokens`);
-            if (byCategory.dedup > 0)
-                lines.push(`  Dedup (already in context): ~${byCategory.dedup} tokens`);
+            const fileParts = topFiles.map(([f, s]) => `${f} ~${s}`);
+            lines.push(`Top files: ${fileParts.join('  ·  ')}`);
         }
-        // Session cache hits
+        // Cache hits + context-mode on one line
+        const extras = [];
         const cacheHits = this.calls.filter(c => c.sessionCacheHit);
         if (cacheHits.length > 0) {
-            const cacheTokensSaved = cacheHits.reduce((s, c) => s + Math.max(0, c.tokensWouldBe - c.tokensReturned), 0);
-            lines.push('');
-            lines.push(`Session cache: ${cacheHits.length} hits / ${this.calls.length} calls (${Math.round(cacheHits.length / this.calls.length * 100)}% hit rate, ~${cacheTokensSaved} tokens saved)`);
+            const hitRate = Math.round(cacheHits.length / this.calls.length * 100);
+            extras.push(`Cache: ${cacheHits.length}/${this.calls.length} hits (${hitRate}%)`);
         }
-        // Dedup reminders served
-        const dedupCalls = this.calls.filter(c => c.savingsCategory === 'dedup');
-        if (dedupCalls.length > 0) {
-            lines.push('');
-            lines.push(`Compact reminders/dedup: ${dedupCalls.length} calls (avoided full re-reads)`);
-        }
-        // Delegation stats
-        const delegated = this.calls.filter(c => c.delegatedToContextMode);
-        if (delegated.length > 0) {
-            lines.push('');
-            lines.push(`Delegated to context-mode: ${delegated.length} calls`);
-        }
-        // Per-intent breakdown (Track 2)
-        const callsWithIntent = this.calls.filter(c => c.intent);
-        if (callsWithIntent.length > 0) {
-            const byIntent = new Map();
-            for (const c of callsWithIntent) {
-                const intent = c.intent;
-                const existing = byIntent.get(intent) ?? { count: 0, saved: 0 };
-                existing.count++;
-                existing.saved += Math.max(0, c.tokensWouldBe - c.tokensReturned);
-                byIntent.set(intent, existing);
-            }
-            lines.push('');
-            lines.push('Per-intent breakdown:');
-            for (const intent of ALL_INTENTS) {
-                const stats = byIntent.get(intent);
-                if (stats) {
-                    lines.push(`  ${intent}: ${stats.count} call${stats.count === 1 ? '' : 's'}, ~${stats.saved} tokens saved`);
-                }
-            }
-        }
-        // Decision insights (Track 0)
-        const tracedCalls = this.calls.filter(c => c.decisionTrace);
-        if (tracedCalls.length > 0) {
-            const alreadyInContextCount = tracedCalls.filter(c => c.decisionTrace.alreadyInContext).length;
-            const totalEstimated = tracedCalls.reduce((s, c) => s + c.decisionTrace.estimatedCost, 0);
-            const totalActual = tracedCalls.reduce((s, c) => s + c.decisionTrace.actualCost, 0);
-            const avgReduction = totalEstimated > 0 ? Math.round((1 - totalActual / totalEstimated) * 100) : 0;
-            const missedSavings = tracedCalls.filter(c => c.decisionTrace.cheaperAlternative).length;
-            lines.push('');
-            lines.push('Decision insights:');
-            lines.push(`  Files already in context: ${alreadyInContextCount} of ${tracedCalls.length} calls (${Math.round(alreadyInContextCount / tracedCalls.length * 100)}%)`);
-            lines.push(`  Avg cost reduction: ${avgReduction}% (estimated → actual)`);
-            if (missedSavings > 0) {
-                lines.push(`  Missed savings opportunities: ${missedSavings} call${missedSavings === 1 ? '' : 's'} could have used cheaper tools`);
-            }
-        }
-        // Context-mode companion status
         if (this.contextModeStatus.detected) {
-            lines.push('');
-            lines.push('--- Combined Architecture ---');
-            lines.push(`context-mode: active (detected via ${this.contextModeStatus.source})`);
-            lines.push('Token Pilot handles: code files (AST-level structural reading)');
-            lines.push('context-mode handles: shell output, logs, large data files (BM25-indexed)');
-            lines.push('TIP: Use /context-mode:stats for context-mode savings breakdown.');
+            extras.push(`context-mode: active (${this.contextModeStatus.source})`);
+        }
+        if (extras.length > 0) {
+            lines.push(extras.join('  ·  '));
         }
         return lines.join('\n');
     }

package/dist/core/symbol-resolver.d.ts

@@ -15,7 +15,6 @@ export declare class SymbolResolver {
         contextBefore?: number;
         contextAfter?: number;
     }): string;
-    private mapKind;
     /**
      * Hierarchical search: AuthService → children → login
      */

package/dist/core/symbol-resolver.js

@@ -1,3 +1,4 @@
+import { mapKind } from '../ast-index/parser.js';
 export class SymbolResolver {
     astIndex;
     constructor(astIndex) {
@@ -63,7 +64,7 @@ export class SymbolResolver {
                 symbol: {
                     name: detail.name,
                     qualifiedName: qualifiedName,
-                    kind: this.mapKind(detail.kind),
+                    kind: mapKind(detail.kind),
                     signature: detail.signature ?? detail.name,
                     location: {
                         startLine: detail.start_line,
@@ -96,7 +97,7 @@ export class SymbolResolver {
                     symbol: {
                         name: leafDetail.name,
                         qualifiedName: qualifiedName,
-                        kind: this.mapKind(leafDetail.kind),
+                        kind: mapKind(leafDetail.kind),
                         signature: leafDetail.signature ?? leafDetail.name,
                         location: {
                             startLine: leafDetail.start_line,
@@ -133,16 +134,6 @@ export class SymbolResolver {
         }
         return output.join('\n');
     }
-    mapKind(kind) {
-        const map = {
-            function: 'function', class: 'class', method: 'method',
-            property: 'property', variable: 'variable', type: 'type',
-            interface: 'interface', enum: 'enum', constant: 'constant',
-            namespace: 'namespace', struct: 'class', trait: 'interface',
-            impl: 'class', module: 'namespace',
-        };
-        return map[kind.toLowerCase()] ?? 'function';
-    }
     /**
      * Hierarchical search: AuthService → children → login
      */

package/dist/handlers/code-audit.js

@@ -87,7 +87,7 @@ async function handleTodo(limit, projectRoot, astIndex) {
         return {
             content: [{
                     type: 'text',
-                    text: 'TODO/FIXME COMMENTS: none found.\n\nHINT: ast-index may not detect all comment formats. Try Grep: grep -rn "TODO\\|FIXME\\|HACK" --include="*.ts"',
+                    text: 'TODO/FIXME COMMENTS: none found.\n\nHINT: ast-index may not detect all comment formats. Try Grep with pattern "TODO|FIXME|HACK".',
                 }],
             meta: { files: [] },
         };
@@ -146,7 +146,7 @@ async function handleAnnotations(name, limit, projectRoot, astIndex) {
         return {
             content: [{
                     type: 'text',
-                    text: `ANNOTATIONS @${name}: none found.\n\nHINT: Try Grep for text-based search: grep -rn "@${name}" --include="*.ts"`,
+                    text: `ANNOTATIONS @${name}: none found.\n\nHINT: Try Grep with pattern "@${name}" for text-based search.`,
                 }],
             meta: { files: [] },
         };

package/dist/handlers/find-unused.js

@@ -18,7 +18,7 @@ export async function handleFindUnused(args, astIndex) {
         return { content: [{ type: 'text', text: 'find_unused is disabled: ' + (astIndex.isDisabled()
                         ? 'project root not detected. Call smart_read() on any project file first — this auto-detects the project root and enables ast-index tools.'
                         : 'ast-index built >50k files (likely includes node_modules). Ensure node_modules is in .gitignore.') +
-                        '\nAlternative: use grep_search to find unused exports manually.' }], meta: { files: [] } };
+                        '\nAlternative: use Grep to find unused exports manually.' }], meta: { files: [] } };
     }
     const requestLimit = (args.limit ?? 30) + 20; // extra to compensate for filtering
     const unused = await astIndex.unusedSymbols({

package/dist/handlers/find-usages.js

@@ -22,6 +22,35 @@ const LANG_EXT_MAP = {
     vue: ['.vue'],
     svelte: ['.svelte'],
 };
+/**
+ * Render a section (DEFINITIONS/IMPORTS/USAGES) grouped by file.
+ * Single match per file → one line. Multiple → file header + indented lines.
+ */
+function renderSection(title, items) {
+    if (items.length === 0)
+        return [];
+    const lines = [`${title}:`];
+    const byFile = new Map();
+    for (const item of items) {
+        const arr = byFile.get(item.file) ?? [];
+        arr.push({ line: item.line, text: item.text });
+        byFile.set(item.file, arr);
+    }
+    for (const [file, matches] of byFile) {
+        matches.sort((a, b) => a.line - b.line);
+        if (matches.length === 1) {
+            lines.push(`  ${file}:${matches[0].line}  ${matches[0].text}`);
+        }
+        else {
+            lines.push(`  ${file}:`);
+            for (const m of matches) {
+                lines.push(`    :${m.line}  ${m.text}`);
+            }
+        }
+    }
+    lines.push('');
+    return lines;
+}
 /**
  * Find all usages of a symbol across the project.
  *
@@ -40,7 +69,7 @@ export async function handleFindUsages(args, astIndex) {
                     text: 'find_usages is disabled: ' + (astIndex.isDisabled()
                         ? 'project root not detected. Call smart_read() on any project file first — this auto-detects the project root and enables ast-index tools.'
                         : 'ast-index built >50k files (likely includes node_modules). Ensure node_modules is in .gitignore.')
-                        + '\nAlternative: use grep_search to find symbol references.',
+                        + '\nAlternative: use Grep to find symbol references.',
                 }],
             meta: { files: [], definitions: 0, imports: 0, usages: 0, total: 0 },
         };
@@ -151,33 +180,12 @@ export async function handleFindUsages(args, astIndex) {
         filterHints.push(`kind=${args.kind}`);
     const filterStr = filterHints.length > 0 ? ` [${filterHints.join(', ')}]` : '';
     const lines = [
-        `REFS: "${args.symbol}" (${totalCount} total: ${definitions.length} definitions, ${allImports.length} imports, ${allUsages.length} usages)${filterStr}`,
+        `REFS: "${args.symbol}" (${totalCount} total: ${definitions.length} def · ${allImports.length} imports · ${allUsages.length} usages)${filterStr}`,
         '',
     ];
-    if (definitions.length > 0) {
-        lines.push('DEFINITIONS:');
-        for (const d of definitions) {
-            lines.push(`  ${d.file}:${d.line}`);
-            lines.push(`    ${d.text}`);
-        }
-        lines.push('');
-    }
-    if (allImports.length > 0) {
-        lines.push('IMPORTS:');
-        for (const i of allImports) {
-            lines.push(`  ${i.file}:${i.line}`);
-            lines.push(`    ${i.text}`);
-        }
-        lines.push('');
-    }
-    if (allUsages.length > 0) {
-        lines.push('USAGES:');
-        for (const u of allUsages) {
-            lines.push(`  ${u.file}:${u.line}`);
-            lines.push(`    ${u.text}`);
-        }
-        lines.push('');
-    }
+    lines.push(...renderSection('DEFINITIONS', definitions));
+    lines.push(...renderSection('IMPORTS', allImports));
+    lines.push(...renderSection('USAGES', allUsages));
     lines.push('HINT: Use read_symbol() or read_range() to load specific results.');
     // Confidence metadata
     const confidenceMeta = assessConfidence({

package/dist/handlers/smart-read.js

@@ -4,6 +4,9 @@ import { formatOutline } from '../formatters/structure.js';
 import { estimateTokens, formatSavings } from '../core/token-estimator.js';
 import { resolveSafePath } from '../core/validation.js';
 import { isNonCodeStructured, handleNonCodeRead } from './non-code.js';
+import { parseTypeScriptRegex } from '../ast-index/regex-parser.js';
+import { buildFileStructure } from '../ast-index/enricher.js';
+const TS_JS_EXTENSIONS = new Set(['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs']);
 import { assessConfidence, formatConfidence } from '../core/confidence.js';
 export async function handleSmartRead(args, projectRoot, astIndex, fileCache, contextRegistry, config) {
     const absPath = resolveSafePath(projectRoot, args.path);
@@ -55,7 +58,7 @@ export async function handleSmartRead(args, projectRoot, astIndex, fileCache, co
     const isStale = cached ? await fileCache.isStale(absPath) : true;
     if (!cached || isStale) {
         // 4. Get structure from ast-index
-        const structure = await astIndex.outline(absPath);
+        let structure = await astIndex.outline(absPath);
         if (!structure) {
             // ast-index doesn't support this file type
             // Try non-code structural summary (JSON, YAML, Markdown, TOML)
@@ -64,6 +67,16 @@ export async function handleSmartRead(args, projectRoot, astIndex, fileCache, co
                 if (nonCodeResult)
                     return nonCodeResult;
             }
+            // Regex fallback for TS/JS when binary is unavailable
+            const ext = absPath.split('.').pop()?.toLowerCase() ?? '';
+            if (TS_JS_EXTENSIONS.has(ext)) {
+                const regexEntries = parseTypeScriptRegex(content);
+                if (regexEntries.length > 0) {
+                    structure = await buildFileStructure(absPath, regexEntries);
+                }
+            }
+        }
+        if (!structure) {
             // Fallback: return truncated preview instead of full raw content
             const previewLines = 60;
             const truncated = lines.length > previewLines;

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export declare const CODE_EXTENSIONS: Set<string>;
 export declare function getVersion(): string;
 export declare function main(cliArgs?: string[]): Promise<void>;
 export declare function startServer(cliArgs?: string[]): Promise<void>;
-export declare function handleHookRead(filePathArg?: string): void;
+export declare function handleHookRead(filePathArg?: string, denyThreshold?: number): void;
 export declare function handleHookEdit(): void;
 export declare function handleInstallHook(projectRoot: string): Promise<void>;
 export declare function handleUninstallHook(projectRoot: string): Promise<void>;

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { readFileSync } from 'node:fs';
+import { readFileSync, realpathSync } from 'node:fs';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
@@ -10,7 +10,6 @@ import { findBinary, installBinary, checkBinaryUpdate, isNewerVersion } from './
 import { loadConfig } from './config/loader.js';
 import { isDangerousRoot } from './core/validation.js';
 const execFileAsync = promisify(execFile);
-const HOOK_DENY_THRESHOLD = 500;
 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',
@@ -30,9 +29,11 @@ export function getVersion() {
 }
 export async function main(cliArgs = process.argv.slice(2)) {
     switch (cliArgs[0]) {
-        case 'hook-read':
-            handleHookRead(cliArgs[1]);
+        case 'hook-read': {
+            const cfg = await loadConfig(process.cwd());
+            handleHookRead(cliArgs[1], cfg.hooks.denyThreshold);
             return;
+        }
         case 'hook-edit':
             handleHookEdit();
             return;
@@ -139,7 +140,7 @@ export async function startServer(cliArgs = process.argv.slice(2)) {
         process.exit(0);
     });
 }
-export function handleHookRead(filePathArg) {
+export function handleHookRead(filePathArg, denyThreshold = 300) {
     // Parse stdin (Claude Code hook format) to get tool_input
     let filePath = filePathArg;
     let hasOffset = false;
@@ -173,7 +174,7 @@ export function handleHookRead(filePathArg) {
     try {
         const content = readFileSync(filePath, 'utf-8');
         lineCount = content.split('\n').length;
-        if (lineCount <= HOOK_DENY_THRESHOLD) {
+        if (lineCount <= denyThreshold) {
             process.exit(0);
         }
     }
@@ -449,7 +450,7 @@ MCP Tools (18):
 `);
     process.exit(0);
 }
-const isDirectRun = process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1];
+const isDirectRun = process.argv[1] !== undefined && realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1]);
 if (isDirectRun) {
     main().catch(err => {
         console.error(`[token-pilot] Fatal: ${err instanceof Error ? err.message : err}`);

package/dist/server/token-estimates.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Token estimation functions for analytics.
+ * Used to calculate "tokens would be" for honest savings reporting.
+ */
+import type { FileCache } from '../core/file-cache.js';
+import type { SavingsCategory } from '../core/session-analytics.js';
+/**
+ * Creates token estimation functions bound to a project context.
+ * Uses getter for projectRoot since it may change on auto-detect.
+ */
+export declare function createTokenEstimates(getProjectRoot: () => string, fileCache: FileCache): {
+    fullFileTokens: (relativePath: string) => Promise<number>;
+    estimateProjectOverviewWorkflowTokens: (includeSections: Array<"stack" | "ci" | "quality" | "architecture">) => Promise<number>;
+    estimateOutlineWorkflowTokens: (relativePath: string, recursive: boolean, maxDepth: number) => Promise<number>;
+    estimateRelatedFilesWorkflowTokens: (targetPath: string, meta?: {
+        imports?: string[];
+        importedBy?: string[];
+        tests?: string[];
+    }) => Promise<number>;
+    estimateFindUsagesWorkflowTokens: (files: string[]) => Promise<number>;
+    estimateExploreAreaWorkflowTokens: (meta: {
+        codeFiles?: string[];
+        testFiles?: string[];
+        internalDeps?: string[];
+        importedBy?: string[];
+        externalDeps?: string[];
+        changeCount?: number;
+    }) => Promise<number>;
+    detectSavingsCategory: (text: string) => SavingsCategory;
+};
+//# sourceMappingURL=token-estimates.d.ts.map