@townco/agent 0.1.49 → 0.1.51

package/dist/acp-server/adapter.d.ts

@@ -19,12 +19,27 @@ export declare class AgentAcpAdapter implements acp.Agent {
     private storage;
     private noSession;
     private agentDir;
+    private agentName;
+    private agentDisplayName;
+    private agentVersion;
+    private agentDescription;
+    private agentSuggestedPrompts;
     constructor(agent: AgentRunner, connection: acp.AgentSideConnection, agentDir?: string, agentName?: string);
+    /**
+     * Helper to save session to disk
+     * Call this after any modification to session.messages or session.context
+     */
+    private saveSessionToDisk;
     initialize(_params: acp.InitializeRequest): Promise<acp.InitializeResponse>;
     newSession(params: acp.NewSessionRequest): Promise<acp.NewSessionResponse>;
     loadSession(params: acp.LoadSessionRequest): Promise<acp.LoadSessionResponse>;
     authenticate(_params: acp.AuthenticateRequest): Promise<acp.AuthenticateResponse | undefined>;
     setSessionMode(_params: acp.SetSessionModeRequest): Promise<acp.SetSessionModeResponse>;
     prompt(params: acp.PromptRequest): Promise<acp.PromptResponse>;
+    /**
+     * Execute hooks if configured for this agent
+     * Returns new context entries that should be appended to session.context
+     */
+    private executeHooksIfConfigured;
     cancel(params: acp.CancelNotification): Promise<void>;
 }

package/dist/acp-server/adapter.js

@@ -1,6 +1,8 @@
 import * as acp from "@agentclientprotocol/sdk";
 import { createLogger } from "@townco/core";
 import { HookExecutor, loadHookCallback } from "../runner/hooks";
+import { calculateContextSize, } from "../utils/context-size-calculator.js";
+import { countToolResultTokens } from "../utils/token-counter.js";
 import { SessionStorage, } from "./session-storage.js";
 const logger = createLogger("adapter");
 /**
@@ -12,7 +14,7 @@ export const SUBAGENT_MODE_KEY = "town.com/isSubagent";
  * Create a context snapshot based on the previous context
  * Preserves full messages from previous context and adds new pointers
  */
-function createContextSnapshot(messageCount, timestamp, previousContext) {
+function createContextSnapshot(messageCount, timestamp, previousContext, context_size) {
     const messages = [];
     if (previousContext) {
         // Start with all messages from previous context
@@ -45,7 +47,19 @@ function createContextSnapshot(messageCount, timestamp, previousContext) {
             messages.push({ type: "pointer", index: i });
         }
     }
-    return { timestamp, messages };
+    return {
+        timestamp,
+        messages,
+        compactedUpTo: previousContext?.compactedUpTo,
+        context_size: context_size || {
+            systemPromptTokens: 0,
+            userMessagesTokens: 0,
+            assistantMessagesTokens: 0,
+            toolInputTokens: 0,
+            toolResultsTokens: 0,
+            totalEstimated: 0,
+        },
+    };
 }
 /**
  * Resolve context entries to session messages
@@ -84,11 +98,21 @@ export class AgentAcpAdapter {
     storage;
     noSession;
     agentDir;
+    agentName;
+    agentDisplayName;
+    agentVersion;
+    agentDescription;
+    agentSuggestedPrompts;
     constructor(agent, connection, agentDir, agentName) {
         this.connection = connection;
         this.sessions = new Map();
         this.agent = agent;
         this.agentDir = agentDir;
+        this.agentName = agentName;
+        this.agentDisplayName = agent.definition.displayName;
+        this.agentVersion = agent.definition.version;
+        this.agentDescription = agent.definition.description;
+        this.agentSuggestedPrompts = agent.definition.suggestedPrompts;
         this.noSession = process.env.TOWN_NO_SESSION === "true";
         this.storage =
             agentDir && agentName && !this.noSession
@@ -97,18 +121,65 @@ export class AgentAcpAdapter {
         logger.info("Initialized with", {
             agentDir,
             agentName,
+            agentDisplayName: this.agentDisplayName,
+            agentVersion: this.agentVersion,
+            agentDescription: this.agentDescription,
+            suggestedPrompts: this.agentSuggestedPrompts,
             noSession: this.noSession,
             hasStorage: this.storage !== null,
             sessionStoragePath: this.storage ? `${agentDir}/.sessions` : null,
         });
     }
+    /**
+     * Helper to save session to disk
+     * Call this after any modification to session.messages or session.context
+     */
+    async saveSessionToDisk(sessionId, session) {
+        if (!this.noSession && this.storage) {
+            try {
+                await this.storage.saveSession(sessionId, session.messages, session.context);
+                logger.debug("Saved session to disk", {
+                    sessionId,
+                    messageCount: session.messages.length,
+                    contextCount: session.context.length,
+                });
+            }
+            catch (error) {
+                logger.error(`Failed to save session ${sessionId}`, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
     async initialize(_params) {
-        return {
+        const response = {
             protocolVersion: acp.PROTOCOL_VERSION,
             agentCapabilities: {
                 loadSession: !this.noSession && this.storage !== null,
             },
         };
+        if (this.agentName) {
+            response.agentInfo = {
+                name: this.agentName,
+                version: this.agentVersion ?? "0.0.0",
+                // title is the ACP field for human-readable display name
+                ...(this.agentDisplayName ? { title: this.agentDisplayName } : {}),
+            };
+        }
+        // Pass description and suggestedPrompts via _meta extension point
+        // since Implementation doesn't support these fields
+        if (this.agentDescription || this.agentSuggestedPrompts) {
+            response._meta = {
+                ...response._meta,
+                ...(this.agentDescription
+                    ? { agentDescription: this.agentDescription }
+                    : {}),
+                ...(this.agentSuggestedPrompts
+                    ? { suggestedPrompts: this.agentSuggestedPrompts }
+                    : {}),
+            };
+        }
+        return response;
     }
     async newSession(params) {
         const sessionId = Math.random().toString(36).substring(2);
@@ -211,6 +282,37 @@ export class AgentAcpAdapter {
                 }
             }
         }
+        // After replay completes, send the latest context size to the UI
+        const latestContext = storedSession.context.length > 0
+            ? storedSession.context[storedSession.context.length - 1]
+            : undefined;
+        if (latestContext?.context_size) {
+            logger.info("Sending context size to UI after session replay", {
+                sessionId: params.sessionId,
+                contextSize: latestContext.context_size,
+            });
+            this.connection.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                    sessionUpdate: "agent_message_chunk",
+                    content: {
+                        type: "text",
+                        text: "",
+                    },
+                    _meta: {
+                        context_size: latestContext.context_size,
+                        isReplay: true,
+                    },
+                },
+            });
+        }
+        else {
+            logger.warn("No context size available after session replay", {
+                sessionId: params.sessionId,
+                hasLatestContext: !!latestContext,
+                contextLength: storedSession.context.length,
+            });
+        }
         return {};
     }
     async authenticate(_params) {
@@ -256,12 +358,49 @@ export class AgentAcpAdapter {
                 timestamp: new Date().toISOString(),
             };
             session.messages.push(userMessage);
+            logger.debug("User message added to session", {
+                sessionId: params.sessionId,
+                messageCount: session.messages.length,
+            });
+            // Save immediately after user message, even before context calculation
+            // This ensures the session file exists if anything crashes below
+            await this.saveSessionToDisk(params.sessionId, session);
+            logger.debug("Session saved after user message", {
+                sessionId: params.sessionId,
+            });
             // Create context snapshot based on previous context
+            logger.debug("Starting context snapshot creation", {
+                sessionId: params.sessionId,
+            });
             const previousContext = session.context.length > 0
                 ? session.context[session.context.length - 1]
                 : undefined;
-            const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext);
+            // Calculate context size for this snapshot
+            // Build message pointers for the new context (previous messages + new user message)
+            const messageEntries = previousContext
+                ? [
+                    ...previousContext.messages,
+                    { type: "pointer", index: session.messages.length - 1 },
+                ]
+                : [{ type: "pointer", index: 0 }];
+            // Resolve message entries to actual messages
+            const contextMessages = [];
+            for (const entry of messageEntries) {
+                if (entry.type === "pointer") {
+                    const message = session.messages[entry.index];
+                    if (message) {
+                        contextMessages.push(message);
+                    }
+                }
+                else if (entry.type === "full") {
+                    contextMessages.push(entry.message);
+                }
+            }
+            // Calculate context size - no LLM call yet, so only estimated values
+            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, undefined);
+            const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, context_size);
             session.context.push(contextSnapshot);
+            await this.saveSessionToDisk(params.sessionId, session);
         }
         // Build ordered content blocks for the assistant response
         const contentBlocks = [];
@@ -273,55 +412,39 @@ export class AgentAcpAdapter {
                 pendingText = "";
             }
         };
+        // Declare agentResponse and turnTokenUsage outside try block so they're accessible after catch
+        let agentResponse;
+        // Track accumulated token usage during the turn
+        const turnTokenUsage = {
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+        };
         try {
-            // Execute hooks before agent invocation
-            const hooks = this.agent.definition.hooks;
-            logger.info("Checking hooks", {
-                noSession: this.noSession,
-                hasHooks: !!hooks,
-                hooksLength: hooks?.length ?? 0,
-                contextEntries: session.context.length,
-                totalMessages: session.messages.length,
-            });
-            if (!this.noSession && hooks && hooks.length > 0) {
-                logger.info("Executing hooks before agent invocation");
-                const hookExecutor = new HookExecutor(hooks, this.agent.definition.model, (callbackRef) => loadHookCallback(callbackRef, this.agentDir));
-                // Create read-only session view for hooks
-                const readonlySession = {
-                    messages: session.messages,
-                    context: session.context,
-                    requestParams: session.requestParams,
-                };
-                const hookResult = await hookExecutor.executeHooks(readonlySession);
-                // Send hook notifications to client
-                for (const notification of hookResult.notifications) {
-                    this.connection.sessionUpdate({
-                        sessionId: params.sessionId,
-                        update: notification,
-                    });
-                }
-                // Append new context entries returned by hooks
-                if (hookResult.newContextEntries.length > 0) {
-                    logger.info(`Appending ${hookResult.newContextEntries.length} new context entries from hooks`);
-                    session.context.push(...hookResult.newContextEntries);
-                    // Save session immediately after hooks to persist compacted context
-                    if (this.storage) {
-                        try {
-                            await this.storage.saveSession(params.sessionId, session.messages, session.context);
-                            logger.info("Session saved after hook execution with new context entries");
-                        }
-                        catch (error) {
-                            logger.error(`Failed to save session ${params.sessionId} after hook execution`, {
-                                error: error instanceof Error ? error.message : String(error),
-                            });
-                        }
-                    }
-                }
+            // Execute hooks before agent invocation (turn start)
+            const turnStartContextEntries = await this.executeHooksIfConfigured(session, params.sessionId, "turn_start");
+            // Append new context entries returned by hooks (e.g., compaction)
+            if (turnStartContextEntries.length > 0) {
+                logger.info(`Appending ${turnStartContextEntries.length} new context entries from turn_start hooks`);
+                session.context.push(...turnStartContextEntries);
+                await this.saveSessionToDisk(params.sessionId, session);
             }
             // Resolve context to messages for agent invocation
             const contextMessages = this.noSession
                 ? []
                 : resolveContextToMessages(session.context, session.messages);
+            logger.debug("Resolved context messages for agent invocation", {
+                sessionId: params.sessionId,
+                contextMessageCount: contextMessages.length,
+                totalSessionMessages: session.messages.length,
+                latestContextEntry: session.context.length > 0 &&
+                    session.context[session.context.length - 1]
+                    ? {
+                        messageCount: session.context[session.context.length - 1].messages.length,
+                        contextSize: session.context[session.context.length - 1].context_size,
+                    }
+                    : null,
+            });
             const invokeParams = {
                 prompt: params.prompt,
                 sessionId: params.sessionId,
@@ -333,7 +456,43 @@ export class AgentAcpAdapter {
             if (session.requestParams._meta) {
                 invokeParams.sessionMeta = session.requestParams._meta;
             }
-            for await (const msg of this.agent.invoke(invokeParams)) {
+            const generator = this.agent.invoke(invokeParams);
+            // Manually iterate to capture the return value
+            let iterResult = await generator.next();
+            while (!iterResult.done) {
+                const msg = iterResult.value;
+                // Extract and accumulate token usage from message chunks
+                if ("sessionUpdate" in msg &&
+                    msg.sessionUpdate === "agent_message_chunk" &&
+                    "_meta" in msg &&
+                    msg._meta &&
+                    typeof msg._meta === "object" &&
+                    "tokenUsage" in msg._meta) {
+                    const tokenUsage = msg._meta.tokenUsage;
+                    if (tokenUsage) {
+                        // Only update inputTokens if we receive a positive value
+                        // (subsequent messages may have inputTokens: 0 for output-only chunks)
+                        if (tokenUsage.inputTokens !== undefined &&
+                            tokenUsage.inputTokens > 0) {
+                            turnTokenUsage.inputTokens = tokenUsage.inputTokens;
+                            // Update the LAST context entry with LLM-reported tokens
+                            if (!this.noSession && session.context.length > 0) {
+                                const lastContext = session.context[session.context.length - 1];
+                                if (lastContext) {
+                                    lastContext.context_size.llmReportedInputTokens =
+                                        tokenUsage.inputTokens;
+                                    logger.debug("Updated context entry with LLM-reported tokens", {
+                                        contextIndex: session.context.length - 1,
+                                        llmReportedTokens: tokenUsage.inputTokens,
+                                        estimatedTokens: lastContext.context_size.totalEstimated,
+                                    });
+                                }
+                            }
+                        }
+                        turnTokenUsage.outputTokens += tokenUsage.outputTokens ?? 0;
+                        turnTokenUsage.totalTokens += tokenUsage.totalTokens ?? 0;
+                    }
+                }
                 // Accumulate text content from message chunks
                 if ("sessionUpdate" in msg &&
                     msg.sessionUpdate === "agent_message_chunk") {
@@ -398,24 +557,175 @@ export class AgentAcpAdapter {
                     const outputMsg = msg;
                     const toolCallBlock = contentBlocks.find((block) => block.type === "tool_call" && block.id === outputMsg.toolCallId);
                     if (toolCallBlock) {
-                        // Store both rawOutput and output from tool_output
-                        if (outputMsg.rawOutput) {
-                            toolCallBlock.rawOutput = outputMsg.rawOutput;
+                        // Get the raw output
+                        let rawOutput = outputMsg.rawOutput || outputMsg.output;
+                        let truncationWarning;
+                        if (rawOutput && !this.noSession) {
+                            // Execute tool_response hooks if configured
+                            const hooks = this.agent.definition.hooks ?? [];
+                            if (hooks.some((h) => h.type === "tool_response")) {
+                                const latestContext = session.context[session.context.length - 1];
+                                const currentContextTokens = latestContext?.context_size.llmReportedInputTokens ??
+                                    latestContext?.context_size.totalEstimated ??
+                                    0;
+                                const outputTokens = countToolResultTokens(rawOutput);
+                                const hookExecutor = new HookExecutor(hooks, this.agent.definition.model, (callbackRef) => loadHookCallback(callbackRef, this.agentDir));
+                                const hookResult = await hookExecutor.executeToolResponseHooks({
+                                    messages: session.messages,
+                                    context: session.context,
+                                    requestParams: session.requestParams,
+                                }, currentContextTokens, {
+                                    toolCallId: outputMsg.toolCallId,
+                                    toolName: toolCallBlock.title || "unknown",
+                                    toolInput: toolCallBlock.rawInput || {},
+                                    rawOutput,
+                                    outputTokens,
+                                });
+                                // Apply modifications if hook returned them
+                                if (hookResult.modifiedOutput) {
+                                    rawOutput = hookResult.modifiedOutput;
+                                    logger.info("Tool response modified by hook", {
+                                        toolCallId: outputMsg.toolCallId,
+                                        originalTokens: outputTokens,
+                                        finalTokens: countToolResultTokens(rawOutput),
+                                    });
+                                }
+                                truncationWarning = hookResult.truncationWarning;
+                            }
+                        }
+                        // Store the (potentially modified) output
+                        if (rawOutput) {
+                            toolCallBlock.rawOutput = rawOutput;
                         }
-                        else if (outputMsg.output) {
-                            toolCallBlock.rawOutput = outputMsg.output;
+                        // Store truncation warning if present (for UI display)
+                        if (truncationWarning) {
+                            if (!toolCallBlock._meta) {
+                                toolCallBlock._meta = {};
+                            }
+                            toolCallBlock._meta.truncationWarning = truncationWarning;
                         }
                         // Note: content blocks are handled by the transport for display
                         // We store the raw output here for session persistence
+                        // Create mid-turn context snapshot after tool completes
+                        if (!this.noSession) {
+                            flushPendingText(); // Ensure all text is captured
+                            // Update or create the partial assistant message in the messages array
+                            const partialAssistantMessage = {
+                                role: "assistant",
+                                content: [...contentBlocks], // Clone current content blocks
+                                timestamp: new Date().toISOString(),
+                            };
+                            // Check if we already have a partial assistant message in messages
+                            const lastMessage = session.messages[session.messages.length - 1];
+                            let partialMessageIndex;
+                            if (lastMessage && lastMessage.role === "assistant") {
+                                // Update existing partial message
+                                session.messages[session.messages.length - 1] =
+                                    partialAssistantMessage;
+                                partialMessageIndex = session.messages.length - 1;
+                            }
+                            else {
+                                // Add new partial message
+                                session.messages.push(partialAssistantMessage);
+                                partialMessageIndex = session.messages.length - 1;
+                            }
+                            // Get the latest context
+                            const latestContext = session.context.length > 0
+                                ? session.context[session.context.length - 1]
+                                : undefined;
+                            // Build message entries for the new context
+                            // Check if we already have a pointer to this message (during mid-turn updates)
+                            const existingMessages = latestContext?.messages ?? [];
+                            const lastEntry = existingMessages[existingMessages.length - 1];
+                            const alreadyHasPointer = lastEntry?.type === "pointer" &&
+                                lastEntry.index === partialMessageIndex;
+                            const messageEntries = alreadyHasPointer
+                                ? existingMessages // Don't add duplicate pointer
+                                : [
+                                    ...existingMessages,
+                                    { type: "pointer", index: partialMessageIndex },
+                                ];
+                            // Resolve message entries to actual messages
+                            const contextMessages = [];
+                            for (const entry of messageEntries) {
+                                if (entry.type === "pointer") {
+                                    const message = session.messages[entry.index];
+                                    if (message) {
+                                        contextMessages.push(message);
+                                    }
+                                }
+                                else if (entry.type === "full") {
+                                    contextMessages.push(entry.message);
+                                }
+                            }
+                            // Calculate context size - tool result is now in the message, but hasn't been sent to LLM yet
+                            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, undefined);
+                            // Create snapshot with a pointer to the partial message (not a full copy!)
+                            const midTurnSnapshot = {
+                                timestamp: new Date().toISOString(),
+                                messages: messageEntries,
+                                compactedUpTo: latestContext?.compactedUpTo,
+                                context_size,
+                            };
+                            session.context.push(midTurnSnapshot);
+                            await this.saveSessionToDisk(params.sessionId, session);
+                            logger.debug("Created mid-turn context snapshot after tool output", {
+                                toolCallId: outputMsg.toolCallId,
+                                contentBlocks: contentBlocks.length,
+                                partialMessageIndex,
+                                totalEstimated: midTurnSnapshot.context_size.totalEstimated,
+                                toolResultsTokens: midTurnSnapshot.context_size.toolResultsTokens,
+                            });
+                            // Execute hooks mid-turn to check if compaction is needed
+                            const midTurnContextEntries = await this.executeHooksIfConfigured(session, params.sessionId, "mid_turn");
+                            // Append new context entries returned by hooks (e.g., compaction)
+                            if (midTurnContextEntries.length > 0) {
+                                logger.info(`Appending ${midTurnContextEntries.length} new context entries from mid_turn hooks`, {
+                                    toolCallId: outputMsg.toolCallId,
+                                });
+                                session.context.push(...midTurnContextEntries);
+                                await this.saveSessionToDisk(params.sessionId, session);
+                            }
+                        }
                     }
                 }
                 // The agent may emit extended types (like tool_output) that aren't in ACP SDK yet
                 // The http transport will handle routing these appropriately
+                // Add context input tokens to messages with token usage metadata
+                let enhancedMsg = msg;
+                if (!this.noSession &&
+                    "_meta" in msg &&
+                    msg._meta &&
+                    typeof msg._meta === "object" &&
+                    "tokenUsage" in msg._meta) {
+                    // Get latest context entry and send its full context_size breakdown to GUI
+                    const latestContext = session.context.length > 0
+                        ? session.context[session.context.length - 1]
+                        : undefined;
+                    if (latestContext?.context_size) {
+                        enhancedMsg = {
+                            ...msg,
+                            _meta: {
+                                ...msg._meta,
+                                context_size: latestContext.context_size,
+                            },
+                        };
+                    }
+                    else {
+                        logger.warn("⚠️ No context_size to send to GUI", {
+                            hasLatestContext: !!latestContext,
+                            contextLength: session.context.length,
+                        });
+                    }
+                }
                 this.connection.sessionUpdate({
                     sessionId: params.sessionId,
-                    update: msg,
+                    update: enhancedMsg,
                 });
+                iterResult = await generator.next();
             }
+            // Capture the return value (PromptResponse with tokenUsage)
+            agentResponse = iterResult.value;
             // Flush any remaining pending text
             flushPendingText();
         }
@@ -433,30 +743,98 @@ export class AgentAcpAdapter {
                 content: contentBlocks,
                 timestamp: new Date().toISOString(),
             };
-            session.messages.push(assistantMessage);
+            // Check if we already have a partial assistant message from mid-turn updates
+            const lastMessage = session.messages[session.messages.length - 1];
+            if (lastMessage && lastMessage.role === "assistant") {
+                // Update the existing message instead of adding a duplicate
+                session.messages[session.messages.length - 1] = assistantMessage;
+            }
+            else {
+                // Add new message (no mid-turn updates occurred)
+                session.messages.push(assistantMessage);
+            }
             // Create context snapshot based on previous context
             const previousContext = session.context.length > 0
                 ? session.context[session.context.length - 1]
                 : undefined;
-            const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext);
-            session.context.push(contextSnapshot);
-        }
-        // Save session to disk if storage is configured and session persistence is enabled
-        if (!this.noSession && this.storage) {
-            try {
-                await this.storage.saveSession(params.sessionId, session.messages, session.context);
-            }
-            catch (error) {
-                logger.error(`Failed to save session ${params.sessionId}`, {
-                    error: error instanceof Error ? error.message : String(error),
-                });
+            // Calculate final context size
+            // Build message pointers for the new context
+            const messageEntries = previousContext
+                ? [
+                    ...previousContext.messages,
+                    { type: "pointer", index: session.messages.length - 1 },
+                ]
+                : [{ type: "pointer", index: session.messages.length - 1 }];
+            // Resolve message entries to actual messages
+            const contextMessages = [];
+            for (const entry of messageEntries) {
+                if (entry.type === "pointer") {
+                    const message = session.messages[entry.index];
+                    if (message) {
+                        contextMessages.push(message);
+                    }
+                }
+                else if (entry.type === "full") {
+                    contextMessages.push(entry.message);
+                }
             }
+            // Calculate context size with LLM-reported tokens from this turn
+            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, turnTokenUsage.inputTokens);
+            const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, context_size);
+            session.context.push(contextSnapshot);
+            await this.saveSessionToDisk(params.sessionId, session);
         }
         session.pendingPrompt = null;
         return {
             stopReason: "end_turn",
         };
     }
+    /**
+     * Execute hooks if configured for this agent
+     * Returns new context entries that should be appended to session.context
+     */
+    async executeHooksIfConfigured(session, sessionId, executionPoint) {
+        // Check if hooks are configured and session persistence is enabled
+        const hooks = this.agent.definition.hooks;
+        if (this.noSession || !hooks || hooks.length === 0) {
+            return [];
+        }
+        logger.info(`Executing hooks at ${executionPoint}`, {
+            hooksLength: hooks.length,
+            contextEntries: session.context.length,
+            totalMessages: session.messages.length,
+        });
+        const hookExecutor = new HookExecutor(hooks, this.agent.definition.model, (callbackRef) => loadHookCallback(callbackRef, this.agentDir));
+        // Create read-only session view for hooks
+        const readonlySession = {
+            messages: session.messages,
+            context: session.context,
+            requestParams: session.requestParams,
+        };
+        // Get actual input token count from latest context entry
+        const latestContext = session.context.length > 0
+            ? session.context[session.context.length - 1]
+            : undefined;
+        // Prefer LLM-reported tokens (most accurate), fall back to our estimate
+        const actualInputTokens = latestContext?.context_size.llmReportedInputTokens ??
+            latestContext?.context_size.totalEstimated ??
+            0;
+        logger.debug("Using tokens for hook execution", {
+            llmReported: latestContext?.context_size.llmReportedInputTokens,
+            estimated: latestContext?.context_size.totalEstimated,
+            used: actualInputTokens,
+        });
+        const hookResult = await hookExecutor.executeHooks(readonlySession, actualInputTokens);
+        // Send hook notifications to client
+        for (const notification of hookResult.notifications) {
+            this.connection.sessionUpdate({
+                sessionId,
+                update: notification,
+            });
+        }
+        // Return new context entries (will be appended by caller)
+        return hookResult.newContextEntries;
+    }
     async cancel(params) {
         this.sessions.get(params.sessionId)?.pendingPrompt?.abort();
     }