@townco/agent 0.1.83 → 0.1.84

package/dist/acp-server/adapter.js

@@ -382,7 +382,7 @@ export class AgentAcpAdapter {
                             : {}),
                         ...block._meta,
                     };
-                    // Debug: log subagent data being replayed
+                    // Debug: log subagent data and compaction metadata being replayed
                     logger.info("Replaying tool_call", {
                         toolCallId: block.id,
                         title: block.title,
@@ -391,6 +391,8 @@ export class AgentAcpAdapter {
                         hasSubagentSessionId: !!block.subagentSessionId,
                         hasSubagentMessages: !!block.subagentMessages,
                         subagentMessagesCount: block.subagentMessages?.length,
+                        blockMeta: block._meta,
+                        replayMeta,
                     });
                     this.connection.sessionUpdate({
                         sessionId: params.sessionId,
@@ -436,6 +438,7 @@ export class AgentAcpAdapter {
                             status: block.status,
                             rawOutput: block.rawOutput,
                             error: block.error,
+                            _meta: replayMeta,
                         },
                     });
                 }
@@ -600,9 +603,8 @@ export class AgentAcpAdapter {
                     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, // No LLM-reported tokens yet
-            this.currentToolOverheadTokens, // Include tool overhead
+            // Calculate context size - only estimated values
+            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, this.currentToolOverheadTokens, // Include tool overhead
             this.currentMcpOverheadTokens, // Include MCP overhead
             getModelContextWindow(this.agent.definition.model));
             const contextSnapshot = createContextSnapshot(session.messages.length - 1, // Exclude the newly added user message (it will be passed separately via prompt)
@@ -721,19 +723,8 @@ export class AgentAcpAdapter {
                         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,
-                                    });
-                                }
-                            }
+                            // Note: We no longer update context entries with LLM-reported tokens
+                            // as they can cause mismatches when updated on mid-turn snapshots
                         }
                         turnTokenUsage.outputTokens += tokenUsage.outputTokens ?? 0;
                         turnTokenUsage.totalTokens += tokenUsage.totalTokens ?? 0;
@@ -910,19 +901,71 @@ export class AgentAcpAdapter {
                         // Get the raw output
                         let rawOutput = outputMsg.rawOutput || outputMsg.output;
                         let truncationWarning;
+                        // Check for compaction metadata embedded by LangChain tool wrapper
+                        // This happens when compaction runs in the wrapper (before reaching adapter)
+                        if (rawOutput &&
+                            typeof rawOutput === "object" &&
+                            "_compactionMeta" in rawOutput) {
+                            const compactionMeta = rawOutput._compactionMeta;
+                            // Store in _meta for UI persistence
+                            if (!toolCallBlock._meta) {
+                                toolCallBlock._meta = {};
+                            }
+                            if (compactionMeta.action) {
+                                toolCallBlock._meta.compactionAction = compactionMeta.action;
+                            }
+                            if (compactionMeta.originalTokens !== undefined) {
+                                toolCallBlock._meta.originalTokens =
+                                    compactionMeta.originalTokens;
+                            }
+                            if (compactionMeta.finalTokens !== undefined) {
+                                toolCallBlock._meta.finalTokens = compactionMeta.finalTokens;
+                            }
+                            // Store original content only if compaction or truncation actually occurred
+                            const wasCompacted = compactionMeta.action === "compacted" ||
+                                compactionMeta.action === "truncated" ||
+                                compactionMeta.action === "compacted_then_truncated";
+                            if (compactionMeta.originalContent &&
+                                wasCompacted &&
+                                this.storage) {
+                                try {
+                                    const toolName = toolCallBlock.title || "unknown";
+                                    const originalContentPath = this.storage.saveToolOriginal(params.sessionId, toolName, outputMsg.toolCallId, compactionMeta.originalContent);
+                                    toolCallBlock._meta.originalContentPath = originalContentPath;
+                                    logger.info("Saved original content to artifacts", {
+                                        toolCallId: outputMsg.toolCallId,
+                                        toolName,
+                                        path: originalContentPath,
+                                    });
+                                }
+                                catch (error) {
+                                    logger.warn("Failed to save original tool content", {
+                                        toolCallId: outputMsg.toolCallId,
+                                        error: error instanceof Error ? error.message : String(error),
+                                    });
+                                }
+                            }
+                            logger.info("Extracted compaction metadata from tool response wrapper", {
+                                toolCallId: outputMsg.toolCallId,
+                                action: compactionMeta.action,
+                                originalTokens: compactionMeta.originalTokens,
+                                finalTokens: compactionMeta.finalTokens,
+                                hasOriginalContent: !!compactionMeta.originalContent,
+                            });
+                            // Remove the metadata from rawOutput to keep it clean
+                            const { _compactionMeta: _, ...cleanOutput } = rawOutput;
+                            rawOutput = cleanOutput;
+                        }
                         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];
-                                // Use max of estimated and LLM-reported tokens (same logic as UI)
-                                const currentContextTokens = Math.max(latestContext?.context_size.totalEstimated ?? 0, latestContext?.context_size.llmReportedInputTokens ?? 0);
-                                // Send the context size to the UI so it shows the same value we're using for hook evaluation
+                                // Use estimated tokens for hook evaluation
+                                const currentContextTokens = latestContext?.context_size.totalEstimated ?? 0;
+                                // Send the context size to the UI
                                 if (latestContext?.context_size) {
-                                    const contextSizeForUI = {
-                                        ...latestContext.context_size,
-                                        totalEstimated: currentContextTokens,
-                                    };
+                                    const contextSizeForUI = latestContext.context_size;
                                     this.connection.sessionUpdate({
                                         sessionId: params.sessionId,
                                         update: {
@@ -964,6 +1007,12 @@ export class AgentAcpAdapter {
                                 });
                                 // Note: Notifications are now sent in real-time via the callback
                                 // The hookResult.notifications array is kept for backwards compatibility
+                                // Capture original content BEFORE any modification (needed for storage)
+                                const originalContentStr = typeof rawOutput === "object" &&
+                                    rawOutput !== null &&
+                                    "content" in rawOutput
+                                    ? String(rawOutput.content)
+                                    : JSON.stringify(rawOutput);
                                 // Apply modifications if hook returned them
                                 if (hookResult.modifiedOutput) {
                                     rawOutput = hookResult.modifiedOutput;
@@ -974,6 +1023,49 @@ export class AgentAcpAdapter {
                                     });
                                 }
                                 truncationWarning = hookResult.truncationWarning;
+                                // Store hook result metadata in toolCallBlock._meta for persistence
+                                if (hookResult.metadata) {
+                                    if (!toolCallBlock._meta) {
+                                        toolCallBlock._meta = {};
+                                    }
+                                    // Store compaction action and stats
+                                    if (hookResult.metadata.action) {
+                                        toolCallBlock._meta.compactionAction = hookResult.metadata
+                                            .action;
+                                    }
+                                    if (hookResult.metadata.originalTokens !== undefined) {
+                                        toolCallBlock._meta.originalTokens = hookResult.metadata
+                                            .originalTokens;
+                                    }
+                                    if (hookResult.metadata.finalTokens !== undefined) {
+                                        toolCallBlock._meta.finalTokens = hookResult.metadata
+                                            .finalTokens;
+                                    }
+                                    // Store original content if compaction occurred (action !== "none")
+                                    if (hookResult.metadata.action &&
+                                        hookResult.metadata.action !== "none" &&
+                                        this.storage) {
+                                        try {
+                                            const toolName = toolCallBlock.title || "unknown";
+                                            const originalContentPath = this.storage.saveToolOriginal(params.sessionId, toolName, outputMsg.toolCallId, originalContentStr);
+                                            toolCallBlock._meta.originalContentPath =
+                                                originalContentPath;
+                                            logger.info("Saved original content to artifacts", {
+                                                toolCallId: outputMsg.toolCallId,
+                                                toolName,
+                                                path: originalContentPath,
+                                            });
+                                        }
+                                        catch (error) {
+                                            logger.warn("Failed to save original tool content", {
+                                                toolCallId: outputMsg.toolCallId,
+                                                error: error instanceof Error
+                                                    ? error.message
+                                                    : String(error),
+                                            });
+                                        }
+                                    }
+                                }
                             }
                         }
                         // Store the (potentially modified) output
@@ -987,6 +1079,22 @@ export class AgentAcpAdapter {
                             }
                             toolCallBlock._meta.truncationWarning = truncationWarning;
                         }
+                        // Send compaction metadata to the client if present
+                        // This is needed for live streaming (not just replay)
+                        if (toolCallBlock._meta?.compactionAction) {
+                            logger.info("Sending compaction metadata to client during live streaming", {
+                                toolCallId: outputMsg.toolCallId,
+                                _meta: toolCallBlock._meta,
+                            });
+                            this.connection.sessionUpdate({
+                                sessionId: params.sessionId,
+                                update: {
+                                    sessionUpdate: "tool_call_update",
+                                    toolCallId: outputMsg.toolCallId,
+                                    _meta: toolCallBlock._meta,
+                                },
+                            });
+                        }
                         // 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
@@ -1062,8 +1170,7 @@ export class AgentAcpAdapter {
                                 }
                             }
                             // 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, // Tool result hasn't been sent to LLM yet, so no new LLM-reported tokens
-                            this.currentToolOverheadTokens, // Include tool overhead
+                            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, this.currentToolOverheadTokens, // Include tool overhead
                             this.currentMcpOverheadTokens, // Include MCP overhead
                             getModelContextWindow(this.agent.definition.model));
                             // Create snapshot with a pointer to the partial message (not a full copy!)
@@ -1217,9 +1324,8 @@ export class AgentAcpAdapter {
                     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, // Final LLM-reported tokens from this turn
-            this.currentToolOverheadTokens, // Include tool overhead
+            // Calculate context size - only estimated values
+            const context_size = calculateContextSize(contextMessages, this.agent.definition.systemPrompt ?? undefined, this.currentToolOverheadTokens, // Include tool overhead
             this.currentMcpOverheadTokens, // Include MCP overhead
             getModelContextWindow(this.agent.definition.model));
             const contextSnapshot = createContextSnapshot(session.messages.length, new Date().toISOString(), previousContext, context_size);
@@ -1297,28 +1403,19 @@ export class AgentAcpAdapter {
             context: session.context,
             requestParams: session.requestParams,
         };
-        // Get actual input token count from latest context entry
+        // Get input token count from latest context entry
         const latestContext = session.context.length > 0
             ? session.context[session.context.length - 1]
             : undefined;
-        // Use max of estimated and LLM-reported tokens (same logic as UI)
-        // This is conservative - we want to trigger compaction earlier rather than later
-        const actualInputTokens = Math.max(latestContext?.context_size.totalEstimated ?? 0, latestContext?.context_size.llmReportedInputTokens ?? 0);
+        // Use estimated tokens for hook evaluation
+        const actualInputTokens = latestContext?.context_size.totalEstimated ?? 0;
         logger.debug("Using tokens for hook execution", {
-            llmReported: latestContext?.context_size.llmReportedInputTokens,
             estimated: latestContext?.context_size.totalEstimated,
             used: actualInputTokens,
         });
-        // Send the context size to the UI so it shows the same value we're using for hook evaluation
-        // This ensures the UI percentage matches what the hook sees
+        // Send the context size to the UI
         if (latestContext?.context_size) {
-            // Create an updated context_size with the actualInputTokens we computed
-            // so UI can calculate the same percentage
-            const contextSizeForUI = {
-                ...latestContext.context_size,
-                // Override with the max value we computed (what hooks actually use)
-                totalEstimated: actualInputTokens,
-            };
+            const contextSizeForUI = latestContext.context_size;
             this.connection.sessionUpdate({
                 sessionId,
                 update: {

package/dist/acp-server/http.js

@@ -455,6 +455,61 @@ export function makeHttpTransport(agent, agentDir, agentName) {
             }, 500);
         }
     });
+    // Serve files from session artifacts folder
+    app.get("/sessions/:sessionId/artifacts/*", async (c) => {
+        if (!agentDir || !agentName) {
+            return c.json({ error: "Session storage not configured" }, 500);
+        }
+        const noSession = process.env.TOWN_NO_SESSION === "true";
+        if (noSession) {
+            return c.json({ error: "Sessions disabled" }, 500);
+        }
+        const sessionId = c.req.param("sessionId");
+        // Extract the filename from the wildcard path
+        const filename = c.req.path.replace(`/sessions/${sessionId}/artifacts/`, "");
+        if (!sessionId || !filename) {
+            return c.json({ error: "Session ID and filename required" }, 400);
+        }
+        // Build path to artifacts folder
+        const storage = new SessionStorage(agentDir, agentName);
+        const artifactsDir = storage.getArtifactsDir(sessionId);
+        const filePath = join(artifactsDir, filename);
+        // Security check: ensure the file is within the artifacts directory
+        const normalizedPath = resolve(filePath);
+        const normalizedArtifactsDir = resolve(artifactsDir);
+        if (!normalizedPath.startsWith(normalizedArtifactsDir)) {
+            logger.warn("Attempted to access file outside artifacts directory", {
+                filename,
+                filePath,
+                artifactsDir,
+            });
+            return c.json({ error: "Invalid path" }, 403);
+        }
+        try {
+            const file = Bun.file(filePath);
+            const exists = await file.exists();
+            if (!exists) {
+                logger.warn("Artifact file not found", {
+                    sessionId,
+                    filename,
+                    filePath,
+                });
+                return c.json({ error: "File not found" }, 404);
+            }
+            const content = await file.text();
+            return c.json({ content });
+        }
+        catch (error) {
+            logger.error("Failed to load artifact", {
+                error,
+                sessionId,
+                filename,
+            });
+            return c.json({
+                error: error instanceof Error ? error.message : String(error),
+            }, 500);
+        }
+    });
     // Serve static files from agent directory (for generated images, etc.)
     if (agentDir) {
         app.get("/static/*", async (c) => {

package/dist/acp-server/session-storage.d.ts

@@ -66,11 +66,13 @@ export interface ToolCallBlock {
     startedAt?: number | undefined;
     completedAt?: number | undefined;
     _meta?: {
-        truncationWarning?: string;
-        compactionAction?: "compacted" | "truncated";
-        originalTokens?: number;
-        finalTokens?: number;
-    };
+        truncationWarning?: string | undefined;
+        compactionAction?: "compacted" | "truncated" | undefined;
+        originalTokens?: number | undefined;
+        finalTokens?: number | undefined;
+        originalContentPreview?: string | undefined;
+        originalContentPath?: string | undefined;
+    } | undefined;
     /** Sub-agent HTTP port (for reference, not used in replay) */
     subagentPort?: number | undefined;
     /** Sub-agent session ID (for reference, not used in replay) */
@@ -124,7 +126,6 @@ export interface ContextEntry {
         toolInputTokens: number;
         toolResultsTokens: number;
         totalEstimated: number;
-        llmReportedInputTokens?: number | undefined;
         modelContextWindow?: number | undefined;
     };
 }
@@ -212,4 +213,28 @@ export declare class SessionStorage {
         messageCount: number;
         firstUserMessage?: string;
     }>>;
+    /**
+     * Get the directory for storing large content files for a session (artifacts folder)
+     */
+    getArtifactsDir(sessionId: string): string;
+    /**
+     * Get the file path for a tool's original content
+     * Follows the pattern: artifacts/tool-<ToolName>/<toolCallId>.original.txt
+     */
+    private getToolOriginalPath;
+    /**
+     * Save original tool response to a separate file
+     * Follows the pattern: artifacts/tool-<ToolName>/<toolCallId>.original.txt
+     * @param toolName - The name of the tool (e.g., "Read", "Grep")
+     * @returns Relative file path (for storage in _meta.originalContentPath)
+     */
+    saveToolOriginal(sessionId: string, toolName: string, toolCallId: string, content: string): string;
+    /**
+     * Load original tool response from separate file
+     */
+    loadToolOriginal(sessionId: string, toolName: string, toolCallId: string): string | null;
+    /**
+     * Check if original content exists for a tool call
+     */
+    hasToolOriginal(sessionId: string, toolName: string, toolCallId: string): boolean;
 }

package/dist/acp-server/session-storage.js

@@ -78,6 +78,16 @@ const toolCallBlockSchema = z.object({
     subagentPort: z.number().optional(),
     subagentSessionId: z.string().optional(),
     subagentMessages: z.array(subagentMessageSchema).optional(),
+    _meta: z
+        .object({
+        truncationWarning: z.string().optional(),
+        compactionAction: z.enum(["compacted", "truncated"]).optional(),
+        originalTokens: z.number().optional(),
+        finalTokens: z.number().optional(),
+        originalContentPreview: z.string().optional(),
+        originalContentPath: z.string().optional(),
+    })
+        .optional(),
 });
 const contentBlockSchema = z.discriminatedUnion("type", [
     textBlockSchema,
@@ -114,7 +124,6 @@ const contextEntrySchema = z.object({
         toolInputTokens: z.number(),
         toolResultsTokens: z.number(),
         totalEstimated: z.number(),
-        llmReportedInputTokens: z.number().optional(),
         modelContextWindow: z.number().optional(),
     }),
 });
@@ -345,4 +354,54 @@ export class SessionStorage {
         sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
         return sessions;
     }
+    /**
+     * Get the directory for storing large content files for a session (artifacts folder)
+     */
+    getArtifactsDir(sessionId) {
+        return join(this.sessionsDir, sessionId, "artifacts");
+    }
+    /**
+     * Get the file path for a tool's original content
+     * Follows the pattern: artifacts/tool-<ToolName>/<toolCallId>.original.txt
+     */
+    getToolOriginalPath(sessionId, toolName, toolCallId) {
+        return join(this.getArtifactsDir(sessionId), `tool-${toolName}`, `${toolCallId}.original.txt`);
+    }
+    /**
+     * Save original tool response to a separate file
+     * Follows the pattern: artifacts/tool-<ToolName>/<toolCallId>.original.txt
+     * @param toolName - The name of the tool (e.g., "Read", "Grep")
+     * @returns Relative file path (for storage in _meta.originalContentPath)
+     */
+    saveToolOriginal(sessionId, toolName, toolCallId, content) {
+        const toolDir = join(this.getArtifactsDir(sessionId), `tool-${toolName}`);
+        if (!existsSync(toolDir)) {
+            mkdirSync(toolDir, { recursive: true });
+        }
+        const filePath = this.getToolOriginalPath(sessionId, toolName, toolCallId);
+        writeFileSync(filePath, content, "utf-8");
+        // Return relative path for storage in metadata
+        return `${sessionId}/artifacts/tool-${toolName}/${toolCallId}.original.txt`;
+    }
+    /**
+     * Load original tool response from separate file
+     */
+    loadToolOriginal(sessionId, toolName, toolCallId) {
+        const filePath = this.getToolOriginalPath(sessionId, toolName, toolCallId);
+        if (!existsSync(filePath)) {
+            return null;
+        }
+        try {
+            return readFileSync(filePath, "utf-8");
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Check if original content exists for a tool call
+     */
+    hasToolOriginal(sessionId, toolName, toolCallId) {
+        return existsSync(this.getToolOriginalPath(sessionId, toolName, toolCallId));
+    }
 }

package/dist/definition/index.d.ts

@@ -21,7 +21,7 @@ export declare const HookConfigSchema: z.ZodObject<{
     setting: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         threshold: z.ZodNumber;
     }, z.core.$strip>, z.ZodObject<{
-        maxContextThreshold: z.ZodOptional<z.ZodNumber>;
+        maxTokensSize: z.ZodOptional<z.ZodNumber>;
         responseTruncationThreshold: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>]>>;
     callback: z.ZodString;
@@ -78,7 +78,7 @@ export declare const AgentDefinitionSchema: z.ZodObject<{
         setting: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
             threshold: z.ZodNumber;
         }, z.core.$strip>, z.ZodObject<{
-            maxContextThreshold: z.ZodOptional<z.ZodNumber>;
+            maxTokensSize: z.ZodOptional<z.ZodNumber>;
             responseTruncationThreshold: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>]>>;
         callback: z.ZodString;

package/dist/definition/index.js

@@ -64,7 +64,7 @@ export const HookConfigSchema = z.object({
         }),
         // For tool_response hooks
         z.object({
-            maxContextThreshold: z.number().min(0).max(100).optional(),
+            maxTokensSize: z.number().min(0).optional(),
             responseTruncationThreshold: z.number().min(0).max(100).optional(),
         }),
     ])

package/dist/runner/agent-runner.d.ts

@@ -48,7 +48,7 @@ export declare const zAgentRunnerParams: z.ZodObject<{
         setting: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
             threshold: z.ZodNumber;
         }, z.core.$strip>, z.ZodObject<{
-            maxContextThreshold: z.ZodOptional<z.ZodNumber>;
+            maxTokensSize: z.ZodOptional<z.ZodNumber>;
             responseTruncationThreshold: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>]>>;
         callback: z.ZodString;

package/dist/runner/hooks/executor.d.ts

@@ -41,6 +41,7 @@ export declare class HookExecutor {
     }): Promise<{
         modifiedOutput?: Record<string, unknown>;
         truncationWarning?: string;
+        metadata?: Record<string, unknown>;
         notifications: HookNotification[];
     }>;
     /**

package/dist/runner/hooks/executor.js

@@ -137,6 +137,9 @@ export class HookExecutor {
                     if (result.truncationWarning !== undefined) {
                         response.truncationWarning = result.truncationWarning;
                     }
+                    if (result.metadata !== undefined) {
+                        response.metadata = result.metadata;
+                    }
                     return response;
                 }
             }
@@ -152,7 +155,11 @@ export class HookExecutor {
         const notifications = [];
         // Get threshold from settings
         const settings = hook.setting;
-        const threshold = settings?.maxContextThreshold ?? 80;
+        // For notifications, calculate a percentage based on maxTokensSize relative to maxTokens
+        // Default to 20000 tokens, which we'll convert to a percentage for display
+        const maxTokensSize = settings?.maxTokensSize ?? 20000;
+        // Calculate approximate percentage: maxTokensSize / maxTokens * 100
+        const threshold = Math.min(100, Math.round((maxTokensSize / maxTokens) * 100));
         // Capture start time and emit hook_triggered BEFORE callback runs
         // This allows the UI to show the loading state immediately
         const triggeredAt = Date.now();
@@ -185,6 +192,13 @@ export class HookExecutor {
                 toolResponse,
             };
             const result = await callback(hookContext);
+            logger.info("Hook callback result", {
+                hasMetadata: !!result.metadata,
+                metadataAction: result.metadata?.action,
+                hasModifiedOutput: !!result.metadata?.modifiedOutput,
+                modifiedOutputType: typeof result.metadata?.modifiedOutput,
+                toolCallId: toolResponse.toolCallId,
+            });
             // Extract modified output and warnings from metadata
             if (result.metadata?.modifiedOutput) {
                 // Hook took action - emit completed notification
@@ -194,6 +208,8 @@ export class HookExecutor {
                     response.truncationWarning = result.metadata
                         .truncationWarning;
                 }
+                // Include full metadata for persistence
+                response.metadata = result.metadata;
                 // Notify completion
                 this.emitNotification({
                     type: "hook_completed",

package/dist/runner/hooks/predefined/tool-response-compactor.d.ts

@@ -1,6 +1,2 @@
 import type { HookCallback } from "../types.js";
-/**
- * Tool response compaction hook - compacts or truncates large tool responses
- * to prevent context overflow
- */
 export declare const toolResponseCompactor: HookCallback;