grov 0.5.11 → 0.6.13

package/dist/integrations/proxy/agents/codex/patch.js

@@ -0,0 +1,40 @@
+// Parse Codex apply_patch format to extract file operations
+const ADD_FILE_PREFIX = '*** Add File: ';
+const UPDATE_FILE_PREFIX = '*** Update File: ';
+const DELETE_FILE_PREFIX = '*** Delete File: ';
+const MOVE_TO_PREFIX = '*** Move to: ';
+export function parsePatchContent(patchText) {
+    const files = [];
+    const operations = [];
+    let hasAdd = false;
+    let hasDelete = false;
+    let currentOp = null;
+    for (const line of patchText.split('\n')) {
+        if (line.startsWith(ADD_FILE_PREFIX)) {
+            const file = line.slice(ADD_FILE_PREFIX.length).trim();
+            files.push(file);
+            hasAdd = true;
+            currentOp = { type: 'add', file };
+            operations.push(currentOp);
+        }
+        else if (line.startsWith(UPDATE_FILE_PREFIX)) {
+            const file = line.slice(UPDATE_FILE_PREFIX.length).trim();
+            files.push(file);
+            currentOp = { type: 'update', file };
+            operations.push(currentOp);
+        }
+        else if (line.startsWith(DELETE_FILE_PREFIX)) {
+            const file = line.slice(DELETE_FILE_PREFIX.length).trim();
+            files.push(file);
+            hasDelete = true;
+            currentOp = { type: 'delete', file };
+            operations.push(currentOp);
+        }
+        else if (line.startsWith(MOVE_TO_PREFIX) && currentOp) {
+            const moveTo = line.slice(MOVE_TO_PREFIX.length).trim();
+            currentOp.moveTo = moveTo;
+            files.push(moveTo);
+        }
+    }
+    return { files: [...new Set(files)], operations, hasAdd, hasDelete };
+}

package/dist/integrations/proxy/agents/codex/settings.d.ts

@@ -0,0 +1,18 @@
+interface ModelProvider {
+    name: string;
+    base_url: string;
+    env_key: string;
+    wire_api: 'responses' | 'chat';
+    query_params?: Record<string, string>;
+    http_headers?: Record<string, string>;
+}
+interface CodexConfig {
+    model_providers?: Record<string, ModelProvider>;
+    [key: string]: unknown;
+}
+export declare function getSettingsPath(): string;
+export declare function readCodexConfig(): CodexConfig;
+export declare function setProxyEnv(enable: boolean): {
+    action: 'added' | 'removed' | 'unchanged';
+};
+export {};

package/dist/integrations/proxy/agents/codex/settings.js

@@ -0,0 +1,73 @@
+// Codex CLI settings management (~/.codex/config.toml)
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { parse, stringify } from 'smol-toml';
+const CODEX_DIR = join(homedir(), '.codex');
+const CONFIG_PATH = join(CODEX_DIR, 'config.toml');
+const PROXY_URL = 'http://127.0.0.1:8080/v1';
+export function getSettingsPath() {
+    return CONFIG_PATH;
+}
+export function readCodexConfig() {
+    if (!existsSync(CONFIG_PATH)) {
+        return {};
+    }
+    try {
+        const content = readFileSync(CONFIG_PATH, 'utf-8');
+        return parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+function writeCodexConfig(config) {
+    if (!existsSync(CODEX_DIR)) {
+        mkdirSync(CODEX_DIR, { recursive: true, mode: 0o700 });
+    }
+    writeFileSync(CONFIG_PATH, stringify(config), { mode: 0o600 });
+}
+export function setProxyEnv(enable) {
+    const config = readCodexConfig();
+    if (enable) {
+        if (!config.model_providers) {
+            config.model_providers = {};
+        }
+        const alreadyConfigured = config.model_providers.grov?.base_url === PROXY_URL &&
+            config.model_provider === 'grov';
+        if (alreadyConfigured) {
+            return { action: 'unchanged' };
+        }
+        // Store original provider to restore on disable
+        if (config.model_provider && config.model_provider !== 'grov') {
+            config._grov_original_provider = config.model_provider;
+        }
+        config.model_providers.grov = {
+            name: 'Grov Memory Proxy',
+            base_url: PROXY_URL,
+            env_key: 'OPENAI_API_KEY',
+            wire_api: 'responses',
+        };
+        // Tell Codex to use the grov provider
+        config.model_provider = 'grov';
+        writeCodexConfig(config);
+        return { action: 'added' };
+    }
+    if (!config.model_providers?.grov) {
+        return { action: 'unchanged' };
+    }
+    delete config.model_providers.grov;
+    // Restore original provider or remove the setting
+    if (config._grov_original_provider) {
+        config.model_provider = config._grov_original_provider;
+        delete config._grov_original_provider;
+    }
+    else {
+        delete config.model_provider;
+    }
+    if (Object.keys(config.model_providers).length === 0) {
+        delete config.model_providers;
+    }
+    writeCodexConfig(config);
+    return { action: 'removed' };
+}

package/dist/integrations/proxy/agents/codex/types.d.ts

@@ -0,0 +1,59 @@
+export interface CodexRequestBody {
+    model: string;
+    instructions?: string;
+    input: CodexInputItem[];
+    previous_response_id?: string;
+    stream?: boolean;
+    tools?: CodexTool[];
+    parallel_tool_calls?: boolean;
+}
+export type CodexInputItem = {
+    role: 'user' | 'assistant';
+    content: string | Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+} | {
+    type: 'function_call_output';
+    call_id: string;
+    output: string;
+};
+export interface CodexTool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+export interface CodexResponse {
+    id: string;
+    status: 'completed' | 'failed' | 'in_progress';
+    output: CodexOutputItem[];
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens?: number;
+    };
+}
+export type CodexOutputItem = {
+    type: 'message';
+    role: 'assistant';
+    content: CodexMessageContent[];
+} | CodexFunctionCall;
+export interface CodexMessageContent {
+    type: 'output_text';
+    text: string;
+}
+export interface CodexFunctionCall {
+    type: 'function_call';
+    call_id: string;
+    name: string;
+    arguments: string;
+}
+export interface ShellArguments {
+    command: string[];
+    workdir: string;
+    timeout?: number;
+}

package/dist/integrations/proxy/agents/codex/types.js

@@ -0,0 +1,2 @@
+// Codex API request and response type definitions
+export {};

package/dist/integrations/proxy/agents/index.d.ts

@@ -0,0 +1,11 @@
+import type { FastifyRequest } from 'fastify';
+import type { AgentAdapter, AgentName } from './types.js';
+export declare function getAllAgents(): AgentAdapter[];
+export declare function getAgentForRequest(request: FastifyRequest): AgentAdapter | undefined;
+export declare function getAgentByName(name: AgentName): AgentAdapter | undefined;
+export declare function getAgentByEndpoint(endpoint: string): AgentAdapter | undefined;
+export declare function getSupportedEndpoints(): string[];
+export { ClaudeAdapter } from './claude/index.js';
+export { CodexAdapter } from './codex/index.js';
+export { BaseAdapter } from './base.js';
+export type { AgentAdapter, AgentName, AgentSettings, NormalizedAction, ForwardResult, TokenUsage, ToolUseBlock, } from './types.js';

package/dist/integrations/proxy/agents/index.js

@@ -0,0 +1,25 @@
+// Agent registry - detects and provides agent adapters
+import { ClaudeAdapter } from './claude/index.js';
+import { CodexAdapter } from './codex/index.js';
+const adapters = [
+    new ClaudeAdapter(),
+    new CodexAdapter(),
+];
+export function getAllAgents() {
+    return adapters;
+}
+export function getAgentForRequest(request) {
+    return adapters.find(adapter => adapter.canHandle(request));
+}
+export function getAgentByName(name) {
+    return adapters.find(adapter => adapter.name === name);
+}
+export function getAgentByEndpoint(endpoint) {
+    return adapters.find(adapter => adapter.endpoint === endpoint);
+}
+export function getSupportedEndpoints() {
+    return adapters.map(adapter => adapter.endpoint);
+}
+export { ClaudeAdapter } from './claude/index.js';
+export { CodexAdapter } from './codex/index.js';
+export { BaseAdapter } from './base.js';

package/dist/integrations/proxy/agents/types.d.ts

@@ -0,0 +1,77 @@
+import type { FastifyRequest } from 'fastify';
+import type { StepActionType } from '../../../core/store/store.js';
+import type { ConversationMessage } from '../../../core/extraction/llm-extractor.js';
+export type AgentName = 'claude' | 'codex' | 'gemini';
+export interface NormalizedAction {
+    toolName: string;
+    actionType: StepActionType;
+    sourceAgent: AgentName;
+    files: string[];
+    folders: string[];
+    command?: string;
+    rawInput: unknown;
+}
+export interface ForwardResult {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: unknown;
+    rawBody: string;
+    wasSSE?: boolean;
+}
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cacheCreation: number;
+    cacheRead: number;
+}
+export interface ToolUseBlock {
+    id: string;
+    name: string;
+    input: unknown;
+}
+export interface AgentSettings {
+    getConfigPath(): string;
+    setProxyEnabled(enabled: boolean): {
+        action: 'added' | 'removed' | 'unchanged';
+    };
+}
+export interface AgentAdapter {
+    readonly name: AgentName;
+    readonly endpoint: string;
+    canHandle(request: FastifyRequest): boolean;
+    forward(body: unknown, headers: Record<string, string>, rawBody?: Buffer): Promise<ForwardResult>;
+    extractProjectPath(body: unknown): string | null;
+    extractSessionId(response: unknown): string | null;
+    extractTextContent(response: unknown): string;
+    extractGoal(messages: unknown[]): string;
+    extractHistory(messages: unknown[]): ConversationMessage[];
+    extractUsage(response: unknown): TokenUsage;
+    isValidResponse(body: unknown): boolean;
+    isSubagentModel(model: string): boolean;
+    isEndTurn(response: unknown): boolean;
+    isToolUse(response: unknown): boolean;
+    parseActions(response: unknown): NormalizedAction[];
+    getToolUseBlocks(response: unknown): ToolUseBlock[];
+    findInternalToolUse(response: unknown, toolName: string): ToolUseBlock | null;
+    injectMemory(body: unknown, memory: string): unknown;
+    injectDelta(body: unknown, delta: string): unknown;
+    injectTool(body: unknown, toolDef: unknown): unknown;
+    buildGrovExpandTool(): unknown;
+    getMessages(body: unknown): unknown[];
+    setMessages(body: unknown, messages: unknown[]): unknown;
+    getLastUserContent(body: unknown): string;
+    injectIntoRawSystemPrompt(rawBody: string, injection: string): {
+        modified: string;
+        success: boolean;
+    };
+    injectIntoRawUserMessage(rawBody: string, injection: string): string;
+    injectToolIntoRawBody(rawBody: string, toolDef: unknown): {
+        modified: string;
+        success: boolean;
+    };
+    filterResponseHeaders(headers: Record<string, string | string[]>): Record<string, string>;
+    buildContinueBody(body: unknown, assistantContent: unknown, toolResult: string, toolId: string): unknown;
+    getResponseContentType(wasSSE: boolean): string;
+    getSettings(): AgentSettings;
+}

package/dist/integrations/proxy/agents/types.js

@@ -0,0 +1,2 @@
+// Agent adapter types for multi-agent proxy support
+export {};

package/dist/{proxy → integrations/proxy/cache}/extended-cache.js

@@ -1,6 +1,6 @@
 // Extended Cache - Keep Anthropic cache alive during idle
 // Sends minimal keep-alive requests to prevent cache TTL expiration
-import { forwardToAnthropic } from './forwarder.js';
+import { forwardToAnthropic, isForwardError } from '../agents/claude/forwarder.js';
 export const extendedCache = new Map();
 // Timing constants
 const EXTENDED_CACHE_IDLE_THRESHOLD = 4 * 60 * 1000; // 4 minutes (under 5-min TTL)
@@ -94,10 +94,6 @@ async function sendExtendedCacheKeepAlive(projectPath, entry) {
     if (result.statusCode !== 200) {
         throw new Error(`Keep-alive failed: ${result.statusCode}`);
     }
-    // Log cache metrics (minimal)
-    const usage = result.body.usage;
-    const cacheRead = usage?.cache_read_input_tokens || 0;
-    console.log(`[CACHE] keep-alive ${projectName}: read=${cacheRead}`);
 }
 export async function checkExtendedCache() {
     const now = Date.now();
@@ -133,7 +129,7 @@ export async function checkExtendedCache() {
         })
             .catch((err) => {
             extendedCache.delete(projectPath);
-            const errMsg = err instanceof Error ? err.message : 'unknown';
+            const errMsg = isForwardError(err) ? err.message : (err instanceof Error ? err.message : 'unknown');
             console.error(`[CACHE] keep-alive ${projectName} failed: ${errMsg}`);
         });
         keepAlivePromises.push(promise);

package/dist/{proxy → integrations/proxy}/config.js

@@ -9,7 +9,7 @@ export const config = {
     REQUEST_TIMEOUT: parseInt(process.env.REQUEST_TIMEOUT || '300000', 10), // 5 minutes
     BODY_LIMIT: parseInt(process.env.BODY_LIMIT || '10485760', 10), // 10MB
     // Drift settings
-    DRIFT_CHECK_INTERVAL: parseInt(process.env.DRIFT_CHECK_INTERVAL || '3', 10),
+    DRIFT_CHECK_INTERVAL: parseInt(process.env.DRIFT_CHECK_INTERVAL || '5', 10),
     TOKEN_WARNING_THRESHOLD: parseInt(process.env.TOKEN_WARNING_THRESHOLD || '160000', 10), // 80%
     TOKEN_CLEAR_THRESHOLD: parseInt(process.env.TOKEN_CLEAR_THRESHOLD || '180000', 10), // 90%
     // Security (Phase 2 - disabled for local)

package/dist/{proxy → integrations/proxy}/handlers/preprocess.d.ts

@@ -1,4 +1,4 @@
-import type { MessagesRequestBody } from '../types.js';
+import type { AgentAdapter } from '../agents/types.js';
 export declare function getPendingPlanClear(): {
     projectPath: string;
     summary: string;
@@ -8,7 +8,7 @@ export declare function setPendingPlanClear(value: {
     summary: string;
 }): void;
 export declare function clearPendingPlan(): void;
-export declare function preProcessRequest(body: MessagesRequestBody, sessionInfo: {
+export declare function preProcessRequest(adapter: AgentAdapter, body: unknown, sessionInfo: {
     sessionId: string;
     promptCount: number;
     projectPath: string;
@@ -17,4 +17,4 @@ export declare function preProcessRequest(body: MessagesRequestBody, sessionInfo
 }, detectRequestType: (messages: Array<{
     role: string;
     content: unknown;
-}>, projectPath: string) => 'first' | 'continuation' | 'retry'): Promise<MessagesRequestBody>;
+}>, projectPath: string) => 'first' | 'continuation' | 'retry'): Promise<unknown>;

package/dist/integrations/proxy/handlers/preprocess.js

@@ -0,0 +1,194 @@
+// Pre-process requests before forwarding to upstream API (agent-agnostic)
+import { config } from '../config.js';
+import { extractFilesFromMessages } from '../request-processor.js';
+import { fetchTeamMemories } from '../../../core/cloud/api-client.js';
+import { getSessionState, updateSessionState, markCleared, } from '../../../core/store/store.js';
+import { isSyncEnabled, getSyncTeamId } from '../../../core/cloud/cloud-sync.js';
+import { clearSessionState, cacheMemories, buildMemoryPreview, buildToolDescription, buildDriftRecoveryInjection, reconstructMessages, addInjectionRecord, commitPendingRecords, setCachedPreview, getCachedPreview, } from '../injection/memory-injection.js';
+let pendingPlanClear = null;
+export function getPendingPlanClear() {
+    return pendingPlanClear;
+}
+export function setPendingPlanClear(value) {
+    pendingPlanClear = value;
+}
+export function clearPendingPlan() {
+    pendingPlanClear = null;
+}
+export async function preProcessRequest(adapter, body, sessionInfo, logger, detectRequestType) {
+    let modified = { ...body };
+    // === WARMUP CHECK (FIRST - before any injection) ===
+    // Skip warmup requests entirely - no tool, no system prompt, nothing
+    const rawEarlyPrompt = adapter.getLastUserContent(modified);
+    const earlyUserPrompt = rawEarlyPrompt
+        .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
+        .replace(/\\n["']?\s*<\/system-reminder>/g, '')
+        .replace(/<\/system-reminder>/g, '')
+        .trim();
+    if (earlyUserPrompt.startsWith('Warmup')) {
+        return modified;
+    }
+    // Save clean user prompt BEFORE any reconstruction/injection (agent-agnostic)
+    modified.__grovRawUserPrompt = earlyUserPrompt.substring(0, 500);
+    // === TOOL INJECTION (only for real user requests) ===
+    const toolDesc = buildToolDescription();
+    modified.__grovInjection = toolDesc;
+    modified.__grovInjectionCached = false;
+    // Add grov_expand tool to tools array (agent-specific format)
+    const toolDef = adapter.buildGrovExpandTool();
+    modified = adapter.injectTool(modified, toolDef);
+    const messages = adapter.getMessages(modified);
+    const requestType = detectRequestType(messages, sessionInfo.projectPath);
+    const sessionState = getSessionState(sessionInfo.sessionId);
+    // === COMMIT PENDING RECORDS FROM PREVIOUS TURN ===
+    // When a new turn starts, commit any pending records so reconstruction stays consistent
+    if (requestType === 'first') {
+        commitPendingRecords(sessionInfo.projectPath);
+    }
+    // === PLANNING CLEAR ===
+    if (pendingPlanClear && pendingPlanClear.projectPath === sessionInfo.projectPath) {
+        modified = adapter.setMessages(modified, []);
+        modified = adapter.injectMemory(modified, pendingPlanClear.summary);
+        pendingPlanClear = null;
+        clearSessionState(sessionInfo.projectPath);
+        return modified;
+    }
+    // === CLEAR MODE (token threshold) ===
+    if (sessionState) {
+        const currentTokenCount = sessionState.token_count || 0;
+        if (currentTokenCount > config.TOKEN_CLEAR_THRESHOLD && sessionState.pending_clear_summary) {
+            logger.info({
+                msg: 'CLEAR MODE ACTIVATED',
+                tokenCount: currentTokenCount,
+                threshold: config.TOKEN_CLEAR_THRESHOLD,
+            });
+            modified = adapter.setMessages(modified, []);
+            modified = adapter.injectMemory(modified, sessionState.pending_clear_summary);
+            markCleared(sessionInfo.sessionId);
+            updateSessionState(sessionInfo.sessionId, { pending_clear_summary: undefined });
+            clearSessionState(sessionInfo.projectPath);
+            return modified;
+        }
+    }
+    // Capture original position BEFORE reconstruction (for injection tracking)
+    const originalMessages = adapter.getMessages(modified);
+    let originalLastUserPos = originalMessages.length - 1;
+    for (let i = originalMessages.length - 1; i >= 0; i--) {
+        if (originalMessages[i]?.role === 'user') {
+            originalLastUserPos = i;
+            break;
+        }
+    }
+    // === RECONSTRUCT HISTORICAL INJECTIONS (for cache consistency) ===
+    const currentMessages = adapter.getMessages(modified);
+    const { messages: reconstructedMsgs, reconstructedCount } = reconstructMessages(currentMessages, sessionInfo.projectPath);
+    if (reconstructedCount > 0) {
+        modified = adapter.setMessages(modified, reconstructedMsgs);
+        modified.__grovReconstructedCount = reconstructedCount;
+    }
+    // Pass original position to orchestrator for tool_cycle tracking
+    modified.__grovOriginalLastUserPos = originalLastUserPos;
+    // === MEMORY PREVIEW INJECTION (new system) ===
+    if (requestType === 'first') {
+        const teamId = getSyncTeamId();
+        const rawUserPrompt = adapter.getLastUserContent(modified);
+        // Clean user prompt - strip Claude Code injections that pollute semantic search
+        const userPrompt = rawUserPrompt
+            .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
+            .replace(/\\n["']?\s*<\/system-reminder>/g, '')
+            .replace(/<\/system-reminder>/g, '')
+            .replace(/^This session is being continued from a previous conversation[\s\S]*?Summary:/gi, '')
+            .replace(/^[\s\n"'\\]+/, '')
+            .trim();
+        const messagesForFiles = adapter.getMessages(modified);
+        const mentionedFiles = extractFilesFromMessages(messagesForFiles);
+        const syncEnabled = isSyncEnabled();
+        if (syncEnabled && teamId && userPrompt) {
+            try {
+                const memories = await fetchTeamMemories(teamId, sessionInfo.projectPath, {
+                    status: 'complete',
+                    limit: 3,
+                    context: userPrompt,
+                    current_files: mentionedFiles.length > 0 ? mentionedFiles : undefined,
+                });
+                if (memories.length > 0) {
+                    const memoryIds = memories.map(m => m.id.substring(0, 8)).join(', ');
+                    console.log(`[MEMORY] ${memories.length} memories found: [${memoryIds}]`);
+                    // Cache for expand tool
+                    cacheMemories(sessionInfo.projectPath, memories);
+                    // Build preview for user message
+                    const preview = buildMemoryPreview(memories);
+                    // Build drift/recovery if pending
+                    const driftRecovery = buildDriftRecoveryInjection(sessionState?.pending_correction, sessionState?.pending_forced_recovery);
+                    // Combine preview + drift/recovery
+                    let userMsgInjection = preview || '';
+                    if (driftRecovery) {
+                        userMsgInjection = userMsgInjection ? `${userMsgInjection}\n${driftRecovery}` : driftRecovery;
+                    }
+                    if (userMsgInjection) {
+                        modified.__grovUserMsgInjection = userMsgInjection;
+                        setCachedPreview(sessionInfo.projectPath, userMsgInjection, messages.length);
+                        // Track for reconstruction on next request (use ORIGINAL position)
+                        addInjectionRecord(sessionInfo.projectPath, {
+                            position: originalLastUserPos,
+                            type: 'preview',
+                            preview: userMsgInjection,
+                        });
+                    }
+                    logger.info({
+                        msg: 'Memory preview injected',
+                        memoriesCount: memories.length,
+                        previewSize: preview?.length || 0,
+                        hasDriftRecovery: !!driftRecovery,
+                    });
+                }
+                else {
+                    // No memories found - inject explicit "no entries" so Claude doesn't use old previews
+                    let noMemoriesMsg = '[PROJECT KNOWLEDGE BASE: No relevant entries for this query]';
+                    const driftRecovery = buildDriftRecoveryInjection(sessionState?.pending_correction, sessionState?.pending_forced_recovery);
+                    if (driftRecovery) {
+                        noMemoriesMsg = `${noMemoriesMsg}\n${driftRecovery}`;
+                    }
+                    modified.__grovUserMsgInjection = noMemoriesMsg;
+                    setCachedPreview(sessionInfo.projectPath, noMemoriesMsg, messages.length);
+                    // Track for reconstruction
+                    addInjectionRecord(sessionInfo.projectPath, {
+                        position: originalLastUserPos,
+                        type: 'preview',
+                        preview: noMemoriesMsg,
+                    });
+                }
+                // Clear pending corrections after injection
+                if (sessionState?.pending_correction || sessionState?.pending_forced_recovery) {
+                    updateSessionState(sessionInfo.sessionId, {
+                        pending_correction: undefined,
+                        pending_forced_recovery: undefined,
+                    });
+                }
+            }
+            catch (err) {
+                console.error(`[MEMORY] fetchTeamMemories error: ${err}`);
+            }
+        }
+        else {
+            // Sync not enabled - only inject drift/recovery if pending
+            const driftRecovery = buildDriftRecoveryInjection(sessionState?.pending_correction, sessionState?.pending_forced_recovery);
+            if (driftRecovery) {
+                modified.__grovUserMsgInjection = driftRecovery;
+                if (sessionState?.pending_correction || sessionState?.pending_forced_recovery) {
+                    updateSessionState(sessionInfo.sessionId, {
+                        pending_correction: undefined,
+                        pending_forced_recovery: undefined,
+                    });
+                }
+            }
+        }
+    }
+    else if (requestType === 'retry') {
+        const cached = getCachedPreview(sessionInfo.projectPath, messages.length);
+        if (cached) {
+            modified.__grovUserMsgInjection = cached;
+        }
+    }
+    return modified;
+}

package/dist/integrations/proxy/index.js

@@ -0,0 +1,20 @@
+// Grov Proxy CLI entry point
+// Load .env file for API keys
+import { config } from 'dotenv';
+import { join } from 'path';
+import { homedir } from 'os';
+import { existsSync } from 'fs';
+// Load from current directory .env first
+config();
+// Also load ~/.grov/.env as fallback
+const grovEnvPath = join(homedir(), '.grov', '.env');
+if (existsSync(grovEnvPath)) {
+    config({ path: grovEnvPath });
+}
+import { startServer } from './server.js';
+// Note: Claude Code auth comes from request headers (no env var needed)
+// Env loading above is for Codex future use and CLI tools
+startServer().catch((err) => {
+    console.error('Proxy failed:', err);
+    process.exit(1);
+});

package/dist/integrations/proxy/injection/memory-injection.d.ts

@@ -0,0 +1,56 @@
+import type { Memory } from '@grov/shared';
+export interface InjectionRecord {
+    position: number;
+    type: 'preview' | 'tool_cycle';
+    preview?: string;
+    toolUse?: {
+        id: string;
+        name: string;
+        input: unknown;
+    };
+    toolResult?: string;
+}
+export interface SessionInjectionState {
+    memoriesById: Map<string, Memory>;
+    injectionHistory: InjectionRecord[];
+    pendingRecords: InjectionRecord[];
+    lastOriginalMsgCount: number;
+    cachedPreview?: {
+        preview: string;
+        msgCount: number;
+    };
+}
+export declare function getOrCreateState(sessionId: string): SessionInjectionState;
+export declare function clearSessionState(sessionId: string): void;
+export declare function cacheMemories(sessionId: string, memories: Memory[]): void;
+export declare function getCachedMemoryById(sessionId: string, memoryId: string): Memory | null;
+export declare function setCachedPreview(sessionId: string, preview: string, msgCount: number): void;
+export declare function getCachedPreview(sessionId: string, currentMsgCount: number): string | null;
+export declare function addInjectionRecord(sessionId: string, record: InjectionRecord): void;
+export declare function commitPendingRecords(sessionId: string): number;
+export declare function hasToolCycleAtPosition(sessionId: string, position: number): boolean;
+export declare function formatAge(updatedAt: string | undefined): string;
+export declare function buildMemoryPreview(memories: Memory[]): string | null;
+export declare function buildExpandedMemory(memory: Memory): string;
+export declare function buildToolDescription(): string;
+export declare function buildDriftRecoveryInjection(pendingCorrection?: string, pendingForcedRecovery?: string): string | null;
+type MessageContent = string | Array<{
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}>;
+export declare function appendTextToMessage(message: {
+    role: string;
+    content: MessageContent;
+}, text: string): void;
+export declare function reconstructMessages(messages: Array<{
+    role: string;
+    content: unknown;
+}>, projectPath: string): {
+    messages: Array<{
+        role: string;
+        content: unknown;
+    }>;
+    reconstructedCount: number;
+};
+export {};