@grapine.ai/contextprune 0.1.0 → 0.1.2

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+"use strict";
+// cli/index.ts
+// ContextPrune CLI entry point.
+// Usage: npx contextprune <command> [options]
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const analyze_1 = require("./commands/analyze");
+const compress_1 = require("./commands/compress");
+const watch_1 = require("./commands/watch");
+const program = new commander_1.Command();
+program
+    .name('contextprune')
+    .description('Intelligent context window management for LLM applications')
+    .version('0.1.0');
+program.addCommand((0, analyze_1.analyzeCommand)());
+program.addCommand((0, compress_1.compressCommand)());
+program.addCommand((0, watch_1.watchCommand)());
+program.parse(process.argv);

package/dist/cli/labels.d.ts

@@ -0,0 +1,4 @@
+export declare const CLS_LABELS: Record<string, string>;
+export declare const STRAT_LABELS: Record<string, string>;
+export declare function clsLabel(cls: string): string;
+export declare function stratLabel(strat: string): string;

package/dist/cli/labels.js

@@ -0,0 +1,35 @@
+"use strict";
+// cli/labels.ts
+// Single source of truth for human-readable classification and strategy names.
+// Used by the CLI (analyze command) and injected into the dashboard HTML by the watch server.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRAT_LABELS = exports.CLS_LABELS = void 0;
+exports.clsLabel = clsLabel;
+exports.stratLabel = stratLabel;
+exports.CLS_LABELS = {
+    SYSTEM_CONSTRAINT: 'System Prompt',
+    TASK_DEFINITION: 'Session Goal',
+    TOOL_OUTPUT_ACTIVE: 'Tool Result',
+    TOOL_OUTPUT_STALE: 'Outdated Tool Result',
+    ERROR_ACTIVE: 'Active Error',
+    ERROR_RESOLVED: 'Fixed Error',
+    REASONING_INTERMEDIATE: 'Chain of Thought',
+    DECISION_FINAL: 'Final Answer',
+    USER_CORRECTION: 'Your Override',
+    PROGRESS_MARKER: 'Status Update',
+    CONVERSATIONAL: 'Chat / Filler',
+};
+exports.STRAT_LABELS = {
+    PRESERVE: 'Keep',
+    DROP: 'Remove',
+    EXTRACT_RESULT: 'Trim to Key Output',
+    COLLAPSE_TO_MARKER: 'Collapse to 1 Line',
+    SUMMARIZE: 'Summarize',
+    DEDUPLICATE: 'Remove Duplicate',
+};
+function clsLabel(cls) {
+    return exports.CLS_LABELS[cls] ?? cls;
+}
+function stratLabel(strat) {
+    return exports.STRAT_LABELS[strat] ?? strat;
+}

package/dist/cli/parse-input.d.ts

@@ -0,0 +1,33 @@
+import type { LLMMessage } from '../src/types';
+export interface TurnCost {
+    messageIndex: number;
+    timestamp: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheWriteTokens: number;
+    cacheReadTokens: number;
+    cost: number;
+}
+export interface SessionCost {
+    date: string;
+    label: string;
+    totalCost: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    turns: number;
+}
+export interface CostData {
+    totalCost: number;
+    currency: 'USD';
+    perTurn: TurnCost[];
+    sessions: SessionCost[];
+}
+export interface LoadResult {
+    messages: LLMMessage[];
+    actualInputTokens?: number;
+    costData?: CostData;
+}
+export declare function loadMessages(file: string): LLMMessage[];
+export declare function loadMessagesWithUsage(file: string): LoadResult;
+export declare function loadProjectCostHistory(projectDir: string, currentFile: string): CostData;

package/dist/cli/parse-input.js

@@ -0,0 +1,191 @@
+"use strict";
+// cli/parse-input.ts
+// Shared file-loading logic for CLI commands.
+// Supports .json (array) and .jsonl (Claude Code session transcripts or plain message-per-line).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMessages = loadMessages;
+exports.loadMessagesWithUsage = loadMessagesWithUsage;
+exports.loadProjectCostHistory = loadProjectCostHistory;
+const fs_1 = require("fs");
+const path_1 = require("path");
+// ─── Cost pricing table (USD per million tokens) ──────────────────────────────
+// Prices: https://www.anthropic.com/pricing
+const PRICING = {
+    'claude-opus-4-6': { input: 15.00, output: 75.00, cacheWrite: 18.75, cacheRead: 1.50 },
+    'claude-opus-4-5': { input: 15.00, output: 75.00, cacheWrite: 18.75, cacheRead: 1.50 },
+    'claude-sonnet-4-6': { input: 3.00, output: 15.00, cacheWrite: 3.75, cacheRead: 0.30 },
+    'claude-sonnet-4-5': { input: 3.00, output: 15.00, cacheWrite: 3.75, cacheRead: 0.30 },
+    'claude-haiku-4-5': { input: 0.80, output: 4.00, cacheWrite: 1.00, cacheRead: 0.08 },
+};
+const DEFAULT_PRICE = { input: 3.00, output: 15.00, cacheWrite: 3.75, cacheRead: 0.30 };
+function getPricing(model) {
+    if (!model)
+        return DEFAULT_PRICE;
+    // Exact match first, then prefix match
+    if (PRICING[model])
+        return PRICING[model];
+    for (const key of Object.keys(PRICING)) {
+        if (model.startsWith(key))
+            return PRICING[key];
+    }
+    return DEFAULT_PRICE;
+}
+function calcCost(p, inputTok, outputTok, cacheWriteTok, cacheReadTok) {
+    return ((inputTok * p.input / 1000000) +
+        (outputTok * p.output / 1000000) +
+        (cacheWriteTok * p.cacheWrite / 1000000) +
+        (cacheReadTok * p.cacheRead / 1000000));
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+function loadMessages(file) {
+    return loadMessagesWithUsage(file).messages;
+}
+function loadMessagesWithUsage(file) {
+    const raw = (0, fs_1.readFileSync)(file, 'utf-8');
+    if (file.endsWith('.jsonl')) {
+        return parseJsonl(raw);
+    }
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+        throw new Error('File must contain a JSON array of messages.');
+    }
+    return { messages: parsed };
+}
+// ─── JSONL parser ─────────────────────────────────────────────────────────────
+// Supports two JSONL shapes:
+// 1. Claude Code session transcript: { type: 'user'|'assistant', message: { role, content } }
+// 2. Plain message-per-line:         { role, content }
+function parseJsonl(raw) {
+    let messages = [];
+    let actualInputTokens;
+    const perTurn = [];
+    let postCompactTurnOffset = 0; // perTurn index where last compact happened
+    for (const line of raw.trim().split('\n')) {
+        if (!line.trim())
+            continue;
+        const record = JSON.parse(line);
+        // /compact boundary — reset live context (only post-compact messages are active)
+        if (record.type === 'system' && record.subtype === 'compact_boundary') {
+            messages = [];
+            actualInputTokens = undefined;
+            postCompactTurnOffset = perTurn.length; // cost history kept, but mark the split
+            continue;
+        }
+        // Claude Code session transcript
+        if ((record.type === 'user' || record.type === 'assistant') && record.message?.role) {
+            const msg = record.message;
+            // Extract actual token usage from each assistant record
+            if (record.type === 'assistant' && msg.usage) {
+                const u = msg.usage;
+                const inputTok = u.input_tokens ?? 0;
+                const outputTok = u.output_tokens ?? 0;
+                const cacheWriteTok = u.cache_creation_input_tokens ?? 0;
+                const cacheReadTok = u.cache_read_input_tokens ?? 0;
+                const total = inputTok + cacheWriteTok + cacheReadTok;
+                if (total > 0) {
+                    actualInputTokens = total; // keep last for session extractor
+                    const model = msg.model ?? record.model ?? '';
+                    const p = getPricing(model);
+                    perTurn.push({
+                        messageIndex: messages.length, // index of the message about to be pushed
+                        timestamp: record.timestamp ?? new Date().toISOString(),
+                        model,
+                        inputTokens: inputTok,
+                        outputTokens: outputTok,
+                        cacheWriteTokens: cacheWriteTok,
+                        cacheReadTokens: cacheReadTok,
+                        cost: calcCost(p, inputTok, outputTok, cacheWriteTok, cacheReadTok),
+                    });
+                }
+            }
+            // Keep the full content array — do NOT filter to text-only
+            const { role, content } = msg;
+            if (Array.isArray(content)) {
+                if (content.length > 0)
+                    messages.push({ role, content });
+            }
+            else if (typeof content === 'string' && content.trim()) {
+                messages.push({ role, content });
+            }
+            continue;
+        }
+        // Plain { role, content }
+        if (record.role && record.content !== undefined) {
+            messages.push({ role: record.role, content: record.content });
+        }
+    }
+    if (messages.length === 0) {
+        throw new Error('No valid messages found in JSONL file.');
+    }
+    const costData = buildCostData(perTurn);
+    return { messages, actualInputTokens, costData };
+}
+// ─── Session grouping ─────────────────────────────────────────────────────────
+// Group consecutive turns into sessions by calendar date.
+// A gap of >2 hours between turns also starts a new session.
+function buildCostData(perTurn) {
+    const totalCost = perTurn.reduce((s, t) => s + t.cost, 0);
+    // Group by date
+    const byDate = {};
+    for (const turn of perTurn) {
+        const date = turn.timestamp.slice(0, 10); // YYYY-MM-DD
+        if (!byDate[date])
+            byDate[date] = [];
+        byDate[date].push(turn);
+    }
+    const sessions = Object.entries(byDate)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([date, turns]) => ({
+        date,
+        label: formatDate(date),
+        totalCost: turns.reduce((s, t) => s + t.cost, 0),
+        totalInputTokens: turns.reduce((s, t) => s + t.inputTokens + t.cacheWriteTokens + t.cacheReadTokens, 0),
+        totalOutputTokens: turns.reduce((s, t) => s + t.outputTokens, 0),
+        turns: turns.length,
+    }));
+    return { totalCost, currency: 'USD', perTurn, sessions };
+}
+function formatDate(iso) {
+    // iso = "YYYY-MM-DD"
+    const [y, m, d] = iso.split('-').map(Number);
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    return `${months[m - 1]} ${d}, ${y}`;
+}
+// ─── Cross-session cost aggregation ───────────────────────────────────────────
+// Reads ALL .jsonl files in the project directory and merges their cost history.
+// The current (active) file's perTurn entries keep their messageIndex intact so
+// per-message cost cells still work in the dashboard. All other files' entries
+// use messageIndex = -1 (they count toward totalCost and sessions but won't
+// match any message row in the top-consumers table).
+function loadProjectCostHistory(projectDir, currentFile) {
+    if (!(0, fs_1.existsSync)(projectDir))
+        return buildCostData([]);
+    let files;
+    try {
+        files = (0, fs_1.readdirSync)(projectDir)
+            .filter(f => f.endsWith('.jsonl'))
+            .map(f => (0, path_1.join)(projectDir, f));
+    }
+    catch {
+        return buildCostData([]);
+    }
+    const merged = [];
+    for (const file of files) {
+        try {
+            const result = loadMessagesWithUsage(file);
+            const turns = result.costData?.perTurn ?? [];
+            if (file === currentFile) {
+                // Keep messageIndex as-is — matches the live messages array
+                merged.push(...turns);
+            }
+            else {
+                // Historical session — contribute to cost totals but no message linkage
+                merged.push(...turns.map(t => ({ ...t, messageIndex: -1 })));
+            }
+        }
+        catch { /* skip unreadable files */ }
+    }
+    // Sort all turns chronologically before building sessions
+    merged.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    return buildCostData(merged);
+}

package/dist/src/brief/index.d.ts

@@ -0,0 +1,2 @@
+import type { AnnotatedMessage } from '../types';
+export declare function generateSessionBrief(messages: AnnotatedMessage[]): string;

package/dist/src/brief/index.js

@@ -0,0 +1,101 @@
+"use strict";
+// src/brief/index.ts
+// Generates a structured session brief from classified messages.
+// No LLM calls — pure extraction. Used when context is getting full
+// so the user can paste it into a new session and continue from where they left off.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSessionBrief = generateSessionBrief;
+const utils_1 = require("../utils");
+const BRIEF_CHAR_LIMIT = 300; // per message excerpt
+const MAX_DECISIONS = 5;
+const MAX_PROGRESS = 5;
+const MAX_STATE = 3;
+function generateSessionBrief(messages) {
+    const goal = extractGoal(messages);
+    const constraints = extractConstraints(messages);
+    const decisions = extractDecisions(messages);
+    const progress = extractProgress(messages);
+    const state = extractCurrentState(messages);
+    const openIssues = extractOpenIssues(messages);
+    const sections = [];
+    sections.push('# Session Brief\n');
+    sections.push('> Paste this at the start of a new session to continue from where you left off.\n');
+    if (goal) {
+        sections.push(`## Goal\n${goal}`);
+    }
+    if (constraints.length) {
+        sections.push(`## Constraints & Rules\n${constraints.map(c => `- ${c}`).join('\n')}`);
+    }
+    if (decisions.length) {
+        sections.push(`## Key Decisions Made\n${decisions.map(d => `- ${d}`).join('\n')}`);
+    }
+    if (progress.length) {
+        sections.push(`## What's Done\n${progress.map(p => `- ${p}`).join('\n')}`);
+    }
+    if (state.length) {
+        sections.push(`## Current State\n${state.join('\n\n')}`);
+    }
+    if (openIssues.length) {
+        sections.push(`## Open Issues\n${openIssues.map(i => `- ${i}`).join('\n')}`);
+    }
+    sections.push('## Continue\nPick up where we left off based on the above context.');
+    return sections.join('\n\n');
+}
+// ─── Extractors ───────────────────────────────────────────────────────────────
+function extractGoal(messages) {
+    // Prefer highest-scored TASK_DEFINITION; fall back to first user message
+    const taskMsgs = messages
+        .filter(m => m.classification === 'TASK_DEFINITION')
+        .sort((a, b) => b.relevanceScore - a.relevanceScore);
+    const source = taskMsgs[0]
+        ?? messages.find(m => m.original.role === 'user');
+    return source ? truncate((0, utils_1.extractText)(source.original), 400) : '';
+}
+function extractConstraints(messages) {
+    const out = [];
+    for (const m of messages) {
+        if (m.classification === 'SYSTEM_CONSTRAINT' || m.classification === 'USER_CORRECTION') {
+            const text = truncate((0, utils_1.extractText)(m.original), BRIEF_CHAR_LIMIT);
+            if (text)
+                out.push(text);
+        }
+    }
+    return out;
+}
+function extractDecisions(messages) {
+    return messages
+        .filter(m => m.classification === 'DECISION_FINAL')
+        .sort((a, b) => b.relevanceScore - a.relevanceScore)
+        .slice(0, MAX_DECISIONS)
+        .map(m => truncate((0, utils_1.extractText)(m.original), BRIEF_CHAR_LIMIT))
+        .filter(Boolean);
+}
+function extractProgress(messages) {
+    return messages
+        .filter(m => m.classification === 'PROGRESS_MARKER')
+        .slice(-MAX_PROGRESS) // most recent progress markers
+        .map(m => truncate((0, utils_1.extractText)(m.original), BRIEF_CHAR_LIMIT))
+        .filter(Boolean);
+}
+function extractCurrentState(messages) {
+    // Most recent active tool outputs — these represent the actual current state
+    return messages
+        .filter(m => m.classification === 'TOOL_OUTPUT_ACTIVE')
+        .slice(-MAX_STATE)
+        .map(m => {
+        const text = truncate((0, utils_1.extractText)(m.original), BRIEF_CHAR_LIMIT);
+        return text ? `**Call ${m.originalIndex}:** ${text}` : '';
+    })
+        .filter(Boolean);
+}
+function extractOpenIssues(messages) {
+    return messages
+        .filter(m => m.classification === 'ERROR_ACTIVE')
+        .map(m => truncate((0, utils_1.extractText)(m.original), BRIEF_CHAR_LIMIT))
+        .filter(Boolean);
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function truncate(text, limit) {
+    const cleaned = text.replace(/\s+/g, ' ').trim();
+    return cleaned.length > limit ? cleaned.slice(0, limit) + '…' : cleaned;
+}

package/dist/src/classifier/confidence.d.ts

@@ -0,0 +1,4 @@
+import type { ConfidenceTier, CompressionStrategy } from '../types';
+export declare function getConfidenceTier(confidence: number): ConfidenceTier;
+export declare const CONFIDENCE_COMPRESSION_MAP: Record<ConfidenceTier, CompressionStrategy[]>;
+export declare function isStrategyAllowed(strategy: CompressionStrategy, confidenceTier: ConfidenceTier): boolean;

package/dist/src/classifier/confidence.js

@@ -0,0 +1,23 @@
+"use strict";
+// src/classifier/confidence.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIDENCE_COMPRESSION_MAP = void 0;
+exports.getConfidenceTier = getConfidenceTier;
+exports.isStrategyAllowed = isStrategyAllowed;
+function getConfidenceTier(confidence) {
+    if (confidence >= 0.85)
+        return 'HIGH';
+    if (confidence >= 0.70)
+        return 'MEDIUM';
+    return 'LOW';
+}
+// Maps confidence tier to maximum allowed compression strategies.
+// LOW confidence = preserve always, regardless of relevance score.
+exports.CONFIDENCE_COMPRESSION_MAP = {
+    HIGH: ['DROP', 'EXTRACT_RESULT', 'SUMMARIZE', 'DEDUPLICATE', 'COLLAPSE_TO_MARKER', 'PRESERVE'],
+    MEDIUM: ['EXTRACT_RESULT', 'SUMMARIZE', 'DEDUPLICATE', 'PRESERVE'],
+    LOW: ['PRESERVE'],
+};
+function isStrategyAllowed(strategy, confidenceTier) {
+    return exports.CONFIDENCE_COMPRESSION_MAP[confidenceTier].includes(strategy);
+}

package/dist/src/classifier/index.d.ts

@@ -0,0 +1,11 @@
+import type { LLMMessage, AnnotatedMessage, MessageClassification } from '../types';
+interface ClassificationResult {
+    classification: MessageClassification;
+    confidence: number;
+    method: 'rule' | 'heuristic';
+    metadata: Record<string, unknown>;
+}
+export declare function isPinned(classification: MessageClassification): boolean;
+export declare function classifyMessage(message: LLMMessage, index: number, allMessages: LLMMessage[], model: string): Promise<ClassificationResult>;
+export declare function classifyAll(messages: LLMMessage[], model: string): Promise<AnnotatedMessage[]>;
+export {};

package/dist/src/classifier/index.js

@@ -0,0 +1,217 @@
+"use strict";
+// src/classifier/index.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPinned = isPinned;
+exports.classifyMessage = classifyMessage;
+exports.classifyAll = classifyAll;
+const tokenizer_1 = require("../tokenizer");
+const utils_1 = require("../utils");
+const patterns_1 = require("./patterns");
+// ─── Pinned Types ─────────────────────────────────────────────────────────────
+function isPinned(classification) {
+    return (classification === 'SYSTEM_CONSTRAINT' ||
+        classification === 'USER_CORRECTION' ||
+        classification === 'TASK_DEFINITION' ||
+        classification === 'ERROR_ACTIVE');
+}
+// ─── Tool Output Sub-Classifier ───────────────────────────────────────────────
+function detectToolType(content) {
+    const text = JSON.stringify(content).toLowerCase();
+    if (text.includes('read_file') || text.includes('cat ') || text.includes('file_content'))
+        return 'file_read';
+    if (text.includes('write_file') || text.includes('create_file') || text.includes('edit_file') || text.includes('str_replace'))
+        return 'write';
+    if (text.includes('run_command') || text.includes('bash') || text.includes('execute') || text.includes('shell'))
+        return 'command_exec';
+    if (text.includes('search') || text.includes('grep') || text.includes('find'))
+        return 'search';
+    return 'unknown';
+}
+function isToolOutputReferenced(message, laterMessages) {
+    const content = Array.isArray(message.content) ? message.content : [];
+    const toolUseId = content.find((b) => b.id || b.tool_use_id);
+    if (toolUseId) {
+        const id = toolUseId.id ?? toolUseId.tool_use_id;
+        if (id) {
+            return laterMessages.some((m) => JSON.stringify(m.content).includes(id));
+        }
+    }
+    return false;
+}
+function hasNewerToolCall(message, allMessages, currentIndex) {
+    const content = Array.isArray(message.content) ? message.content : [];
+    const toolName = content.find((b) => b.name)?.name;
+    if (!toolName)
+        return false;
+    const laterMessages = allMessages.slice(currentIndex + 1);
+    return laterMessages.some((m) => {
+        const laterContent = Array.isArray(m.content) ? m.content : [];
+        return laterContent.some((b) => b.name === toolName);
+    });
+}
+async function classifyToolOutput(message, allMessages, currentIndex, model) {
+    const content = Array.isArray(message.content) ? message.content : [];
+    const toolType = detectToolType(content);
+    const text = typeof message.content === 'string' ? message.content : JSON.stringify(message.content);
+    const tokenCount = await (0, tokenizer_1.countTokens)(text, model);
+    const laterMessages = allMessages.slice(currentIndex + 1);
+    const isReferenced = isToolOutputReferenced(message, laterMessages);
+    // Pure tool_result messages have no 'name' field, so hasNewerToolCall returns
+    // false — but their staleness should mirror the preceding tool_use message.
+    const hasToolResults = content.some((b) => b.type === 'tool_result');
+    const hasToolUse = content.some((b) => b.type === 'tool_use');
+    let hasNewer;
+    if (hasToolResults && !hasToolUse && currentIndex > 0) {
+        const preceding = allMessages[currentIndex - 1];
+        hasNewer = preceding ? hasNewerToolCall(preceding, allMessages, currentIndex - 1) : false;
+    }
+    else {
+        hasNewer = hasNewerToolCall(message, allMessages, currentIndex);
+    }
+    const turnsFromEnd = allMessages.length - currentIndex;
+    const isOld = turnsFromEnd > 6;
+    const isStale = !isReferenced && (hasNewer || isOld);
+    return {
+        classification: isStale ? 'TOOL_OUTPUT_STALE' : 'TOOL_OUTPUT_ACTIVE',
+        confidence: isStale ? 0.85 : 0.75,
+        toolType,
+        isLarge: tokenCount > 500,
+    };
+}
+// ─── Error Resolution Checker ─────────────────────────────────────────────────
+function isErrorResolved(errorMessageIndex, allMessages) {
+    const searchWindow = allMessages.slice(errorMessageIndex + 1, errorMessageIndex + 9);
+    return searchWindow.some((m) => {
+        const text = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+        return patterns_1.RESOLUTION_PATTERNS.some((pattern) => pattern.test(text));
+    });
+}
+// ─── Main Classifier ──────────────────────────────────────────────────────────
+async function classifyMessage(message, index, allMessages, model) {
+    // Rule 1: System messages — deterministic
+    if (message.role === 'system') {
+        return { classification: 'SYSTEM_CONSTRAINT', confidence: 1.0, method: 'rule', metadata: {} };
+    }
+    const text = (0, utils_1.extractText)(message);
+    // Rule 2: Tool outputs — structural detection
+    const hasToolContent = Array.isArray(message.content) &&
+        message.content.some((b) => b.type === 'tool_use' || b.type === 'tool_result');
+    if (hasToolContent) {
+        const toolResult = await classifyToolOutput(message, allMessages, index, model);
+        return {
+            classification: toolResult.classification,
+            confidence: toolResult.confidence,
+            method: 'rule',
+            metadata: { toolType: toolResult.toolType, isLarge: toolResult.isLarge },
+        };
+    }
+    // Rule 3: User corrections — check before task definition
+    if (message.role === 'user') {
+        const correctionMatches = patterns_1.CORRECTION_PATTERNS.filter((p) => p.test(text));
+        if (correctionMatches.length >= 1) {
+            return {
+                classification: 'USER_CORRECTION',
+                confidence: correctionMatches.length >= 2 ? 0.95 : 0.75,
+                method: 'heuristic',
+                metadata: { matchCount: correctionMatches.length },
+            };
+        }
+    }
+    // Rule 4: Task definition — first user messages
+    if (message.role === 'user' && index <= 2) {
+        const taskMatches = patterns_1.TASK_DEFINITION_PATTERNS.filter((p) => p.test(text));
+        if (taskMatches.length >= 1) {
+            return {
+                classification: 'TASK_DEFINITION',
+                confidence: index === 0 ? 0.95 : 0.80,
+                method: 'heuristic',
+                metadata: {},
+            };
+        }
+    }
+    // Rule 5: Errors — multiple pattern matches required to reduce false positives
+    const errorMatches = patterns_1.ERROR_PATTERNS.filter((p) => p.test(text));
+    if (errorMatches.length >= 2) {
+        const resolved = isErrorResolved(index, allMessages);
+        return {
+            classification: resolved ? 'ERROR_RESOLVED' : 'ERROR_ACTIVE',
+            confidence: errorMatches.length >= 3 ? 0.92 : 0.78,
+            method: 'heuristic',
+            metadata: { matchCount: errorMatches.length, resolved },
+        };
+    }
+    // Rule 6: Progress markers — short assistant messages with progress language
+    if (message.role === 'assistant') {
+        const progressMatches = patterns_1.PROGRESS_PATTERNS.filter((p) => p.test(text));
+        if (progressMatches.length >= 1 && text.length < 500) {
+            return {
+                classification: 'PROGRESS_MARKER',
+                confidence: 0.72,
+                method: 'heuristic',
+                metadata: {},
+            };
+        }
+    }
+    // Rule 7: Reasoning vs Decision — assistant only
+    if (message.role === 'assistant') {
+        const conclusionMatches = patterns_1.CONCLUSION_PATTERNS.filter((p) => p.test(text));
+        const tokenCount = await (0, tokenizer_1.countTokens)(text, model);
+        if (conclusionMatches.length >= 1) {
+            return {
+                classification: 'DECISION_FINAL',
+                confidence: 0.70,
+                method: 'heuristic',
+                metadata: { tokenCount },
+            };
+        }
+        if (tokenCount > 800) {
+            return {
+                classification: 'REASONING_INTERMEDIATE',
+                confidence: 0.65,
+                method: 'heuristic',
+                metadata: { tokenCount },
+            };
+        }
+    }
+    // Default — CONVERSATIONAL is the safe fallback; LOW confidence prevents aggressive compression
+    return {
+        classification: 'CONVERSATIONAL',
+        confidence: 0.60,
+        method: 'heuristic',
+        metadata: {},
+    };
+}
+// ─── Batch Classifier ─────────────────────────────────────────────────────────
+async function classifyAll(messages, model) {
+    const annotated = [];
+    for (let i = 0; i < messages.length; i++) {
+        const message = messages[i];
+        if (!message)
+            continue;
+        const result = await classifyMessage(message, i, messages, model);
+        // Use full content for token count — tool messages have substantial JSON payload
+        const fullText = typeof message.content === 'string'
+            ? message.content
+            : JSON.stringify(message.content);
+        const tokenCount = await (0, tokenizer_1.countTokens)(fullText, model);
+        annotated.push({
+            id: (0, utils_1.generateId)(),
+            originalIndex: i,
+            original: message,
+            classification: result.classification,
+            classificationConfidence: result.confidence,
+            classificationMethod: result.method,
+            relevanceScore: 0, // filled by scorer
+            relevanceFactors: {
+                recencyScore: 0,
+                referenceCount: 0,
+                taskProximity: 0,
+                isPinned: isPinned(result.classification),
+            },
+            tokenCount,
+            compressionStrategy: 'PRESERVE', // filled by strategy selector
+            compressionApplied: false,
+        });
+    }
+    return annotated;
+}

package/dist/src/classifier/patterns.d.ts

@@ -0,0 +1,7 @@
+export declare const ERROR_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
+export declare const RESOLUTION_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
+export declare const CORRECTION_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
+export declare const PROGRESS_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
+export declare const TASK_DEFINITION_PATTERNS: readonly [RegExp, RegExp, RegExp];
+export declare const CONCLUSION_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp];
+export declare const TECH_STACK_SIGNALS: Record<string, RegExp>;