grov 0.1.0

package/dist/commands/capture.js

@@ -0,0 +1,324 @@
+// grov capture - Called by Stop hook, extracts and stores reasoning
+import 'dotenv/config';
+import { findLatestSessionFile, parseSession, getSessionIdFromPath, isPathWithinProject } from '../lib/jsonl-parser.js';
+import { createTask, createFileReasoning, getSessionState, updateSessionState, shouldFlagForReview, getDriftSummary } from '../lib/store.js';
+import { isLLMAvailable, extractReasoning } from '../lib/llm-extractor.js';
+import { extractAnchors, findAnchorAtLine, computeCodeHash, estimateLineNumber } from '../lib/anchor-extractor.js';
+import { debugCapture } from '../lib/debug.js';
+import { truncate, capitalize } from '../lib/utils.js';
+import { readFileSync, existsSync } from 'fs';
+export async function capture(options) {
+    // Get project path from Claude Code env var, fallback to cwd
+    // CLAUDE_PROJECT_DIR is set by Claude Code when running hooks
+    const projectPath = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    // Find the latest session file
+    const sessionFile = findLatestSessionFile(projectPath);
+    if (!sessionFile) {
+        // No session file found - this is normal for new projects
+        // Silent exit - don't spam the user
+        return;
+    }
+    try {
+        // Parse the session
+        const session = parseSession(sessionFile);
+        // Skip if no user messages (empty session)
+        if (session.userMessages.length === 0) {
+            return;
+        }
+        // Get the original query (first user message)
+        const originalQuery = session.userMessages[0];
+        let goal;
+        let reasoningTrace;
+        let filesTouched;
+        let status;
+        let tags;
+        // Use LLM extraction if available, otherwise fall back to basic extraction
+        if (isLLMAvailable()) {
+            try {
+                debugCapture('Using LLM extraction...');
+                const extracted = await extractReasoning(session);
+                goal = extracted.goal;
+                reasoningTrace = extracted.reasoning_trace;
+                filesTouched = extracted.files_touched;
+                status = extracted.status;
+                tags = extracted.tags;
+                debugCapture('LLM extraction complete: status=%s', status);
+            }
+            catch (llmError) {
+                debugCapture('LLM extraction failed, using fallback: %O', llmError);
+                // Fall back to basic extraction
+                const basic = basicExtraction(session);
+                goal = basic.goal;
+                reasoningTrace = basic.reasoningTrace;
+                filesTouched = basic.filesTouched;
+                status = basic.status;
+                tags = basic.tags;
+            }
+        }
+        else {
+            // No API key - use basic extraction
+            const basic = basicExtraction(session);
+            goal = basic.goal;
+            reasoningTrace = basic.reasoningTrace;
+            filesTouched = basic.filesTouched;
+            status = basic.status;
+            tags = basic.tags;
+        }
+        // Get session ID for drift check
+        const sessionId = getSessionIdFromPath(sessionFile);
+        // === GRADUATION LOGIC: Check if task should be flagged for review ===
+        let finalStatus = status;
+        let finalTags = [...tags];
+        let finalReasoningTrace = [...reasoningTrace];
+        if (sessionId) {
+            const needsReview = shouldFlagForReview(sessionId);
+            const driftSummary = getDriftSummary(sessionId);
+            if (needsReview) {
+                debugCapture('Task flagged for review due to drift');
+                // Downgrade status if was complete
+                if (finalStatus === 'complete') {
+                    finalStatus = 'partial';
+                    debugCapture('Status downgraded from complete to partial');
+                }
+                // Add drift tags
+                finalTags.push('needs-review', 'had-drift');
+                // Add drift summary to reasoning trace
+                if (driftSummary.totalEvents > 0) {
+                    finalReasoningTrace.push(`[Drift events: ${driftSummary.totalEvents} corrections given]`);
+                    finalReasoningTrace.push(`[Drift ${driftSummary.resolved ? 'resolved' : 'unresolved'}: final score ${driftSummary.finalScore}]`);
+                    if (driftSummary.hadHalt) {
+                        finalReasoningTrace.push('[Warning: HALT-level drift occurred during session]');
+                    }
+                }
+            }
+            else if (driftSummary.totalEvents > 0) {
+                // Had drift but recovered - still note it
+                finalReasoningTrace.push(`[Drift events: ${driftSummary.totalEvents} - all resolved]`);
+            }
+        }
+        // Store the task
+        const task = createTask({
+            project_path: projectPath,
+            original_query: originalQuery,
+            goal,
+            reasoning_trace: finalReasoningTrace,
+            files_touched: filesTouched,
+            status: finalStatus,
+            tags: finalTags
+        });
+        // Create file_reasoning entries for each file touched
+        await createFileReasoningEntries(task.id, session, goal);
+        // Update session state if exists
+        if (sessionId) {
+            const sessionState = getSessionState(sessionId);
+            if (sessionState) {
+                updateSessionState(sessionId, {
+                    status: finalStatus === 'complete' ? 'completed' : 'abandoned',
+                    files_explored: [...new Set([...sessionState.files_explored, ...filesTouched])],
+                    original_goal: goal,
+                });
+                debugCapture('Updated session state: %s...', sessionId.substring(0, 8));
+            }
+        }
+        // Log for debugging
+        debugCapture('Captured task: %s...', task.id.substring(0, 8));
+        debugCapture('Query: %s...', originalQuery.substring(0, 50));
+        debugCapture('Files: %d', filesTouched.length);
+        debugCapture('Status: %s (original: %s)', finalStatus, status);
+        debugCapture('LLM: %s', isLLMAvailable() ? 'yes' : 'no');
+    }
+    catch (error) {
+        // Silent fail - don't interrupt user's workflow
+        debugCapture('Capture error: %O', error);
+    }
+}
+/**
+ * Basic extraction without LLM
+ */
+function basicExtraction(session) {
+    const filesTouched = [...new Set([...session.filesRead, ...session.filesWritten])];
+    const status = session.filesWritten.length > 0 ? 'complete' : 'partial';
+    return {
+        goal: session.userMessages[0] || 'Unknown goal',
+        reasoningTrace: generateBasicReasoningTrace(session),
+        filesTouched,
+        status,
+        tags: generateTags(filesTouched)
+    };
+}
+/**
+ * Generate tags from file paths
+ */
+function generateTags(files) {
+    const tags = new Set();
+    for (const file of files) {
+        const parts = file.split('/');
+        const filename = parts[parts.length - 1];
+        // Add directory names as tags
+        for (const part of parts) {
+            if (part && !part.includes('.') && part !== 'src' && part !== 'lib') {
+                tags.add(part.toLowerCase());
+            }
+        }
+        // Add file extension as tag
+        const ext = filename.split('.').pop();
+        if (ext && ext !== filename) {
+            tags.add(ext);
+        }
+        // Common patterns
+        if (filename.includes('auth'))
+            tags.add('auth');
+        if (filename.includes('api'))
+            tags.add('api');
+        if (filename.includes('test'))
+            tags.add('test');
+        if (filename.includes('config'))
+            tags.add('config');
+        if (filename.includes('route'))
+            tags.add('routes');
+        if (filename.includes('model'))
+            tags.add('models');
+        if (filename.includes('util'))
+            tags.add('utils');
+    }
+    return [...tags].slice(0, 10); // Limit to 10 tags
+}
+/**
+ * Generate basic reasoning trace from session data
+ */
+function generateBasicReasoningTrace(session) {
+    const trace = [];
+    // Count tool usage
+    const toolCounts = session.toolCalls.reduce((acc, t) => {
+        acc[t.name] = (acc[t.name] || 0) + 1;
+        return acc;
+    }, {});
+    // Add tool usage summary
+    if (toolCounts['Read']) {
+        trace.push(`Read ${toolCounts['Read']} files`);
+    }
+    if (toolCounts['Write']) {
+        trace.push(`Wrote ${toolCounts['Write']} files`);
+    }
+    if (toolCounts['Edit']) {
+        trace.push(`Edited ${toolCounts['Edit']} files`);
+    }
+    if (toolCounts['Grep'] || toolCounts['Glob']) {
+        trace.push(`Searched codebase`);
+    }
+    if (toolCounts['Bash']) {
+        trace.push(`Ran ${toolCounts['Bash']} commands`);
+    }
+    // Add file summaries
+    if (session.filesRead.length > 0) {
+        trace.push(`Files examined: ${session.filesRead.slice(0, 5).map(f => f.split('/').pop()).join(', ')}`);
+    }
+    if (session.filesWritten.length > 0) {
+        trace.push(`Files modified: ${session.filesWritten.map(f => f.split('/').pop()).join(', ')}`);
+    }
+    return trace;
+}
+/**
+ * Create file_reasoning entries for each file touched in the session
+ */
+async function createFileReasoningEntries(taskId, session, goal) {
+    try {
+        // Process files that were written/edited
+        for (const filePath of session.filesWritten) {
+            await createFileReasoningForFile(taskId, filePath, session, goal, true);
+        }
+        // Also process files that were only read (with less detail)
+        for (const filePath of session.filesRead) {
+            // Skip if already processed as written
+            if (session.filesWritten.includes(filePath))
+                continue;
+            await createFileReasoningForFile(taskId, filePath, session, goal, false);
+        }
+    }
+    catch (error) {
+        debugCapture('Error creating file reasoning entries: %O', error);
+    }
+}
+/**
+ * Create a file_reasoning entry for a specific file
+ */
+async function createFileReasoningForFile(taskId, filePath, session, goal, wasModified) {
+    try {
+        // SECURITY: Validate path is within project boundary to prevent path traversal
+        const projectPath = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+        if (!isPathWithinProject(projectPath, filePath)) {
+            debugCapture('Skipping file outside project boundary: %s', filePath);
+            return;
+        }
+        // Check if file exists
+        if (!existsSync(filePath)) {
+            return;
+        }
+        // Read file content
+        const content = readFileSync(filePath, 'utf-8');
+        // Extract anchors from the file
+        const anchors = extractAnchors(filePath, content);
+        // Find the Edit tool call for this file to determine what was changed
+        const editCalls = session.toolCalls.filter(t => t.name === 'Edit' && t.input?.file_path === filePath);
+        if (editCalls.length > 0 && wasModified) {
+            // For each edit, try to find the anchor
+            for (const editCall of editCalls) {
+                const input = editCall.input;
+                if (input.old_string) {
+                    const lineNumber = estimateLineNumber(input.old_string, content);
+                    const anchor = lineNumber ? findAnchorAtLine(anchors, lineNumber) : null;
+                    const lineStart = anchor?.lineStart || lineNumber || undefined;
+                    const lineEnd = anchor?.lineEnd || lineNumber || undefined;
+                    createFileReasoning({
+                        task_id: taskId,
+                        file_path: filePath,
+                        anchor: anchor?.name,
+                        line_start: lineStart,
+                        line_end: lineEnd,
+                        code_hash: lineStart && lineEnd ? computeCodeHash(content, lineStart, lineEnd) : undefined,
+                        change_type: 'edit',
+                        reasoning: buildReasoningString(anchor, goal, 'edited')
+                    });
+                }
+            }
+        }
+        else if (wasModified) {
+            // File was created/written without Edit
+            const writeCalls = session.toolCalls.filter(t => t.name === 'Write' && t.input?.file_path === filePath);
+            const changeType = writeCalls.length > 0 ? 'create' : 'write';
+            createFileReasoning({
+                task_id: taskId,
+                file_path: filePath,
+                anchor: anchors.length > 0 ? anchors[0].name : undefined,
+                line_start: 1,
+                line_end: content.split('\n').length,
+                code_hash: computeCodeHash(content, 1, content.split('\n').length),
+                change_type: changeType,
+                reasoning: buildReasoningString(null, goal, changeType === 'create' ? 'created' : 'wrote')
+            });
+        }
+        else {
+            // File was only read
+            createFileReasoning({
+                task_id: taskId,
+                file_path: filePath,
+                anchor: anchors.length > 0 ? anchors[0].name : undefined,
+                change_type: 'read',
+                reasoning: `Read during: ${truncate(goal, 80)}`
+            });
+        }
+    }
+    catch (error) {
+        debugCapture('Error processing file %s: %O', filePath, error);
+    }
+}
+/**
+ * Build a reasoning string for a file modification
+ */
+function buildReasoningString(anchor, goal, action) {
+    const shortGoal = truncate(goal, 80);
+    if (anchor) {
+        return `${capitalize(action)} ${anchor.type} "${anchor.name}": ${shortGoal}`;
+    }
+    return `${capitalize(action)} file: ${shortGoal}`;
+}

package/dist/commands/drift-test.d.ts

@@ -0,0 +1,7 @@
+import 'dotenv/config';
+export interface DriftTestOptions {
+    session?: string;
+    goal?: string;
+    verbose?: boolean;
+}
+export declare function driftTest(prompt: string, options: DriftTestOptions): Promise<void>;

package/dist/commands/drift-test.js

@@ -0,0 +1,177 @@
+// grov drift-test - Debug command for testing drift detection
+// Usage: grov drift-test "your prompt here" [--session <id>] [--goal "original goal"]
+//
+// NOTE: This command creates mock ACTIONS from the prompt for testing.
+// In real usage, actions are parsed from Claude's JSONL session file.
+import 'dotenv/config';
+import { getSessionState, createSessionState } from '../lib/store.js';
+import { extractIntent, isAnthropicAvailable } from '../lib/llm-extractor.js';
+import { buildDriftCheckInput, checkDrift, checkDriftBasic, DRIFT_CONFIG } from '../lib/drift-checker.js';
+import { determineCorrectionLevel, buildCorrection } from '../lib/correction-builder.js';
+export async function driftTest(prompt, options) {
+    console.log('=== GROV DRIFT TEST ===\n');
+    // Check API availability
+    const llmAvailable = isAnthropicAvailable();
+    console.log(`Anthropic API: ${llmAvailable ? 'AVAILABLE' : 'NOT AVAILABLE (using fallback)'}`);
+    console.log('');
+    // Get or create session state
+    let sessionState = options.session ? getSessionState(options.session) : null;
+    // If no session, create a test one with provided or extracted goal
+    if (!sessionState) {
+        console.log('No session provided, creating test session...');
+        const goalText = options.goal || prompt;
+        const intent = await extractIntent(goalText);
+        console.log('\n--- Extracted Intent ---');
+        console.log(`Goal: ${intent.goal}`);
+        console.log(`Scope: ${intent.expected_scope.join(', ') || 'none'}`);
+        console.log(`Constraints: ${intent.constraints.join(', ') || 'none'}`);
+        console.log(`Keywords: ${intent.keywords.join(', ')}`);
+        console.log('');
+        // Create temporary session state in memory (not persisted unless session ID provided)
+        sessionState = {
+            session_id: options.session || 'test-session',
+            project_path: process.cwd(),
+            original_goal: intent.goal,
+            actions_taken: [],
+            files_explored: [],
+            current_intent: undefined,
+            drift_warnings: [],
+            start_time: new Date().toISOString(),
+            last_update: new Date().toISOString(),
+            status: 'active',
+            expected_scope: intent.expected_scope,
+            constraints: intent.constraints,
+            success_criteria: intent.success_criteria,
+            keywords: intent.keywords,
+            last_drift_score: undefined,
+            escalation_count: 0,
+            pending_recovery_plan: undefined,
+            drift_history: [],
+            last_checked_at: 0 // New field for action tracking
+        };
+        // Persist if session ID was provided
+        if (options.session) {
+            try {
+                createSessionState({
+                    session_id: options.session,
+                    project_path: process.cwd(),
+                    original_goal: intent.goal,
+                    expected_scope: intent.expected_scope,
+                    constraints: intent.constraints,
+                    success_criteria: intent.success_criteria,
+                    keywords: intent.keywords
+                });
+                console.log(`Session state persisted: ${options.session}`);
+            }
+            catch {
+                // Might already exist, ignore
+            }
+        }
+    }
+    else {
+        console.log(`Using existing session: ${options.session}`);
+        console.log(`Original goal: ${sessionState.original_goal}`);
+        console.log(`Escalation count: ${sessionState.escalation_count}`);
+        console.log(`Drift history: ${sessionState.drift_history.length} events`);
+        console.log('');
+    }
+    // Ensure sessionState is not null at this point
+    if (!sessionState) {
+        console.error('Failed to create session state');
+        process.exit(1);
+    }
+    // Create mock actions from prompt for testing
+    // In real usage, actions are parsed from Claude's JSONL session file
+    const mockFiles = extractFilesFromPrompt(prompt);
+    const mockActions = mockFiles.length > 0
+        ? mockFiles.map((file, i) => ({
+            type: 'edit',
+            files: [file],
+            timestamp: Date.now() + i * 1000
+        }))
+        : [{ type: 'edit', files: ['mock-file.ts'], timestamp: Date.now() }];
+    console.log('--- Mock Actions (from prompt) ---');
+    console.log(`Files detected: ${mockFiles.join(', ') || 'none (using mock-file.ts)'}`);
+    console.log('');
+    // Build drift check input using ACTIONS (not prompt!)
+    const driftInput = buildDriftCheckInput(mockActions, sessionState.session_id, sessionState);
+    console.log('--- Drift Check Input ---');
+    console.log(`Actions: ${mockActions.map(a => `${a.type}:${a.files.join(',')}`).join(' | ')}`);
+    console.log('');
+    // Run drift check
+    console.log('--- Running Drift Check ---');
+    let result;
+    if (llmAvailable) {
+        console.log('Using LLM-based detection...');
+        result = await checkDrift(driftInput);
+    }
+    else {
+        console.log('Using basic (fallback) detection...');
+        result = checkDriftBasic(driftInput);
+    }
+    console.log('');
+    console.log('--- Drift Check Result ---');
+    console.log(`Score: ${result.score}/10`);
+    console.log(`Type: ${result.type}`);
+    console.log(`Diagnostic: ${result.diagnostic}`);
+    if (result.boundaries.length > 0) {
+        console.log(`Boundaries: ${result.boundaries.join(', ')}`);
+    }
+    if (result.recoveryPlan?.steps) {
+        console.log('Recovery steps:');
+        for (const step of result.recoveryPlan.steps) {
+            const file = step.file ? `[${step.file}] ` : '';
+            console.log(`  - ${file}${step.action}`);
+        }
+    }
+    console.log('');
+    // Determine correction level
+    const level = determineCorrectionLevel(result.score, sessionState.escalation_count);
+    console.log('--- Correction Level ---');
+    console.log(`Level: ${level || 'NONE (no correction needed)'}`);
+    console.log('');
+    // Show thresholds
+    console.log('--- Thresholds (with escalation=%d) ---', sessionState.escalation_count);
+    console.log(`>= ${DRIFT_CONFIG.SCORE_NO_INJECTION - sessionState.escalation_count}: No correction`);
+    console.log(`>= ${DRIFT_CONFIG.SCORE_NUDGE - sessionState.escalation_count}: Nudge`);
+    console.log(`>= ${DRIFT_CONFIG.SCORE_CORRECT - sessionState.escalation_count}: Correct`);
+    console.log(`>= ${DRIFT_CONFIG.SCORE_INTERVENE - sessionState.escalation_count}: Intervene`);
+    console.log(`< ${DRIFT_CONFIG.SCORE_INTERVENE - sessionState.escalation_count}: Halt`);
+    console.log('');
+    // Build and show correction if applicable
+    if (level) {
+        console.log('--- Correction Output ---');
+        const correction = buildCorrection(result, sessionState, level);
+        console.log(correction);
+    }
+    else {
+        console.log('No correction needed for this prompt.');
+    }
+    console.log('\n=== END DRIFT TEST ===');
+}
+/**
+ * Extract file paths from a prompt for mock action creation
+ */
+function extractFilesFromPrompt(prompt) {
+    const patterns = [
+        // Absolute paths: /Users/dev/file.ts
+        /(?:^|\s)(\/[\w\-\.\/]+\.\w+)/g,
+        // Relative paths with ./: ./src/file.ts
+        /(?:^|\s)(\.\/[\w\-\.\/]+\.\w+)/g,
+        // Relative paths: src/file.ts or path/to/file.ts
+        /(?:^|\s)([\w\-]+\/[\w\-\.\/]+\.\w+)/g,
+        // Simple filenames with extension: file.ts
+        /(?:^|\s|['"`])([\w\-]+\.\w{1,5})(?:\s|$|,|:|['"`])/g,
+    ];
+    const files = new Set();
+    for (const pattern of patterns) {
+        const matches = prompt.matchAll(pattern);
+        for (const match of matches) {
+            const file = match[1].trim();
+            if (file && !file.match(/^(http|https|ftp|mailto|tel)/) && !file.match(/^\d+\.\d+/)) {
+                files.add(file);
+            }
+        }
+    }
+    return [...files];
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function init(): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,27 @@
+// grov init - Register hooks in Claude Code settings
+import { registerGrovHooks, getSettingsPath } from '../lib/hooks.js';
+export async function init() {
+    console.log('Registering grov hooks in Claude Code...\n');
+    try {
+        const { added, alreadyExists } = registerGrovHooks();
+        if (added.length > 0) {
+            console.log('Added hooks:');
+            added.forEach(hook => console.log(`  + ${hook}`));
+        }
+        if (alreadyExists.length > 0) {
+            console.log('Already registered:');
+            alreadyExists.forEach(hook => console.log(`  = ${hook}`));
+        }
+        console.log(`\nSettings file: ${getSettingsPath()}`);
+        console.log('\nGrov is now active! Your Claude Code sessions will automatically:');
+        console.log('  - Capture reasoning after each task (Stop hook)');
+        console.log('  - Inject relevant context at session start (SessionStart hook)');
+        console.log('  - Inject targeted context before each prompt (UserPromptSubmit hook)');
+        console.log('\nJust use Claude Code normally. Grov works in the background.');
+    }
+    catch (error) {
+        // SECURITY: Only show error message, not full stack trace with paths
+        console.error('Failed to register hooks:', error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+}

package/dist/commands/inject.d.ts

@@ -0,0 +1,5 @@
+interface InjectOptions {
+    task?: string;
+}
+export declare function inject(options: InjectOptions): Promise<void>;
+export {};

package/dist/commands/inject.js

@@ -0,0 +1,88 @@
+// grov inject - Called by SessionStart hook, outputs context JSON
+import { getTasksForProject, createSessionState, getSessionState } from '../lib/store.js';
+import { getCurrentSessionId } from '../lib/jsonl-parser.js';
+import { debugInject } from '../lib/debug.js';
+import { truncate } from '../lib/utils.js';
+export async function inject(options) {
+    debugInject('inject called - CLAUDE_PROJECT_DIR=%s, cwd=%s', process.env.CLAUDE_PROJECT_DIR || 'NOT_SET', process.cwd());
+    try {
+        // Get project path from Claude Code env var, fallback to cwd
+        // CLAUDE_PROJECT_DIR is set by Claude Code when running hooks
+        const projectPath = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+        // Initialize session state for this session
+        const sessionId = getCurrentSessionId(projectPath);
+        if (sessionId) {
+            const existing = getSessionState(sessionId);
+            if (!existing) {
+                createSessionState({
+                    session_id: sessionId,
+                    project_path: projectPath,
+                    user_id: process.env.USER || undefined,
+                });
+                debugInject('Created session state: %s...', sessionId.substring(0, 8));
+            }
+        }
+        // Get completed tasks for this project
+        const tasks = getTasksForProject(projectPath, {
+            status: 'complete',
+            limit: 5 // Only inject most recent 5
+        });
+        // Build context string
+        const context = buildContextString(tasks);
+        // Only output if we have context to inject
+        // Claude Code expects JSON with hookEventName for SessionStart hooks
+        if (context) {
+            const output = {
+                hookSpecificOutput: {
+                    hookEventName: "SessionStart",
+                    additionalContext: context
+                }
+            };
+            console.log(JSON.stringify(output));
+        }
+        // If no context, output nothing - this is cleaner for Claude Code
+    }
+    catch (error) {
+        // On error, output nothing - don't break the session
+        // Silent fail is better than outputting potentially invalid JSON
+        debugInject('Inject error: %O', error);
+    }
+}
+/**
+ * Build the context string to inject
+ */
+function buildContextString(tasks) {
+    if (tasks.length === 0) {
+        return ''; // No context to inject
+    }
+    const lines = [];
+    lines.push('VERIFIED CONTEXT FROM PREVIOUS SESSIONS:');
+    lines.push('(This context was captured from your previous work on this codebase)');
+    lines.push('');
+    for (const task of tasks) {
+        lines.push(`[Task: ${truncate(task.original_query, 80)}]`);
+        // Files touched
+        if (task.files_touched.length > 0) {
+            const fileList = task.files_touched
+                .slice(0, 5)
+                .map(f => f.split('/').pop())
+                .join(', ');
+            lines.push(`- Files: ${fileList}${task.files_touched.length > 5 ? ` (+${task.files_touched.length - 5} more)` : ''}`);
+        }
+        // Reasoning trace
+        if (task.reasoning_trace.length > 0) {
+            for (const trace of task.reasoning_trace.slice(0, 3)) {
+                lines.push(`- ${trace}`);
+            }
+        }
+        // Tags
+        if (task.tags.length > 0) {
+            lines.push(`- Tags: ${task.tags.join(', ')}`);
+        }
+        lines.push('');
+    }
+    // Add instruction for Claude
+    lines.push('YOU MAY SKIP EXPLORE AGENTS for files mentioned above.');
+    lines.push('Read them directly if relevant to the current task.');
+    return lines.join('\n');
+}

package/dist/commands/prompt-inject.d.ts

@@ -0,0 +1,4 @@
+import 'dotenv/config';
+export interface PromptInjectOptions {
+}
+export declare function promptInject(_options: PromptInjectOptions): Promise<void>;