@claudetools/tools 0.7.6 → 0.7.8

package/dist/handlers/tool-handlers.js

@@ -6,7 +6,7 @@ import { mcpLogger } from '../logger.js';
 import { getDefaultProjectId, DEFAULT_USER_ID, lastContextUsed, setLastContextUsed, API_BASE_URL } from '../helpers/config.js';
 import { EXPERT_WORKERS, matchTaskToWorker, buildWorkerPrompt } from '../helpers/workers.js';
 import { validateTaskDescription } from '../templates/orchestrator-prompt.js';
-import { searchMemory, addMemory, storeFact, getContext, getSummary, getEntities, injectContext, apiRequest, listCachedDocs, getCachedDocs, cacheDocs } from '../helpers/api-client.js';
+import { searchMemory, addMemory, storeFact, getContext, getSummary, getEntities, injectContext, apiRequest, listCachedDocs, getCachedDocs, cacheDocs, getMemoryIndex, getMemoryDetail, getDisclosureAnalytics } from '../helpers/api-client.js';
 import { queryDependencies, analyzeImpact } from '../helpers/dependencies.js';
 import { checkPatterns } from '../helpers/patterns.js';
 import { formatContextForClaude } from '../helpers/formatter.js';
@@ -180,6 +180,139 @@ export function registerToolHandlers(server) {
                         ],
                     };
                 }
+                // =========================================================================
+                // PROGRESSIVE DISCLOSURE HANDLERS (memory_index / memory_detail)
+                // =========================================================================
+                case 'memory_index': {
+                    // Get lightweight index of available memories
+                    const query = args?.query;
+                    const limit = args?.limit || 30;
+                    const includeCategories = args?.include_categories;
+                    const minRelevance = args?.min_relevance || 0.3;
+                    mcpLogger.searchQuery(query || '(index scan)', 'index');
+                    const indexTimer = mcpLogger.startTimer();
+                    const result = await getMemoryIndex(projectId, {
+                        query,
+                        limit,
+                        include_categories: includeCategories,
+                        min_relevance: minRelevance,
+                    });
+                    mcpLogger.toolResult(name, true, timer(), `${result.index.length} entries, ${result.metadata.critical_count} critical`);
+                    // Format as compact index table
+                    let output = `# Memory Index\n\n`;
+                    output += `**Total Available:** ${result.metadata.total_available}\n`;
+                    output += `**Returned:** ${result.metadata.returned}\n`;
+                    output += `**Critical Facts:** ${result.metadata.critical_count}\n`;
+                    output += `**Total Token Cost:** ~${result.metadata.total_token_cost} tokens\n`;
+                    output += `**Query:** ${result.metadata.query || '(none)'}\n`;
+                    output += `**Time:** ${result.metadata.retrieval_time_ms}ms\n\n`;
+                    if (result.index.length === 0) {
+                        output += `No memories found matching the criteria.\n`;
+                    }
+                    else {
+                        output += `## Entries\n\n`;
+                        output += `| # | ID | Summary | Category | Relevance | Tokens | Critical |\n`;
+                        output += `|---|----|---------|---------:|---------:|---------:|:---------:|\n`;
+                        result.index.forEach((entry, i) => {
+                            const critical = entry.is_critical ? '🔴' : '';
+                            const summary = entry.summary.length > 50 ? entry.summary.slice(0, 47) + '...' : entry.summary;
+                            output += `| ${i + 1} | \`${entry.id.slice(0, 8)}\` | ${summary} | ${entry.category} | ${(entry.relevance * 100).toFixed(0)}% | ~${entry.token_cost} | ${critical} |\n`;
+                        });
+                        output += `\n**Usage:** Call \`memory_detail(memory_ids=["id1", "id2", ...])\` to fetch full content for specific entries.\n`;
+                    }
+                    return {
+                        content: [{ type: 'text', text: output }],
+                    };
+                }
+                case 'memory_detail': {
+                    // Fetch full content for specific memory IDs
+                    const memoryIds = args?.memory_ids;
+                    if (!memoryIds || memoryIds.length === 0) {
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: 'Error: memory_ids array is required. Use memory_index first to discover IDs.',
+                                }],
+                            isError: true,
+                        };
+                    }
+                    const detailTimer = mcpLogger.startTimer();
+                    const result = await getMemoryDetail(projectId, memoryIds);
+                    mcpLogger.toolResult(name, true, timer(), `${result.metadata.found}/${result.metadata.requested} found`);
+                    let output = `# Memory Details\n\n`;
+                    output += `**Requested:** ${result.metadata.requested}\n`;
+                    output += `**Found:** ${result.metadata.found}\n`;
+                    output += `**Time:** ${result.metadata.retrieval_time_ms}ms\n\n`;
+                    if (result.metadata.not_found.length > 0) {
+                        output += `**Not Found:** ${result.metadata.not_found.join(', ')}\n\n`;
+                    }
+                    if (result.memories.length === 0) {
+                        output += `No memories found for the requested IDs.\n`;
+                    }
+                    else {
+                        for (const memory of result.memories) {
+                            output += `---\n\n`;
+                            output += `## ${memory.source_entity} → ${memory.relation_type} → ${memory.target_entity}\n\n`;
+                            output += `**ID:** \`${memory.id}\`\n`;
+                            output += `**Created:** ${new Date(memory.created_at).toLocaleDateString()}\n`;
+                            output += `**Valid:** ${memory.valid ? '✅' : '❌'}\n\n`;
+                            output += `**Fact:**\n${memory.fact}\n\n`;
+                        }
+                    }
+                    return {
+                        content: [{ type: 'text', text: output }],
+                    };
+                }
+                case 'disclosure_analytics': {
+                    // Get disclosure analytics for memory usage optimization
+                    const days = args?.days || 30;
+                    const limit = args?.limit || 20;
+                    const analyticsTimer = mcpLogger.startTimer();
+                    const result = await getDisclosureAnalytics(projectId, { days, limit });
+                    mcpLogger.toolResult(name, true, timer(), `${result.summary.unique_memories} memories tracked`);
+                    let output = `# Disclosure Analytics\n\n`;
+                    output += `## Summary (Last ${result.summary.period_days} days)\n\n`;
+                    output += `| Metric | Value |\n`;
+                    output += `|:-------|------:|\n`;
+                    output += `| Total Indexed | ${result.summary.total_indexed} |\n`;
+                    output += `| Total Fetched | ${result.summary.total_fetched} |\n`;
+                    output += `| Total Injected | ${result.summary.total_injected} |\n`;
+                    output += `| Unique Memories | ${result.summary.unique_memories} |\n`;
+                    output += `| Overall Hit Rate | ${(result.summary.overall_hit_rate * 100).toFixed(1)}% |\n\n`;
+                    if (result.event_counts.length > 0) {
+                        output += `## Event Counts\n\n`;
+                        output += `| Event Type | Count |\n`;
+                        output += `|:-----------|------:|\n`;
+                        for (const ec of result.event_counts) {
+                            output += `| ${ec.event_type} | ${ec.count} |\n`;
+                        }
+                        output += `\n`;
+                    }
+                    if (result.top_fetched.length > 0) {
+                        output += `## Top Fetched Memories\n\n`;
+                        output += `These memories are frequently accessed via memory_detail:\n\n`;
+                        output += `| Memory ID | Index | Fetch | Inject | Hit Rate |\n`;
+                        output += `|:----------|------:|------:|-------:|---------:|\n`;
+                        for (const tf of result.top_fetched) {
+                            output += `| \`${tf.memory_id.slice(0, 12)}\` | ${tf.index_count} | ${tf.detail_count} | ${tf.inject_count} | ${(tf.hit_rate * 100).toFixed(0)}% |\n`;
+                        }
+                        output += `\n`;
+                    }
+                    if (result.critical_candidates.length > 0) {
+                        output += `## 🔴 Critical Candidates\n\n`;
+                        output += `These memories have high hit rates and may benefit from being marked as critical:\n\n`;
+                        output += `| Memory ID | Index | Fetch | Hit Rate |\n`;
+                        output += `|:----------|------:|------:|---------:|\n`;
+                        for (const cc of result.critical_candidates) {
+                            output += `| \`${cc.memory_id.slice(0, 12)}\` | ${cc.index_count} | ${cc.detail_count} | ${(cc.hit_rate * 100).toFixed(0)}% |\n`;
+                        }
+                        output += `\n`;
+                        output += `**Tip:** Mark frequently-fetched memories as architecture/decision facts for auto-injection.\n`;
+                    }
+                    return {
+                        content: [{ type: 'text', text: output }],
+                    };
+                }
                 case 'query_dependencies': {
                     const functionName = args?.function_name;
                     const direction = args?.direction || 'both';

package/dist/helpers/api-client.d.ts

@@ -75,6 +75,96 @@ export declare function listCachedDocs(_projectId?: string): Promise<DocsCacheLi
  */
 export declare function getCachedDocs(_projectId: string, // Unused - docs cache is global
 libraryId: string, topic?: string): Promise<CachedDoc | null>;
+export interface MemoryIndexEntry {
+    id: string;
+    summary: string;
+    category: 'architecture' | 'pattern' | 'decision' | 'preference' | 'fact';
+    relevance: number;
+    token_cost: number;
+    is_critical: boolean;
+    created_at: string;
+}
+export interface MemoryIndexResponse {
+    index: MemoryIndexEntry[];
+    metadata: {
+        total_available: number;
+        returned: number;
+        query?: string;
+        retrieval_time_ms: number;
+        critical_count: number;
+        total_token_cost: number;
+    };
+}
+export interface MemoryDetailEntry {
+    id: string;
+    source_entity: string;
+    target_entity: string;
+    relation_type: string;
+    fact: string;
+    context?: string;
+    created_at: string;
+    valid: boolean;
+}
+export interface MemoryDetailResponse {
+    memories: MemoryDetailEntry[];
+    metadata: {
+        requested: number;
+        found: number;
+        not_found: string[];
+        retrieval_time_ms: number;
+    };
+}
+/**
+ * Get a lightweight index of available memories without full content.
+ * Returns metadata (topic, token cost, relevance) for Claude to scan and decide what to fetch.
+ */
+export declare function getMemoryIndex(projectId: string, options?: {
+    query?: string;
+    limit?: number;
+    include_categories?: ('architecture' | 'pattern' | 'decision' | 'preference' | 'fact')[];
+    min_relevance?: number;
+}, userId?: string): Promise<MemoryIndexResponse>;
+/**
+ * Fetch full content for specific memory IDs.
+ * Use after scanning the index to retrieve only needed details.
+ */
+export declare function getMemoryDetail(projectId: string, memoryIds: string[], userId?: string): Promise<MemoryDetailResponse>;
+export interface DisclosureAnalytics {
+    summary: {
+        period_days: number;
+        total_indexed: number;
+        total_fetched: number;
+        total_injected: number;
+        unique_memories: number;
+        overall_hit_rate: number;
+    };
+    event_counts: Array<{
+        event_type: string;
+        count: number;
+    }>;
+    top_fetched: Array<{
+        memory_id: string;
+        index_count: number;
+        detail_count: number;
+        inject_count: number;
+        hit_rate: number;
+        last_indexed_at: string;
+        last_fetched_at: string;
+    }>;
+    critical_candidates: Array<{
+        memory_id: string;
+        index_count: number;
+        detail_count: number;
+        hit_rate: number;
+    }>;
+}
+/**
+ * Get disclosure analytics for a project
+ */
+export declare function getDisclosureAnalytics(projectId: string, options?: {
+    limit?: number;
+    days?: number;
+}, userId?: string): Promise<DisclosureAnalytics>;
 /**
  * Ensure documentation is cached (fetches from Context7 if needed)
  */

package/dist/helpers/api-client.js

@@ -105,6 +105,38 @@ libraryId, topic) {
         return null;
     }
 }
+/**
+ * Get a lightweight index of available memories without full content.
+ * Returns metadata (topic, token cost, relevance) for Claude to scan and decide what to fetch.
+ */
+export async function getMemoryIndex(projectId, options = {}, userId = DEFAULT_USER_ID) {
+    const response = await apiRequest(`/api/v1/memory/${userId}/${projectId}/index`, 'POST', options);
+    return response.data;
+}
+/**
+ * Fetch full content for specific memory IDs.
+ * Use after scanning the index to retrieve only needed details.
+ */
+export async function getMemoryDetail(projectId, memoryIds, userId = DEFAULT_USER_ID) {
+    const response = await apiRequest(`/api/v1/memory/${userId}/${projectId}/detail`, 'POST', { memory_ids: memoryIds });
+    return response.data;
+}
+/**
+ * Get disclosure analytics for a project
+ */
+export async function getDisclosureAnalytics(projectId, options = {}, userId = DEFAULT_USER_ID) {
+    const params = new URLSearchParams();
+    if (options.limit)
+        params.set('limit', String(options.limit));
+    if (options.days)
+        params.set('days', String(options.days));
+    const queryString = params.toString();
+    const response = await apiRequest(`/api/v1/memory/${userId}/${projectId}/analytics${queryString ? `?${queryString}` : ''}`);
+    return response.data;
+}
+// =============================================================================
+// Documentation Cache Operations
+// =============================================================================
 /**
  * Ensure documentation is cached (fetches from Context7 if needed)
  */

package/dist/setup.js

@@ -625,27 +625,43 @@ if [ -n "$PROJECT_ID" ]; then
     -d "{\\"project_id\\": \\"$PROJECT_ID\\"}" 2>/dev/null)
 
   if [ -n "$CONTEXT" ] && [ "$CONTEXT" != "null" ]; then
-    # Extract facts and patterns from response
-    FACTS=$(echo "$CONTEXT" | jq -r '.facts // []' 2>/dev/null)
-    PATTERNS=$(echo "$CONTEXT" | jq -r '.patterns // []' 2>/dev/null)
+    # Extract progressive disclosure data from response
+    CRITICAL=$(echo "$CONTEXT" | jq -r '.data.critical_facts // []' 2>/dev/null)
+    INDEX=$(echo "$CONTEXT" | jq -r '.data.memory_index // []' 2>/dev/null)
+    INSTRUCTIONS=$(echo "$CONTEXT" | jq -r '.data.instructions // ""' 2>/dev/null)
+    CRITICAL_COUNT=$(echo "$CONTEXT" | jq -r '.data.metadata.critical_count // 0' 2>/dev/null)
+    INDEX_COUNT=$(echo "$CONTEXT" | jq -r '.data.metadata.index_count // 0' 2>/dev/null)
 
-    # Generate session context file
+    # Generate session context file with progressive disclosure format
     cat > "$CONTEXT_FILE" << CTXEOF
-# Session Context: $PROJECT_NAME
+🚀 **SESSION CONTEXT: $PROJECT_NAME**
 
 **Project ID:** $PROJECT_ID
 **Generated:** $(date -u +"%Y-%m-%dT%H:%M:%SZ")
 
-## Relevant Facts
+---
+
+## 📌 Project Knowledge (Auto-Injected from Memory)
+
+**IMPORTANT:** The facts below are stored in your memory system and represent critical patterns, mistakes to avoid, and architectural decisions. READ THESE before making changes.
 
-$(echo "$FACTS" | jq -r '.[] | "- \\(.entity1) \\(.relationship) \\(.entity2): \\(.context)"' 2>/dev/null || echo "- No facts stored yet")
+$(echo "$CRITICAL" | jq -r '.[] | "### \\(.category | ascii_upcase): \\(.source) → \\(.target)\n\\(.fact)\n"' 2>/dev/null || echo "No critical facts stored yet.")
 
-## Detected Patterns
+$(if [ "$INDEX_COUNT" != "0" ] && [ "$INDEX_COUNT" != "" ]; then
+echo "---
 
-$(echo "$PATTERNS" | jq -r '.[] | "- **\\(.name)**: \\(.description)"' 2>/dev/null || echo "- No patterns detected yet")
+## 📋 Memory Index ($INDEX_COUNT entries available)
+
+**Quick reference** - use \\\`memory_detail({ memory_ids: [\"id\"] })\\\` to fetch full details.
+
+| ID | Summary | Category |
+|:---|:--------|:---------|"
+echo "$INDEX" | jq -r '.[] | "| \(.id) | \(.summary) | \(.category) |"' 2>/dev/null
+fi)
 
 ---
-*This file is regenerated each session. Do not edit manually.*
+*This context is automatically generated each session. Facts come from the claudetools memory system.*
+*To add new facts: use memory_store_fact(entity1, relationship, entity2, context)*
 CTXEOF
   fi
 else
@@ -671,9 +687,10 @@ fi
     writeFileSync(sessionStartPath, sessionStartHook, { mode: 0o755 });
     success('Installed session-start.sh hook');
     // User prompt submit hook - injects context before each message
+    // This hook receives the user's prompt via stdin and performs semantic search
     const userPromptHook = `#!/bin/bash
-# ClaudeTools Context Injection Hook
-# Automatically injects relevant memory context before each prompt
+# ClaudeTools Per-Prompt Context Injection Hook
+# Reads user's prompt from stdin, performs semantic search, injects relevant context
 
 # Prevent recursion
 LOCK_FILE="/tmp/claude-prompt-hook.lock"
@@ -684,6 +701,21 @@ trap "rm -f $LOCK_FILE" EXIT
 # Skip if disabled
 if [ "$CLAUDE_DISABLE_HOOKS" = "1" ]; then exit 0; fi
 
+# Read the user's prompt from stdin (Claude Code passes it as JSON)
+INPUT=$(timeout 1 cat 2>/dev/null || echo "")
+USER_QUERY=""
+if [ -n "$INPUT" ]; then
+  # Extract the prompt text from the JSON input
+  # Claude Code sends: {"prompt": "user message...", ...}
+  USER_QUERY=$(echo "$INPUT" | jq -r '.prompt // .message // .content // empty' 2>/dev/null)
+fi
+
+# If no query, skip injection (nothing to search for)
+if [ -z "$USER_QUERY" ]; then exit 0; fi
+
+# Skip very short queries (likely not worth searching)
+if [ \${#USER_QUERY} -lt 10 ]; then exit 0; fi
+
 # Read config
 CONFIG_FILE="$HOME/.claudetools/config.json"
 if [ ! -f "$CONFIG_FILE" ]; then exit 0; fi
@@ -706,25 +738,28 @@ fi
 
 # Priority 2: Fall back to projects.json cache
 if [ -z "$PROJECT_ID" ] && [ -f "$PROJECT_FILE" ]; then
-  # Try to find project by path prefix (use variable binding for jq startswith)
   PROJECT_ID=$(jq -r --arg cwd "$CWD" '
     .bindings[]? | select(.local_path) |
     . as $b | select($cwd | startswith($b.local_path)) |
     .project_id' "$PROJECT_FILE" 2>/dev/null | head -1)
 fi
 
-# Inject context (silent fail)
-RESULT=$(curl -s -X POST "$API_URL/api/v1/context/inject" \\
+# Escape the query for JSON (handle quotes and newlines)
+ESCAPED_QUERY=$(echo "$USER_QUERY" | head -c 500 | jq -Rs '.')
+
+# Inject context with semantic search based on the user's prompt
+RESULT=$(curl -s --max-time 2 -X POST "$API_URL/api/v1/context/inject" \\
   -H "Authorization: Bearer $API_KEY" \\
   -H "Content-Type: application/json" \\
-  -d "{\\"project_id\\": \\"$PROJECT_ID\\", \\"cwd\\": \\"$CWD\\"}" \\
+  -d "{\\"query\\": $ESCAPED_QUERY, \\"project_id\\": \\"$PROJECT_ID\\", \\"cwd\\": \\"$CWD\\"}" \\
   2>/dev/null)
 
-# Output context if available
+# Output context as additionalContext JSON for Claude Code
 if [ -n "$RESULT" ] && [ "$RESULT" != "null" ]; then
-  CONTEXT=$(echo "$RESULT" | jq -r '.context // empty' 2>/dev/null)
-  if [ -n "$CONTEXT" ]; then
-    echo "$CONTEXT"
+  CONTEXT=$(echo "$RESULT" | jq -r '.data.context // empty' 2>/dev/null)
+  if [ -n "$CONTEXT" ] && [ "$CONTEXT" != "" ]; then
+    # Output as JSON with additionalContext for Claude Code to inject
+    echo "{\\"additionalContext\\": $CONTEXT}"
   fi
 fi
 `;
@@ -777,6 +812,77 @@ curl -s -X POST "$API_URL/api/v1/tools/log" \\
     }
     writeFileSync(postToolPath, postToolHook, { mode: 0o755 });
     success('Installed post-tool-use.sh hook');
+    // PreCompact hook - auto-saves session knowledge before compaction
+    // Fires before Claude's auto-compact summarizes away conversation details
+    const preCompactHook = `#!/bin/bash
+# ClaudeTools PreCompact Knowledge Extraction Hook
+# Automatically extracts and saves important session knowledge before compaction
+
+# Skip if disabled
+if [ "$CLAUDE_DISABLE_HOOKS" = "1" ]; then exit 0; fi
+
+# Read the transcript from stdin (Claude Code passes JSON with transcript)
+INPUT=$(timeout 5 cat 2>/dev/null || echo "")
+if [ -z "$INPUT" ]; then exit 0; fi
+
+# Extract trigger type (auto or manual)
+TRIGGER=$(echo "$INPUT" | jq -r '.trigger // "unknown"' 2>/dev/null)
+
+# Only process auto compaction (most valuable to preserve)
+# Manual compaction the user controls what gets kept
+if [ "$TRIGGER" != "auto" ]; then exit 0; fi
+
+# Read config
+CONFIG_FILE="$HOME/.claudetools/config.json"
+if [ ! -f "$CONFIG_FILE" ]; then exit 0; fi
+
+API_URL=$(jq -r '.apiUrl // "https://api.claudetools.dev"' "$CONFIG_FILE")
+API_KEY=$(jq -r '.apiKey // empty' "$CONFIG_FILE")
+
+if [ -z "$API_KEY" ]; then exit 0; fi
+
+# Get current project
+CWD=$(pwd)
+PROJECT_ID=""
+
+CLAUDE_MD="$CWD/.claude/CLAUDE.md"
+if [ -f "$CLAUDE_MD" ]; then
+  PROJECT_ID=$(grep "Project ID" "$CLAUDE_MD" 2>/dev/null | sed -n "s/.*\\\`\\([a-z0-9_]*\\)\\\`.*/\\1/p" | head -1)
+fi
+
+if [ -z "$PROJECT_ID" ]; then
+  PROJECT_FILE="$HOME/.claudetools/projects.json"
+  if [ -f "$PROJECT_FILE" ]; then
+    PROJECT_ID=$(jq -r --arg cwd "$CWD" '
+      .bindings[]? | select(.local_path) |
+      . as $b | select($cwd | startswith($b.local_path)) |
+      .project_id' "$PROJECT_FILE" 2>/dev/null | head -1)
+  fi
+fi
+
+if [ -z "$PROJECT_ID" ]; then exit 0; fi
+
+# Extract the transcript/conversation from the input
+TRANSCRIPT=$(echo "$INPUT" | jq -r '.transcript // .conversation // .messages // empty' 2>/dev/null)
+
+# Send to API for knowledge extraction (async, don't block compaction)
+curl -s --max-time 10 -X POST "$API_URL/api/v1/context/extract" \\
+  -H "Authorization: Bearer $API_KEY" \\
+  -H "Content-Type: application/json" \\
+  -d "{\\"project_id\\": \\"$PROJECT_ID\\", \\"trigger\\": \\"$TRIGGER\\", \\"transcript\\": $TRANSCRIPT}" \\
+  2>/dev/null &
+
+# Don't wait for extraction - let compaction proceed
+exit 0
+`;
+    const preCompactPath = join(HOOKS_DIR, 'pre-compact.sh');
+    if (existsSync(preCompactPath)) {
+        const backup = backupFile(preCompactPath);
+        if (backup)
+            info(`Backed up existing hook to ${basename(backup)}`);
+    }
+    writeFileSync(preCompactPath, preCompactHook, { mode: 0o755 });
+    success('Installed pre-compact.sh hook');
 }
 async function configureSettings() {
     header('Claude Code Settings');
@@ -850,6 +956,23 @@ async function configureSettings() {
         });
         success('Added PostToolUse hook to settings');
     }
+    // Add PreCompact hook (auto-saves session knowledge before compaction)
+    if (!hooks.PreCompact) {
+        hooks.PreCompact = [];
+    }
+    const preCompactHooks = hooks.PreCompact;
+    const hasPreCompactHook = preCompactHooks.some(h => h.hooks?.some(hk => hk.command?.includes('pre-compact.sh')));
+    if (!hasPreCompactHook) {
+        preCompactHooks.push({
+            matcher: '',
+            hooks: [{
+                    type: 'command',
+                    command: join(HOOKS_DIR, 'pre-compact.sh'),
+                    timeout: 15, // Give extraction more time
+                }],
+        });
+        success('Added PreCompact hook to settings');
+    }
     // Write settings
     writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
     success(`Saved settings to ${SETTINGS_PATH}`);
@@ -967,7 +1090,7 @@ async function verifySetup(config) {
         error('MCP config not found');
     }
     // Check hooks installed
-    const requiredHooks = ['session-start.sh', 'user-prompt-submit.sh', 'post-tool-use.sh'];
+    const requiredHooks = ['session-start.sh', 'user-prompt-submit.sh', 'post-tool-use.sh', 'pre-compact.sh'];
     const installedHooks = requiredHooks.filter(h => existsSync(join(HOOKS_DIR, h)));
     if (installedHooks.length === requiredHooks.length) {
         success('All hooks installed');
@@ -1151,7 +1274,7 @@ export async function runUninstall() {
         }
     }
     // Remove hook scripts
-    const hooks = ['session-start.sh', 'user-prompt-submit.sh', 'post-tool-use.sh'];
+    const hooks = ['session-start.sh', 'user-prompt-submit.sh', 'post-tool-use.sh', 'pre-compact.sh'];
     for (const hook of hooks) {
         const hookPath = join(HOOKS_DIR, hook);
         if (existsSync(hookPath)) {

package/dist/tools.js

@@ -180,6 +180,111 @@ EXAMPLES:
                     },
                 },
             },
+            // =========================================================================
+            // PROGRESSIVE DISCLOSURE TOOLS (Layer 1 & 2)
+            // =========================================================================
+            {
+                name: 'memory_index',
+                description: `Get a lightweight index of available memories WITHOUT fetching full content. Use this FIRST to scan what context is available before deciding what to retrieve.
+
+Returns for each memory:
+- id: Unique identifier for fetching details
+- topic: Short topic/subject description
+- relevance: Score (0-1) indicating how relevant to query
+- token_cost: Estimated tokens if fetched
+- importance: "critical" | "high" | "normal" - Critical facts are auto-injected
+- category: "architecture" | "pattern" | "decision" | "preference" | "fact"
+- last_accessed: When this memory was last used
+
+WORKFLOW:
+1. Call memory_index with your query to see what's available
+2. Review the index - critical items are auto-injected
+3. Call memory_detail for specific IDs you want full content for
+
+This saves tokens by letting you selectively fetch only relevant memories.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'Search query to find relevant memories (optional - returns all if empty)',
+                        },
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID (optional, uses default if not provided)',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of index entries to return (default: 50)',
+                        },
+                        include_categories: {
+                            type: 'array',
+                            items: { type: 'string', enum: ['architecture', 'pattern', 'decision', 'preference', 'fact'] },
+                            description: 'Filter by memory categories (optional)',
+                        },
+                        min_relevance: {
+                            type: 'number',
+                            description: 'Minimum relevance score (0-1) to include (default: 0)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'memory_detail',
+                description: `Fetch full content for specific memories by ID. Use after memory_index to retrieve details for memories you want.
+
+Returns full memory content including:
+- Complete fact/context text
+- Related entities
+- Source information
+- Temporal context
+
+Use sparingly - each fetch costs tokens. Let memory_index guide which memories to fetch.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        memory_ids: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Array of memory IDs to fetch full content for',
+                        },
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID (optional, uses default if not provided)',
+                        },
+                    },
+                    required: ['memory_ids'],
+                },
+            },
+            {
+                name: 'disclosure_analytics',
+                description: `View analytics for memory disclosure patterns. Shows which memories are indexed vs fetched, hit rates, and candidates for marking as critical.
+
+Use this to optimize memory retrieval:
+- See which memories are frequently fetched (may need auto-injection)
+- Calculate overall hit rate (fetched / indexed ratio)
+- Identify memories that should be marked as critical/architecture
+- Track usage trends over time
+
+High hit rate memories (frequently fetched after being indexed) are good candidates for promotion to critical status, which enables auto-injection and saves tokens.`,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID (optional, uses default if not provided)',
+                        },
+                        days: {
+                            type: 'number',
+                            description: 'Number of days to analyze (default: 30)',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of top memories to return (default: 20)',
+                        },
+                    },
+                },
+            },
             {
                 name: 'query_dependencies',
                 description: 'Query function call dependencies from the code graph. Find what functions a given function calls (forward) or what functions call it (reverse). Week 4: Dependency Query Tool.',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claudetools/tools",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "description": "Persistent AI memory, task management, and codebase intelligence for Claude Code",
   "type": "module",
   "main": "dist/index.js",