grov 0.5.2 → 0.5.3

package/dist/proxy/injection/injectors.js

@@ -0,0 +1,139 @@
+// Injection helpers for modifying request bodies
+export function appendToLastUserMessage(rawBody, injection) {
+    // Find the last occurrence of "role":"user" followed by content
+    // We need to find the content field of the last user message and append to it
+    // Strategy: Find all user messages, get the last one, append to its content
+    // This is tricky because content can be string or array
+    // Simpler approach: Find the last user message's closing content
+    // Look for pattern: "role":"user","content":"..." or "role":"user","content":[...]
+    // Find last "role":"user"
+    const userRolePattern = /"role"\s*:\s*"user"/g;
+    let lastUserMatch = null;
+    let match;
+    while ((match = userRolePattern.exec(rawBody)) !== null) {
+        lastUserMatch = match;
+    }
+    if (!lastUserMatch) {
+        // No user message found, can't inject
+        return rawBody;
+    }
+    // From lastUserMatch position, find the content field
+    const afterRole = rawBody.slice(lastUserMatch.index);
+    // Find "content" field after role
+    const contentMatch = afterRole.match(/"content"\s*:\s*/);
+    if (!contentMatch || contentMatch.index === undefined) {
+        return rawBody;
+    }
+    const contentStartGlobal = lastUserMatch.index + contentMatch.index + contentMatch[0].length;
+    const afterContent = rawBody.slice(contentStartGlobal);
+    // Determine if content is string or array
+    if (afterContent.startsWith('"')) {
+        // String content - find closing quote (handling escapes)
+        let i = 1; // Skip opening quote
+        while (i < afterContent.length) {
+            if (afterContent[i] === '\\') {
+                i += 2; // Skip escaped char
+            }
+            else if (afterContent[i] === '"') {
+                // Found closing quote
+                const insertPos = contentStartGlobal + i;
+                // Insert before closing quote, escape the injection for JSON
+                const escapedInjection = injection
+                    .replace(/\\/g, '\\\\')
+                    .replace(/"/g, '\\"')
+                    .replace(/\n/g, '\\n');
+                return rawBody.slice(0, insertPos) + '\\n\\n' + escapedInjection + rawBody.slice(insertPos);
+            }
+            else {
+                i++;
+            }
+        }
+    }
+    else if (afterContent.startsWith('[')) {
+        // Array content - find last text block and append, or add new text block
+        // Find the closing ] of the content array
+        let depth = 1;
+        let i = 1;
+        while (i < afterContent.length && depth > 0) {
+            const char = afterContent[i];
+            if (char === '[')
+                depth++;
+            else if (char === ']')
+                depth--;
+            else if (char === '"') {
+                // Skip string
+                i++;
+                while (i < afterContent.length && afterContent[i] !== '"') {
+                    if (afterContent[i] === '\\')
+                        i++;
+                    i++;
+                }
+            }
+            i++;
+        }
+        if (depth === 0) {
+            // Found closing bracket at position i-1
+            const insertPos = contentStartGlobal + i - 1;
+            // Add new text block before closing bracket
+            const escapedInjection = injection
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"')
+                .replace(/\n/g, '\\n');
+            const newBlock = `,{"type":"text","text":"\\n\\n${escapedInjection}"}`;
+            return rawBody.slice(0, insertPos) + newBlock + rawBody.slice(insertPos);
+        }
+    }
+    // Fallback: couldn't parse, return unchanged
+    return rawBody;
+}
+export function appendToSystemPrompt(body, textToAppend) {
+    if (typeof body.system === 'string') {
+        body.system = body.system + textToAppend;
+    }
+    else if (Array.isArray(body.system)) {
+        // Append as new text block WITHOUT cache_control
+        // Anthropic allows max 4 cache blocks - Claude Code already uses 2+
+        // Grov's injections are small (~2KB) so uncached is fine
+        body.system.push({
+            type: 'text',
+            text: textToAppend,
+        });
+    }
+    else {
+        // No system prompt yet, create as string
+        body.system = textToAppend;
+    }
+}
+export function injectIntoRawBody(rawBody, injectionText) {
+    // Find the system array in the raw JSON
+    // Pattern: "system": [....]
+    const systemMatch = rawBody.match(/"system"\s*:\s*\[/);
+    if (!systemMatch || systemMatch.index === undefined) {
+        return { modified: rawBody, success: false };
+    }
+    // Find the matching closing bracket for the system array
+    const startIndex = systemMatch.index + systemMatch[0].length;
+    let bracketCount = 1;
+    let endIndex = startIndex;
+    for (let i = startIndex; i < rawBody.length && bracketCount > 0; i++) {
+        const char = rawBody[i];
+        if (char === '[')
+            bracketCount++;
+        else if (char === ']')
+            bracketCount--;
+        if (bracketCount === 0) {
+            endIndex = i;
+            break;
+        }
+    }
+    if (bracketCount !== 0) {
+        return { modified: rawBody, success: false };
+    }
+    // Escape the injection text for JSON
+    const escapedText = JSON.stringify(injectionText).slice(1, -1); // Remove outer quotes
+    // Create the new block (without cache_control - will be cache_creation)
+    const newBlock = `,{"type":"text","text":"${escapedText}"}`;
+    // Insert before the closing bracket
+    const modified = rawBody.slice(0, endIndex) + newBlock + rawBody.slice(endIndex);
+    return { modified, success: true };
+}

package/dist/proxy/request-processor.d.ts

@@ -1,9 +1,15 @@
 /**
- * Build context from team memory for injection (PAST sessions only)
- * Queries tasks and file_reasoning tables, excluding current session data
- * @param currentSessionId - Session ID to exclude (ensures only past session data)
+ * Build context from CLOUD team memory for injection
+ * Fetches memories from Supabase via API (cloud-first approach)
+ * Uses hybrid search (semantic + lexical) when userPrompt is provided
+ *
+ * @param teamId - Team UUID from sync configuration
+ * @param projectPath - Project path to filter by
+ * @param mentionedFiles - Files mentioned in user messages (for boost)
+ * @param userPrompt - User's prompt for semantic search (optional)
+ * @returns Formatted context string or null if no memories found
  */
-export declare function buildTeamMemoryContext(projectPath: string, mentionedFiles: string[], currentSessionId?: string): string | null;
+export declare function buildTeamMemoryContextCloud(teamId: string, projectPath: string, mentionedFiles: string[], userPrompt?: string): Promise<string | null>;
 /**
  * Extract file paths from messages (user messages only, clean text)
  */
@@ -11,3 +17,11 @@ export declare function extractFilesFromMessages(messages: Array<{
     role: string;
     content: unknown;
 }>): string[];
+/**
+ * Extract the last user prompt from messages for semantic search
+ * Returns clean text without system tags
+ */
+export declare function extractLastUserPrompt(messages: Array<{
+    role: string;
+    content: unknown;
+}>): string | undefined;

package/dist/proxy/request-processor.js

@@ -1,33 +1,98 @@
 // Request processor - handles context injection from team memory
 // Reference: plan_proxy_local.md Section 2.1
-import { getTasksForProject, getTasksByFiles, getStepsReasoningByPath, } from '../lib/store.js';
 import { truncate } from '../lib/utils.js';
+import { fetchTeamMemories } from '../lib/api-client.js';
 /**
- * Build context from team memory for injection (PAST sessions only)
- * Queries tasks and file_reasoning tables, excluding current session data
- * @param currentSessionId - Session ID to exclude (ensures only past session data)
+ * Build context from CLOUD team memory for injection
+ * Fetches memories from Supabase via API (cloud-first approach)
+ * Uses hybrid search (semantic + lexical) when userPrompt is provided
+ *
+ * @param teamId - Team UUID from sync configuration
+ * @param projectPath - Project path to filter by
+ * @param mentionedFiles - Files mentioned in user messages (for boost)
+ * @param userPrompt - User's prompt for semantic search (optional)
+ * @returns Formatted context string or null if no memories found
  */
-export function buildTeamMemoryContext(projectPath, mentionedFiles, currentSessionId) {
-    // Get recent completed tasks for this project
-    const tasks = getTasksForProject(projectPath, {
-        status: 'complete',
-        limit: 10,
-    });
-    // Get tasks that touched mentioned files
-    const fileTasks = mentionedFiles.length > 0
-        ? getTasksByFiles(projectPath, mentionedFiles, { status: 'complete', limit: 5 })
-        : [];
-    // Get file-level reasoning from steps table (PAST sessions only)
-    // Pass currentSessionId to exclude current session data
-    const fileReasonings = mentionedFiles.length > 0
-        ? mentionedFiles.flatMap(f => getStepsReasoningByPath(f, 3, currentSessionId))
-        : [];
-    // Combine unique tasks
-    const allTasks = [...new Map([...tasks, ...fileTasks].map(t => [t.id, t])).values()];
-    if (allTasks.length === 0 && fileReasonings.length === 0) {
-        return null;
+export async function buildTeamMemoryContextCloud(teamId, projectPath, mentionedFiles, userPrompt) {
+    const startTime = Date.now();
+    const hasContext = userPrompt && userPrompt.trim().length > 0;
+    console.log(`[CLOUD] ═══════════════════════════════════════════════════════════`);
+    console.log(`[CLOUD] buildTeamMemoryContextCloud START`);
+    console.log(`[CLOUD] Team: ${teamId.substring(0, 8)}...`);
+    console.log(`[CLOUD] Project: ${projectPath}`);
+    console.log(`[CLOUD] Prompt: "${hasContext ? userPrompt.substring(0, 60) + '...' : 'N/A'}"`);
+    console.log(`[CLOUD] Files for boost: ${mentionedFiles.length > 0 ? mentionedFiles.join(', ') : 'none'}`);
+    try {
+        // Fetch memories from cloud API (hybrid search if context provided)
+        const fetchStart = Date.now();
+        const memories = await fetchTeamMemories(teamId, projectPath, {
+            status: 'complete',
+            limit: 5, // Max 5 memories for injection (Convex Combination scoring)
+            files: mentionedFiles.length > 0 ? mentionedFiles : undefined,
+            context: hasContext ? userPrompt : undefined,
+            current_files: mentionedFiles.length > 0 ? mentionedFiles : undefined,
+        });
+        const fetchTime = Date.now() - fetchStart;
+        if (memories.length === 0) {
+            console.log(`[CLOUD] No memories found (fetch took ${fetchTime}ms)`);
+            console.log(`[CLOUD] ═══════════════════════════════════════════════════════════`);
+            return null;
+        }
+        console.log(`[CLOUD] ───────────────────────────────────────────────────────────`);
+        console.log(`[CLOUD] Fetched ${memories.length} memories in ${fetchTime}ms`);
+        console.log(`[CLOUD] ───────────────────────────────────────────────────────────`);
+        // Log each memory with scores (if available from hybrid search)
+        for (let i = 0; i < memories.length; i++) {
+            const mem = memories[i];
+            const semScore = typeof mem.semantic_score === 'number' ? mem.semantic_score.toFixed(3) : '-';
+            const lexScore = typeof mem.lexical_score === 'number' ? mem.lexical_score.toFixed(3) : '-';
+            const combScore = typeof mem.combined_score === 'number' ? mem.combined_score.toFixed(3) : '-';
+            const boosted = mem.file_boost_applied ? '🚀' : '  ';
+            const query = String(memories[i].original_query || '').substring(0, 50);
+            const filesCount = memories[i].files_touched?.length || 0;
+            const reasoningCount = memories[i].reasoning_trace?.length || 0;
+            console.log(`[CLOUD] ${i + 1}. ${boosted} [${combScore}] sem=${semScore} lex=${lexScore} | files=${filesCount} reasoning=${reasoningCount}`);
+            console.log(`[CLOUD]    "${query}..."`);
+        }
+        console.log(`[CLOUD] ───────────────────────────────────────────────────────────`);
+        // Convert Memory[] to Task[] format for the existing formatter
+        const tasks = memories.map(memoryToTask);
+        // Reuse existing formatter (no file-level reasoning from cloud yet)
+        const context = formatTeamMemoryContext(tasks, [], mentionedFiles);
+        // Estimate tokens (~4 chars per token)
+        const estimatedTokens = Math.round(context.length / 4);
+        const totalTime = Date.now() - startTime;
+        console.log(`[CLOUD] Context built: ${context.length} chars (~${estimatedTokens} tokens)`);
+        console.log(`[CLOUD] Total time: ${totalTime}ms (fetch: ${fetchTime}ms, format: ${totalTime - fetchTime}ms)`);
+        console.log(`[CLOUD] ═══════════════════════════════════════════════════════════`);
+        return context;
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+        console.error(`[CLOUD] buildTeamMemoryContextCloud failed: ${errorMsg}`);
+        return null; // Fail silent - don't block Claude Code
     }
-    return formatTeamMemoryContext(allTasks, fileReasonings, mentionedFiles);
+}
+/**
+ * Convert Memory (cloud format) to Task (local format)
+ * Used to reuse existing formatTeamMemoryContext function
+ */
+function memoryToTask(memory) {
+    return {
+        id: memory.id,
+        project_path: memory.project_path,
+        user: memory.user_id || undefined,
+        original_query: memory.original_query,
+        goal: memory.goal || undefined,
+        reasoning_trace: memory.reasoning_trace || [],
+        files_touched: memory.files_touched || [],
+        decisions: memory.decisions || [],
+        constraints: memory.constraints || [],
+        status: memory.status,
+        tags: memory.tags || [],
+        linked_commit: memory.linked_commit || undefined,
+        created_at: memory.created_at,
+    };
 }
 /**
  * Format team memory context for injection
@@ -48,21 +113,44 @@ function formatTeamMemoryContext(tasks, fileReasonings, files) {
         }
         lines.push('');
     }
-    // Task context with decisions and constraints
+    // Task context with knowledge pairs and decisions
+    // Inject up to 5 pairs (10 entries) per task for rich context
     if (tasks.length > 0) {
         lines.push('Related past tasks:');
-        for (const task of tasks.slice(0, 5)) {
+        for (const task of tasks.slice(0, 5)) { // Limit to 5 tasks (Convex Combination top results)
             lines.push(`- ${truncate(task.original_query, 60)}`);
             if (task.files_touched.length > 0) {
-                const fileList = task.files_touched.slice(0, 3).map(f => f.split('/').pop()).join(', ');
+                const fileList = task.files_touched.slice(0, 5).map(f => f.split('/').pop()).join(', ');
                 lines.push(`  Files: ${fileList}`);
             }
+            // Inject knowledge pairs (interleaved: conclusion, insight, conclusion, insight...)
+            // Take up to 5 pairs (10 entries) per task
             if (task.reasoning_trace.length > 0) {
-                lines.push(`  Key: ${truncate(task.reasoning_trace[0], 80)}`);
+                lines.push('  Knowledge:');
+                const maxPairs = 5;
+                const maxEntries = maxPairs * 2; // 10 entries
+                const entries = task.reasoning_trace.slice(0, maxEntries);
+                for (let i = 0; i < entries.length; i += 2) {
+                    const conclusion = entries[i];
+                    const insight = entries[i + 1];
+                    // Format conclusion (remove prefix for brevity)
+                    const cText = conclusion?.replace(/^CONCLUSION:\s*/i, '') || '';
+                    if (cText) {
+                        lines.push(`    • ${truncate(cText, 120)}`);
+                    }
+                    // Format insight (indented under conclusion)
+                    if (insight) {
+                        const iText = insight.replace(/^INSIGHT:\s*/i, '');
+                        lines.push(`      → ${truncate(iText, 100)}`);
+                    }
+                }
             }
-            // Include decisions if available
+            // Include decisions (up to 2 per task)
             if (task.decisions && task.decisions.length > 0) {
-                lines.push(`  Decision: ${task.decisions[0].choice} (${truncate(task.decisions[0].reason, 50)})`);
+                const decisionsToShow = task.decisions.slice(0, 2);
+                for (const decision of decisionsToShow) {
+                    lines.push(`  Decision: ${truncate(decision.choice, 60)} (${truncate(decision.reason, 50)})`);
+                }
             }
             // Include constraints if available
             if (task.constraints && task.constraints.length > 0) {
@@ -120,3 +208,36 @@ export function extractFilesFromMessages(messages) {
     }
     return [...new Set(files)];
 }
+/**
+ * Extract the last user prompt from messages for semantic search
+ * Returns clean text without system tags
+ */
+export function extractLastUserPrompt(messages) {
+    // Find last user message
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role !== 'user')
+            continue;
+        let textContent = '';
+        // Handle string content
+        if (typeof msg.content === 'string') {
+            textContent = msg.content;
+        }
+        // Handle array content (Claude Code API format)
+        if (Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if (block && typeof block === 'object' && 'type' in block && block.type === 'text' && 'text' in block && typeof block.text === 'string') {
+                    textContent += block.text + '\n';
+                }
+            }
+        }
+        // Strip system-reminder tags to get clean user content
+        const cleanContent = textContent
+            .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
+            .trim();
+        if (cleanContent) {
+            return cleanContent;
+        }
+    }
+    return undefined;
+}

package/dist/proxy/response-processor.js

@@ -2,7 +2,80 @@
 // Reference: plan_proxy_local.md Section 4.6
 import { getSessionState, getValidatedSteps, deleteStepsForSession, deleteSessionState, createTask, markTaskSynced, setTaskSyncError, } from '../lib/store.js';
 import { syncTask } from '../lib/cloud-sync.js';
-import { extractReasoning, isLLMAvailable, extractReasoningAndDecisions, isReasoningExtractionAvailable, } from '../lib/llm-extractor.js';
+import { extractReasoningAndDecisions, isReasoningExtractionAvailable, } from '../lib/llm-extractor.js';
+/**
+ * Group steps by reasoning (non-NULL starts a group, NULLs continue it)
+ * Steps from the same Claude response share identical reasoning, stored only on the first.
+ */
+function groupStepsByReasoning(steps) {
+    const groups = [];
+    let currentGroup = null;
+    for (const step of steps) {
+        if (step.reasoning && step.reasoning.length > 0) {
+            // Step with reasoning = start new group
+            if (currentGroup) {
+                groups.push(currentGroup);
+            }
+            currentGroup = {
+                reasoning: step.reasoning,
+                actions: [{
+                        type: step.action_type,
+                        files: step.files || [],
+                        folders: step.folders || [],
+                        command: step.command ?? undefined,
+                    }],
+                allFiles: [...(step.files || [])],
+                allFolders: [...(step.folders || [])],
+            };
+        }
+        else if (currentGroup) {
+            // Step without reasoning = continue current group
+            currentGroup.actions.push({
+                type: step.action_type,
+                files: step.files || [],
+                folders: step.folders || [],
+                command: step.command ?? undefined,
+            });
+            currentGroup.allFiles.push(...(step.files || []));
+            currentGroup.allFolders.push(...(step.folders || []));
+        }
+        // Edge case: step without reasoning and no current group = skip (shouldn't happen with new code)
+    }
+    // Push last group
+    if (currentGroup) {
+        groups.push(currentGroup);
+    }
+    return groups;
+}
+/**
+ * Format grouped steps for Haiku prompt
+ * Provides structured XML with reasoning + associated actions and files
+ */
+function formatGroupsForHaiku(groups) {
+    if (groups.length === 0) {
+        return '';
+    }
+    return groups.map((g, i) => {
+        const actionLines = g.actions.map(a => {
+            let line = `- ${a.type}`;
+            if (a.files.length > 0)
+                line += `: ${a.files.join(', ')}`;
+            if (a.command)
+                line += ` (command: ${a.command.substring(0, 50)})`;
+            return line;
+        }).join('\n');
+        const uniqueFiles = [...new Set(g.allFiles)];
+        return `<response index="${i + 1}">
+<reasoning>
+${g.reasoning}
+</reasoning>
+<actions_performed>
+${actionLines}
+</actions_performed>
+<files_touched>${uniqueFiles.join(', ') || 'none'}</files_touched>
+</response>`;
+    }).join('\n\n###\n\n');
+}
 /**
  * Save session to team memory
  * Called on: task complete, subtask complete, session abandoned
@@ -23,18 +96,24 @@ export async function saveToTeamMemory(sessionId, triggerReason) {
     // Create task in team memory
     const task = createTask(taskData);
     // Fire-and-forget cloud sync; never block capture path
+    // NOTE: Do NOT invalidate cache after sync - cache persists until CLEAR/Summary/restart
+    // Next SESSION will get fresh data, current session keeps its context
     syncTask(task)
         .then((success) => {
         if (success) {
             markTaskSynced(task.id);
+            console.log(`[SYNC] Task ${task.id.substring(0, 8)} synced to cloud`);
         }
         else {
             setTaskSyncError(task.id, 'Sync not enabled or team not configured');
+            console.log(`[SYNC] Task ${task.id.substring(0, 8)} sync skipped (not enabled)`);
         }
     })
         .catch((err) => {
         const message = err instanceof Error ? err.message : 'Unknown sync error';
         setTaskSyncError(task.id, message);
+        console.error(`[SYNC] Task ${task.id.substring(0, 8)} sync failed: ${message}`);
+        // NOTE: Do NOT invalidate cache - data not in cloud
     });
 }
 /**
@@ -72,16 +151,21 @@ async function buildTaskFromSession(sessionState, steps, triggerReason) {
     let constraints = sessionState.constraints || [];
     if (isReasoningExtractionAvailable()) {
         try {
-            // Collect reasoning from steps + final response
-            const stepsReasoning = steps
-                .map(s => s.reasoning)
-                .filter((r) => !!r && r.length > 10);
-            // Include final response (contains the actual analysis/conclusion)
+            // Group steps by reasoning to avoid duplicates and preserve action context
+            const groups = groupStepsByReasoning(steps);
+            let formattedSteps = formatGroupsForHaiku(groups);
+            // Add final_response as separate section if exists and is different from grouped reasoning
             if (sessionState.final_response && sessionState.final_response.length > 100) {
-                stepsReasoning.push(sessionState.final_response);
+                const finalAlreadyIncluded = groups.some(g => g.reasoning.includes(sessionState.final_response.substring(0, 100)));
+                if (!finalAlreadyIncluded) {
+                    if (formattedSteps.length > 0) {
+                        formattedSteps += '\n\n###\n\n';
+                    }
+                    formattedSteps += `<final_response>\n${sessionState.final_response.substring(0, 8000)}\n</final_response>`;
+                }
             }
-            if (stepsReasoning.length > 0) {
-                const extracted = await extractReasoningAndDecisions(stepsReasoning, sessionState.original_goal || '');
+            if (formattedSteps.length > 50) {
+                const extracted = await extractReasoningAndDecisions(formattedSteps, sessionState.original_goal || '');
                 if (extracted.reasoning_trace.length > 0) {
                     reasoningTrace = extracted.reasoning_trace;
                 }
@@ -94,22 +178,6 @@ async function buildTaskFromSession(sessionState, steps, triggerReason) {
             // Fall back to basic extraction
         }
     }
-    else if (isLLMAvailable() && steps.length > 0) {
-        // Fallback to OpenAI-based extraction if Anthropic not available
-        try {
-            const pseudoSession = buildPseudoSession(sessionState, steps);
-            const extracted = await extractReasoning(pseudoSession);
-            if (extracted.decisions.length > 0) {
-                decisions = extracted.decisions;
-            }
-            if (extracted.constraints.length > 0) {
-                constraints = [...new Set([...constraints, ...extracted.constraints])];
-            }
-        }
-        catch {
-            // Fall back to basic extraction
-        }
-    }
     return {
         project_path: sessionState.project_path,
         user: sessionState.user_id,
@@ -123,26 +191,6 @@ async function buildTaskFromSession(sessionState, steps, triggerReason) {
         trigger_reason: triggerReason,
     };
 }
-/**
- * Build pseudo ParsedSession for LLM extraction
- */
-function buildPseudoSession(sessionState, steps) {
-    return {
-        sessionId: sessionState.session_id,
-        projectPath: sessionState.project_path,
-        startTime: sessionState.start_time,
-        endTime: sessionState.last_update,
-        userMessages: [sessionState.original_goal || ''],
-        assistantMessages: steps.map(s => `[${s.action_type}] ${s.files.join(', ')}`),
-        toolCalls: steps.map(s => ({
-            name: s.action_type,
-            input: { files: s.files, command: s.command },
-        })),
-        filesRead: steps.filter(s => s.action_type === 'read').flatMap(s => s.files),
-        filesWritten: steps.filter(s => s.action_type === 'write' || s.action_type === 'edit').flatMap(s => s.files),
-        rawEntries: [],
-    };
-}
 /**
  * Clean up session data after save
  */

package/dist/proxy/server.d.ts

@@ -1,5 +1,4 @@
 import { FastifyInstance } from 'fastify';
-export declare function setDebugMode(enabled: boolean): void;
 /**
  * Create and configure the Fastify server
  */