grov 0.5.2 → 0.5.3

package/dist/proxy/cache.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Global team memory cache
+ * - Calculated ONCE on first request, reused for ALL subsequent requests
+ * - Invalidated only on: sync completion (in .then() callback), proxy restart
+ * - Ensures system prompt prefix stays CONSTANT for Anthropic cache preservation
+ */
+export declare let globalTeamMemoryCache: {
+    projectPath: string;
+    content: string;
+} | null;
+/**
+ * Invalidate the global team memory cache
+ * Called after successful sync to cloud (in .then() callback)
+ * This ensures cache is only invalidated AFTER data is in cloud
+ */
+export declare function invalidateTeamMemoryCache(): void;
+/**
+ * Set the global team memory cache
+ * @param projectPath - Project path for cache key
+ * @param content - Formatted team memory content
+ */
+export declare function setTeamMemoryCache(projectPath: string, content: string): void;
+/**
+ * Get the current cache content if it matches the project path
+ * @param projectPath - Project path to check
+ * @returns Cached content or null if not cached/different project
+ */
+export declare function getTeamMemoryCache(projectPath: string): string | null;
+/**
+ * Check if cache exists for a specific project
+ */
+export declare function hasCacheForProject(projectPath: string): boolean;
+/**
+ * Get current cache project path (for logging/debugging)
+ */
+export declare function getCacheProjectPath(): string | null;

package/dist/proxy/cache.js

@@ -0,0 +1,51 @@
+// Phase 0 verified
+// Cache management for team memory injection
+// Shared between server.ts and response-processor.ts to avoid circular dependencies
+/**
+ * Global team memory cache
+ * - Calculated ONCE on first request, reused for ALL subsequent requests
+ * - Invalidated only on: sync completion (in .then() callback), proxy restart
+ * - Ensures system prompt prefix stays CONSTANT for Anthropic cache preservation
+ */
+export let globalTeamMemoryCache = null;
+/**
+ * Invalidate the global team memory cache
+ * Called after successful sync to cloud (in .then() callback)
+ * This ensures cache is only invalidated AFTER data is in cloud
+ */
+export function invalidateTeamMemoryCache() {
+    globalTeamMemoryCache = null;
+    console.log('[CACHE] Team memory cache invalidated');
+}
+/**
+ * Set the global team memory cache
+ * @param projectPath - Project path for cache key
+ * @param content - Formatted team memory content
+ */
+export function setTeamMemoryCache(projectPath, content) {
+    globalTeamMemoryCache = { projectPath, content };
+    console.log(`[CACHE] Team memory cache set for project: ${projectPath} (${content.length} chars)`);
+}
+/**
+ * Get the current cache content if it matches the project path
+ * @param projectPath - Project path to check
+ * @returns Cached content or null if not cached/different project
+ */
+export function getTeamMemoryCache(projectPath) {
+    if (globalTeamMemoryCache && globalTeamMemoryCache.projectPath === projectPath) {
+        return globalTeamMemoryCache.content;
+    }
+    return null;
+}
+/**
+ * Check if cache exists for a specific project
+ */
+export function hasCacheForProject(projectPath) {
+    return globalTeamMemoryCache?.projectPath === projectPath;
+}
+/**
+ * Get current cache project path (for logging/debugging)
+ */
+export function getCacheProjectPath() {
+    return globalTeamMemoryCache?.projectPath || null;
+}

package/dist/proxy/config.d.ts

@@ -12,6 +12,7 @@ export declare const config: {
     ENABLE_TLS: boolean;
     LOG_LEVEL: string;
     LOG_REQUESTS: boolean;
+    EXTENDED_CACHE_ENABLED: boolean;
 };
 export declare const FORWARD_HEADERS: string[];
 export declare const SENSITIVE_HEADERS: string[];

package/dist/proxy/config.js

@@ -19,6 +19,8 @@ export const config = {
     // Logging
     LOG_LEVEL: process.env.LOG_LEVEL || 'info',
     LOG_REQUESTS: process.env.LOG_REQUESTS !== 'false',
+    // Extended Cache - preserve Anthropic prompt cache during idle
+    EXTENDED_CACHE_ENABLED: process.env.GROV_EXTENDED_CACHE === 'true',
 };
 // Headers to forward to Anthropic (whitelist approach)
 export const FORWARD_HEADERS = [

package/dist/proxy/extended-cache.d.ts

@@ -0,0 +1,10 @@
+export interface ExtendedCacheEntry {
+    headers: Record<string, string>;
+    rawBody: Buffer;
+    timestamp: number;
+    keepAliveCount: number;
+}
+export declare const extendedCache: Map<string, ExtendedCacheEntry>;
+export declare function log(msg: string): void;
+export declare function evictOldestCacheEntry(): void;
+export declare function checkExtendedCache(): Promise<void>;

package/dist/proxy/extended-cache.js

@@ -0,0 +1,155 @@
+// Extended Cache - Keep Anthropic cache alive during idle
+// Sends minimal keep-alive requests to prevent cache TTL expiration
+import { forwardToAnthropic } from './forwarder.js';
+export const extendedCache = new Map();
+// Timing constants
+const EXTENDED_CACHE_IDLE_THRESHOLD = 4 * 60 * 1000; // 4 minutes (under 5-min TTL)
+const EXTENDED_CACHE_MAX_IDLE = 10 * 60 * 1000; // 10 minutes total
+const EXTENDED_CACHE_MAX_KEEPALIVES = 2;
+const EXTENDED_CACHE_MAX_ENTRIES = 100; // Max concurrent sessions (memory cap)
+export function log(msg) {
+    console.log(`[CACHE] ${msg}`);
+}
+export function evictOldestCacheEntry() {
+    if (extendedCache.size < EXTENDED_CACHE_MAX_ENTRIES)
+        return;
+    let oldestId = null;
+    let oldestTime = Infinity;
+    for (const [id, entry] of extendedCache) {
+        if (entry.timestamp < oldestTime) {
+            oldestTime = entry.timestamp;
+            oldestId = id;
+        }
+    }
+    if (oldestId) {
+        extendedCache.delete(oldestId);
+        log(`Extended cache: evicted ${oldestId.substring(0, 8)} (capacity limit)`);
+    }
+}
+async function sendExtendedCacheKeepAlive(projectPath, entry) {
+    const projectName = projectPath.split('/').pop() || projectPath;
+    let rawBodyStr = entry.rawBody.toString('utf-8');
+    // 1. Find messages array and add "." message before closing bracket
+    const messagesMatch = rawBodyStr.match(/"messages"\s*:\s*\[/);
+    if (!messagesMatch || messagesMatch.index === undefined) {
+        throw new Error('Cannot find messages array in rawBody');
+    }
+    // Find closing bracket of messages array (handling nested arrays/objects)
+    const messagesStart = messagesMatch.index + messagesMatch[0].length;
+    let bracketDepth = 1; // We're inside the [ already
+    let braceDepth = 0; // Track {} for objects
+    let inString = false; // Track if we're inside a string
+    let messagesEnd = messagesStart;
+    for (let i = messagesStart; i < rawBodyStr.length && bracketDepth > 0; i++) {
+        const char = rawBodyStr[i];
+        const prevChar = i > 0 ? rawBodyStr[i - 1] : '';
+        // Handle string boundaries (skip escaped quotes)
+        if (char === '"' && prevChar !== '\\') {
+            inString = !inString;
+            continue;
+        }
+        // Skip everything inside strings
+        if (inString)
+            continue;
+        // Track brackets and braces
+        if (char === '[')
+            bracketDepth++;
+        else if (char === ']')
+            bracketDepth--;
+        else if (char === '{')
+            braceDepth++;
+        else if (char === '}')
+            braceDepth--;
+        // Found the closing bracket of messages array
+        if (bracketDepth === 0) {
+            messagesEnd = i;
+            break;
+        }
+    }
+    // Safety check: did we find the end?
+    if (bracketDepth !== 0) {
+        throw new Error(`Could not find closing bracket of messages array (depth=${bracketDepth})`);
+    }
+    // Check if array has content (anything between messagesStart and messagesEnd)
+    const arrayContent = rawBodyStr.slice(messagesStart, messagesEnd).trim();
+    const messagesIsEmpty = arrayContent.length === 0;
+    // Insert minimal user message before closing bracket
+    const keepAliveMsg = messagesIsEmpty
+        ? '{"role":"user","content":"."}'
+        : ',{"role":"user","content":"."}';
+    log(`Extended cache: SEND keep-alive project=${projectName} msg_array_size=${messagesEnd - messagesStart}`);
+    rawBodyStr = rawBodyStr.slice(0, messagesEnd) + keepAliveMsg + rawBodyStr.slice(messagesEnd);
+    // NOTE: We do NOT modify max_tokens or stream!
+    // Keeping them identical preserves the cache prefix for byte-exact matching.
+    // Claude will respond briefly to "." anyway, and forwarder handles streaming.
+    // 2. Validate JSON after manipulation
+    try {
+        JSON.parse(rawBodyStr);
+    }
+    catch (e) {
+        throw new Error(`Invalid JSON after modifications: ${e instanceof Error ? e.message : 'unknown'}`);
+    }
+    // 3. Forward to Anthropic using same undici path as regular requests
+    const result = await forwardToAnthropic({}, entry.headers, undefined, Buffer.from(rawBodyStr, 'utf-8'));
+    if (result.statusCode !== 200) {
+        throw new Error(`Keep-alive failed: ${result.statusCode}`);
+    }
+    // Log cache metrics
+    const usage = result.body.usage;
+    const cacheRead = usage?.cache_read_input_tokens || 0;
+    const cacheCreate = usage?.cache_creation_input_tokens || 0;
+    const inputTokens = usage?.input_tokens || 0;
+    log(`Extended cache: keep-alive for ${projectName} - cache_read=${cacheRead}, cache_create=${cacheCreate}, input=${inputTokens}`);
+}
+export async function checkExtendedCache() {
+    const now = Date.now();
+    const projectsToKeepAlive = [];
+    // First pass: cleanup stale/maxed entries, collect projects needing keep-alive
+    for (const [projectPath, entry] of extendedCache) {
+        const idleTime = now - entry.timestamp;
+        const projectName = projectPath.split('/').pop() || projectPath;
+        // Stale cleanup: user left after 10 minutes
+        if (idleTime > EXTENDED_CACHE_MAX_IDLE) {
+            extendedCache.delete(projectPath);
+            log(`Extended cache: cleared ${projectName} (stale)`);
+            continue;
+        }
+        // Skip if not idle enough yet
+        if (idleTime < EXTENDED_CACHE_IDLE_THRESHOLD) {
+            continue;
+        }
+        // Skip if already sent max keep-alives
+        if (entry.keepAliveCount >= EXTENDED_CACHE_MAX_KEEPALIVES) {
+            extendedCache.delete(projectPath);
+            log(`Extended cache: cleared ${projectName} (max retries)`);
+            continue;
+        }
+        projectsToKeepAlive.push({ projectPath, entry });
+    }
+    // Second pass: send all keep-alives in PARALLEL
+    const keepAlivePromises = [];
+    for (const { projectPath, entry } of projectsToKeepAlive) {
+        const projectName = projectPath.split('/').pop() || projectPath;
+        const promise = sendExtendedCacheKeepAlive(projectPath, entry)
+            .then(() => {
+            entry.timestamp = Date.now();
+            entry.keepAliveCount++;
+        })
+            .catch((err) => {
+            extendedCache.delete(projectPath);
+            // Handle both Error instances and ForwardError objects
+            const errMsg = err instanceof Error
+                ? err.message
+                : (err && typeof err === 'object' && 'message' in err)
+                    ? String(err.message)
+                    : JSON.stringify(err);
+            const errType = err && typeof err === 'object' && 'type' in err ? ` [${err.type}]` : '';
+            log(`Extended cache: cleared ${projectName} (error${errType}: ${errMsg})`);
+        });
+        keepAlivePromises.push(promise);
+    }
+    // Wait for all keep-alives to complete
+    if (keepAlivePromises.length > 0) {
+        await Promise.all(keepAlivePromises);
+    }
+}

package/dist/proxy/handlers/preprocess.d.ts

@@ -0,0 +1,20 @@
+import type { MessagesRequestBody } from '../types.js';
+export declare function getPendingPlanClear(): {
+    projectPath: string;
+    summary: string;
+} | null;
+export declare function setPendingPlanClear(value: {
+    projectPath: string;
+    summary: string;
+}): void;
+export declare function clearPendingPlan(): void;
+export declare function preProcessRequest(body: MessagesRequestBody, sessionInfo: {
+    sessionId: string;
+    promptCount: number;
+    projectPath: string;
+}, logger: {
+    info: (data: Record<string, unknown>) => void;
+}, detectRequestType: (messages: Array<{
+    role: string;
+    content: unknown;
+}>, projectPath: string) => 'first' | 'continuation' | 'retry'): Promise<MessagesRequestBody>;

package/dist/proxy/handlers/preprocess.js

@@ -0,0 +1,169 @@
+// Pre-process requests before forwarding to Anthropic
+import { config } from '../config.js';
+import { extractLastUserPrompt, extractFilesFromMessages, buildTeamMemoryContextCloud } from '../request-processor.js';
+import { getSessionState, updateSessionState, markCleared, } from '../../lib/store.js';
+import { isSyncEnabled, getSyncTeamId } from '../../lib/cloud-sync.js';
+import { globalTeamMemoryCache, setTeamMemoryCache, invalidateTeamMemoryCache } from '../cache.js';
+import { buildDynamicInjection, clearSessionTracking } from '../injection/delta-tracking.js';
+import { appendToSystemPrompt } from '../injection/injectors.js';
+// Pending plan summary state - triggers CLEAR-like reset after planning task completes
+let pendingPlanClear = null;
+export function getPendingPlanClear() {
+    return pendingPlanClear;
+}
+export function setPendingPlanClear(value) {
+    pendingPlanClear = value;
+}
+export function clearPendingPlan() {
+    pendingPlanClear = null;
+}
+export async function preProcessRequest(body, sessionInfo, logger, detectRequestType) {
+    const modified = { ...body };
+    // Skip warmup requests - Claude Code sends "Warmup" as health check
+    // No need to do semantic search or cache operations for these
+    const earlyUserPrompt = extractLastUserPrompt(modified.messages || []);
+    if (earlyUserPrompt === 'Warmup') {
+        console.log('[INJECT] Skipping warmup request (no search, no cache)');
+        return modified;
+    }
+    // Detect request type: first, continuation, or retry
+    const requestType = detectRequestType(modified.messages || [], sessionInfo.projectPath);
+    // === NEW ARCHITECTURE: Separate static and dynamic injection ===
+    //
+    // STATIC (system prompt, cached):
+    //   - Team memory from PAST sessions only
+    //   - CLEAR summary when triggered
+    //   -> Uses __grovInjection + injectIntoRawBody()
+    //
+    // DYNAMIC (user message, delta only):
+    //   - Files edited in current session
+    //   - Key decisions with reasoning
+    //   - Drift correction, forced recovery
+    //   -> Uses __grovUserMsgInjection + appendToLastUserMessage()
+    // Get session state
+    const sessionState = getSessionState(sessionInfo.sessionId);
+    // === PLANNING CLEAR: Reset after planning task completes ===
+    // This ensures implementation phase starts fresh with planning context from team memory
+    if (pendingPlanClear && pendingPlanClear.projectPath === sessionInfo.projectPath) {
+        // 1. Empty messages array (fresh start)
+        modified.messages = [];
+        // 2. Inject planning summary into system prompt
+        appendToSystemPrompt(modified, pendingPlanClear.summary);
+        // 3. Rebuild team memory NOW (includes the just-saved planning task)
+        const mentionedFiles = extractFilesFromMessages(modified.messages || []);
+        const userPrompt = extractLastUserPrompt(modified.messages || []);
+        // Use cloud-first approach if sync is enabled
+        let teamContext = null;
+        const teamId = getSyncTeamId();
+        if (isSyncEnabled() && teamId) {
+            console.log(`[INJECT] PLANNING_CLEAR: Using cloud team memory (teamId=${teamId.substring(0, 8)}...)`);
+            teamContext = await buildTeamMemoryContextCloud(teamId, sessionInfo.projectPath, mentionedFiles, userPrompt // For hybrid semantic search
+            );
+        }
+        else {
+            // Sync not enabled - no injection (cloud-first approach)
+            console.log('[INJECT] Sync not enabled. Enable sync for team memory injection.');
+            teamContext = null;
+        }
+        if (teamContext) {
+            modified.__grovInjection = teamContext;
+            modified.__grovInjectionCached = false;
+            // Update cache with fresh team memory
+            setTeamMemoryCache(sessionInfo.projectPath, teamContext);
+        }
+        // 4. Clear the pending plan (one-time use)
+        pendingPlanClear = null;
+        // 5. Clear tracking (fresh start)
+        clearSessionTracking(sessionInfo.sessionId);
+        return modified; // Skip other injections - this is a complete reset
+    }
+    // === CLEAR MODE (100% threshold) ===
+    // If token count exceeds threshold AND we have a pre-computed summary, apply CLEAR
+    if (sessionState) {
+        const currentTokenCount = sessionState.token_count || 0;
+        if (currentTokenCount > config.TOKEN_CLEAR_THRESHOLD &&
+            sessionState.pending_clear_summary) {
+            logger.info({
+                msg: 'CLEAR MODE ACTIVATED - resetting conversation',
+                tokenCount: currentTokenCount,
+                threshold: config.TOKEN_CLEAR_THRESHOLD,
+                summaryLength: sessionState.pending_clear_summary.length,
+            });
+            // 1. Empty messages array (fundamental reset)
+            modified.messages = [];
+            // 2. Inject summary into system prompt (this will cause cache miss - intentional)
+            appendToSystemPrompt(modified, sessionState.pending_clear_summary);
+            // 3. Mark session as cleared
+            markCleared(sessionInfo.sessionId);
+            // 4. Clear pending summary and invalidate GLOBAL team memory cache (new baseline)
+            updateSessionState(sessionInfo.sessionId, { pending_clear_summary: undefined });
+            invalidateTeamMemoryCache(); // Force recalculation on next request (CLEAR mode)
+            // 5. Clear tracking (fresh start after CLEAR)
+            clearSessionTracking(sessionInfo.sessionId);
+            logger.info({ msg: 'CLEAR complete - conversation reset with summary' });
+            return modified; // Skip other injections - this is a complete reset
+        }
+    }
+    // === STATIC INJECTION: Team memory (PAST sessions only) ===
+    // Cached per session - identical across all requests for cache preservation
+    // GLOBAL cache: same team memory for ALL requests (regardless of sessionId changes)
+    // Only recalculate on: first request ever, CLEAR/Summary, project change, proxy restart
+    const isSameProject = globalTeamMemoryCache?.projectPath === sessionInfo.projectPath;
+    if (globalTeamMemoryCache && isSameProject) {
+        // Reuse GLOBAL cached team memory (constant for entire conversation)
+        modified.__grovInjection = globalTeamMemoryCache.content;
+        modified.__grovInjectionCached = true;
+        console.log(`[CACHE] Using global team memory cache, size=${globalTeamMemoryCache.content.length}`);
+    }
+    else {
+        // First request OR project changed OR cache was invalidated: compute team memory
+        const mentionedFiles = extractFilesFromMessages(modified.messages || []);
+        const userPrompt = extractLastUserPrompt(modified.messages || []);
+        // Use cloud-first approach if sync is enabled
+        let teamContext = null;
+        const teamId = getSyncTeamId();
+        if (isSyncEnabled() && teamId) {
+            console.log(`[INJECT] First/cache miss: Using cloud team memory (teamId=${teamId.substring(0, 8)}...)`);
+            teamContext = await buildTeamMemoryContextCloud(teamId, sessionInfo.projectPath, mentionedFiles, userPrompt // For hybrid semantic search
+            );
+        }
+        else {
+            // Sync not enabled - no injection (cloud-first approach)
+            console.log('[INJECT] Sync not enabled. Enable sync for team memory injection.');
+            teamContext = null;
+        }
+        console.log(`[CACHE] Computing team memory (first/new), files=${mentionedFiles.length}, result=${teamContext ? teamContext.length : 'null'}`);
+        if (teamContext) {
+            modified.__grovInjection = teamContext;
+            modified.__grovInjectionCached = false;
+            // Store in GLOBAL cache - stays constant until CLEAR or restart
+            setTeamMemoryCache(sessionInfo.projectPath, teamContext);
+        }
+        else {
+            // No team memory available - clear global cache for this project
+            if (isSameProject) {
+                invalidateTeamMemoryCache();
+            }
+        }
+    }
+    // SKIP dynamic injection for retries and continuations
+    if (requestType !== 'first') {
+        return modified;
+    }
+    // === DYNAMIC INJECTION: User message (delta only) ===
+    // Includes: edited files, key decisions, drift correction, forced recovery
+    // This goes into the LAST user message, not system prompt
+    const dynamicInjection = buildDynamicInjection(sessionInfo.sessionId, sessionState, logger);
+    if (dynamicInjection) {
+        modified.__grovUserMsgInjection = dynamicInjection;
+        logger.info({ msg: 'Dynamic injection ready for user message', size: dynamicInjection.length });
+        // Clear pending corrections after building injection
+        if (sessionState?.pending_correction || sessionState?.pending_forced_recovery) {
+            updateSessionState(sessionInfo.sessionId, {
+                pending_correction: undefined,
+                pending_forced_recovery: undefined,
+            });
+        }
+    }
+    return modified;
+}

package/dist/proxy/injection/delta-tracking.d.ts

@@ -0,0 +1,11 @@
+import type { SessionState } from '../../lib/store.js';
+export interface SessionInjectionTracking {
+    files: Set<string>;
+    decisionIds: Set<string>;
+    reasonings: Set<string>;
+}
+export declare function getOrCreateTracking(sessionId: string): SessionInjectionTracking;
+export declare function clearSessionTracking(sessionId: string): void;
+export declare function buildDynamicInjection(sessionId: string, sessionState: SessionState | null, logger?: {
+    info: (data: Record<string, unknown>) => void;
+}): string | null;

package/dist/proxy/injection/delta-tracking.js

@@ -0,0 +1,93 @@
+// Delta tracking - avoid duplicate injections across requests
+import { getEditedFiles, getKeyDecisions } from '../../lib/store.js';
+import { smartTruncate } from '../../lib/utils.js';
+const sessionInjectionTracking = new Map();
+export function getOrCreateTracking(sessionId) {
+    if (!sessionInjectionTracking.has(sessionId)) {
+        sessionInjectionTracking.set(sessionId, {
+            files: new Set(),
+            decisionIds: new Set(),
+            reasonings: new Set(),
+        });
+    }
+    return sessionInjectionTracking.get(sessionId);
+}
+export function clearSessionTracking(sessionId) {
+    sessionInjectionTracking.delete(sessionId);
+}
+export function buildDynamicInjection(sessionId, sessionState, logger) {
+    const tracking = getOrCreateTracking(sessionId);
+    const parts = [];
+    const debugInfo = {};
+    // 1. Get edited files (delta - not already injected)
+    const allEditedFiles = getEditedFiles(sessionId);
+    const newFiles = allEditedFiles.filter(f => !tracking.files.has(f));
+    debugInfo.totalEditedFiles = allEditedFiles.length;
+    debugInfo.newEditedFiles = newFiles.length;
+    debugInfo.alreadyTrackedFiles = tracking.files.size;
+    if (newFiles.length > 0) {
+        // Track and add to injection
+        newFiles.forEach(f => tracking.files.add(f));
+        const fileNames = newFiles.slice(0, 5).map(f => f.split('/').pop());
+        parts.push(`[EDITED: ${fileNames.join(', ')}]`);
+        debugInfo.editedFilesInjected = fileNames;
+    }
+    // 2. Get key decisions with reasoning (delta - not already injected)
+    const keyDecisions = getKeyDecisions(sessionId, 5);
+    debugInfo.totalKeyDecisions = keyDecisions.length;
+    debugInfo.alreadyTrackedDecisions = tracking.decisionIds.size;
+    const newDecisions = keyDecisions.filter(d => !tracking.decisionIds.has(d.id) &&
+        d.reasoning &&
+        !tracking.reasonings.has(d.reasoning));
+    debugInfo.newKeyDecisions = newDecisions.length;
+    for (const decision of newDecisions.slice(0, 3)) {
+        tracking.decisionIds.add(decision.id);
+        tracking.reasonings.add(decision.reasoning);
+        const truncated = smartTruncate(decision.reasoning, 120);
+        parts.push(`[DECISION: ${truncated}]`);
+        // Log the original and truncated reasoning for debugging
+        if (logger) {
+            logger.info({
+                msg: 'Key decision reasoning extracted',
+                originalLength: decision.reasoning.length,
+                truncatedLength: truncated.length,
+                original: decision.reasoning.substring(0, 200) + (decision.reasoning.length > 200 ? '...' : ''),
+                truncated,
+            });
+        }
+    }
+    debugInfo.decisionsInjected = newDecisions.slice(0, 3).length;
+    // 3. Add drift correction if pending
+    if (sessionState?.pending_correction) {
+        parts.push(`[DRIFT: ${sessionState.pending_correction}]`);
+        debugInfo.hasDriftCorrection = true;
+        debugInfo.driftCorrectionLength = sessionState.pending_correction.length;
+    }
+    // 4. Add forced recovery if pending
+    if (sessionState?.pending_forced_recovery) {
+        parts.push(`[RECOVERY: ${sessionState.pending_forced_recovery}]`);
+        debugInfo.hasForcedRecovery = true;
+        debugInfo.forcedRecoveryLength = sessionState.pending_forced_recovery.length;
+    }
+    // Log debug info
+    if (logger) {
+        logger.info({
+            msg: 'Dynamic injection build details',
+            ...debugInfo,
+            partsCount: parts.length,
+        });
+    }
+    if (parts.length === 0) {
+        return null;
+    }
+    const injection = '---\n[GROV CONTEXT]\n' + parts.join('\n');
+    // Log final injection content
+    if (logger) {
+        logger.info({
+            msg: 'Dynamic injection content',
+            size: injection.length,
+            content: injection,
+        });
+    }
+    return injection;
+}

package/dist/proxy/injection/injectors.d.ts

@@ -0,0 +1,7 @@
+import type { MessagesRequestBody } from '../types.js';
+export declare function appendToLastUserMessage(rawBody: string, injection: string): string;
+export declare function appendToSystemPrompt(body: MessagesRequestBody, textToAppend: string): void;
+export declare function injectIntoRawBody(rawBody: string, injectionText: string): {
+    modified: string;
+    success: boolean;
+};