wave-agent-sdk 1.0.5 → 1.0.7

package/dist/managers/slashCommandManager.js

@@ -14,6 +14,34 @@ export class SlashCommandManager {
     }
     initialize() {
         this.loadCustomCommands();
+        // Builtin /subtask: manual fork subagent (aligned with Claude Code's
+        // /subtask — inherits the parent's full context, runs in the background,
+        // result returns to the main conversation via a task notification).
+        this.registerCommand({
+            id: "subtask",
+            name: "subtask",
+            description: "Start a fork subagent with the current conversation context in the background",
+            handler: async (args, signal) => {
+                const taskDescription = args?.trim();
+                if (!taskDescription) {
+                    this.messageManager.addErrorBlock("Usage: /subtask <task description>");
+                    return;
+                }
+                try {
+                    // The fork snapshots its context synchronously on entry, so the
+                    // transcript echo below never duplicates the prompt inside the fork.
+                    await this.aiManager.runForkSubagent(taskDescription, { description: taskDescription }, signal);
+                    this.messageManager.addUserMessage({
+                        content: `/subtask ${taskDescription}`,
+                    });
+                }
+                catch (error) {
+                    this.aiManager.setIsLoading(false);
+                    logger?.error("Failed to execute /subtask:", error);
+                    this.messageManager.addErrorBlock(`Failed to execute /subtask: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
+        });
         // Listen for skill refreshes and update skill commands
         const skillManager = this.container.get("SkillManager");
         if (skillManager) {

package/dist/managers/subagentManager.d.ts

@@ -19,7 +19,6 @@ export interface SubagentManagerCallbacks {
         subagentId: string;
         messageId: string;
         chunk: string;
-        accumulated: string;
         stage: "streaming" | "end";
     }) => void;
     /** Triggered during subagent reasoning streaming updates */
@@ -27,7 +26,6 @@ export interface SubagentManagerCallbacks {
         subagentId: string;
         messageId: string;
         chunk: string;
-        accumulated: string;
         stage: "streaming" | "end";
     }) => void;
     /** Triggered when subagent tool block is updated */

package/dist/services/aiService.d.ts

@@ -1,7 +1,6 @@
 import { ChatCompletionMessageToolCall } from "openai/resources";
 import { ChatCompletionMessageParam, ChatCompletionFunctionTool } from "openai/resources.js";
-import type { GatewayConfig, ModelConfig } from "../types/index.js";
-import { type ClaudeUsage } from "../utils/cacheControlUtils.js";
+import type { GatewayConfig, ModelConfig, Usage } from "../types/index.js";
 import { type SystemPromptBlock } from "../prompts/index.js";
 /**
  * Resets the rate limiter state. Primarily used for testing.
@@ -40,7 +39,7 @@ export interface CallAgentResult {
     content?: string;
     tool_calls?: ChatCompletionMessageToolCall[];
     reasoning_content?: string;
-    usage?: ClaudeUsage;
+    usage?: Usage;
     finish_reason?: "stop" | "length" | "tool_calls" | "content_filter" | "function_call" | null;
     response_headers?: Record<string, string>;
     additionalFields?: Record<string, unknown>;

package/dist/services/aiService.js

@@ -202,17 +202,9 @@ export async function callAgent(options) {
             });
             const finalMessage = response.choices[0]?.message;
             const finishReason = response.choices[0]?.finish_reason || null;
-            let totalUsage = response.usage
-                ? {
-                    prompt_tokens: response.usage.prompt_tokens,
-                    completion_tokens: response.usage.completion_tokens,
-                    total_tokens: response.usage.total_tokens,
-                }
+            const totalUsage = response.usage
+                ? extendUsageWithCacheMetrics(response.usage)
                 : undefined;
-            // Extend usage with cache metrics (Claude top-level + OpenAI prompt_tokens_details)
-            if (totalUsage && response.usage) {
-                totalUsage = extendUsageWithCacheMetrics(totalUsage, response.usage);
-            }
             const result = {};
             if (finalMessage) {
                 const { content: finalContent, tool_calls: finalToolCalls, reasoning_content: finalReasoningContent, ...otherFields } = finalMessage;
@@ -353,14 +345,8 @@ async function processStreamingResponse(stream, onContentUpdate, onToolUpdate, o
             }
             // Check for usage information in any chunk
             if (chunk.usage) {
-                let chunkUsage = {
-                    prompt_tokens: chunk.usage.prompt_tokens,
-                    completion_tokens: chunk.usage.completion_tokens,
-                    total_tokens: chunk.usage.total_tokens,
-                };
-                // Extend usage with cache metrics (Claude top-level + OpenAI prompt_tokens_details)
-                chunkUsage = extendUsageWithCacheMetrics(chunkUsage, chunk.usage);
-                usage = chunkUsage;
+                // Extend usage with cache metrics from OpenAI prompt_tokens_details
+                usage = extendUsageWithCacheMetrics(chunk.usage);
             }
             // Check for finish_reason in the choice
             const choice = chunk.choices?.[0];

package/dist/services/configurationService.d.ts

@@ -196,6 +196,13 @@ export declare function mergeEnvironmentConfig(userEnv: Record<string, string> |
  * Supports both hooks and environment variables with proper validation
  */
 export declare function loadWaveConfigFromFile(filePath: string): WaveConfiguration | null;
+/**
+ * Load the user-level (~/.wave/settings.json) `env` block only — no workdir
+ * dependency. Used at daemon startup to apply WAVE_SERVER_URL before any agent
+ * initializes: auth queries (getAuthStatus) can run before the first agent,
+ * and AuthService falls back to the default URL otherwise.
+ */
+export declare function loadUserConfigEnv(): Record<string, string>;
 /**
  * Load and merge Wave configuration from both user and project sources
  * Project configuration takes precedence over user configuration

package/dist/services/configurationService.js

@@ -1079,6 +1079,16 @@ export function loadWaveConfigFromFile(filePath) {
         throw error;
     }
 }
+/**
+ * Load the user-level (~/.wave/settings.json) `env` block only — no workdir
+ * dependency. Used at daemon startup to apply WAVE_SERVER_URL before any agent
+ * initializes: auth queries (getAuthStatus) can run before the first agent,
+ * and AuthService falls back to the default URL otherwise.
+ */
+export function loadUserConfigEnv() {
+    const config = loadWaveConfigFromFile(getUserConfigPaths()[0]);
+    return config?.env ?? {};
+}
 /**
  * Load and merge Wave configuration from both user and project sources
  * Project configuration takes precedence over user configuration

package/dist/telemetry/instrumentation.d.ts

@@ -5,7 +5,7 @@
  * and graceful shutdown for Wave's OpenTelemetry integration.
  */
 import type { TelemetryConfig } from "../types/telemetry.js";
-import type { SpanExporter, ReadableSpan } from "@opentelemetry/sdk-trace-node";
+import type { SpanExporter, ReadableSpan } from "@opentelemetry/sdk-trace-base";
 import type { LogRecordExporter, ReadableLogRecord } from "@opentelemetry/sdk-logs";
 /**
  * Resolve the full TelemetryConfig from env vars + settings.json.

package/dist/telemetry/instrumentation.js

@@ -8,13 +8,17 @@ import { logger } from "../utils/globalLogger.js";
 import * as fs from "node:fs";
 import { AuthService, getOrCreateAnonymousId, } from "../services/authService.js";
 // Lazy-loaded OTEL modules — only imported when telemetry is initialized
-let sdkNode;
+let sdkTraceBase;
+let otelResources;
 let api;
+let apiLogs;
 let sdkLogs;
 let exporterTraceOtlpHttp;
 let exporterLogsOtlpHttp;
-/** Internal SDK instance */
-let otelSdk;
+/** Internal trace provider instance */
+let tracerProvider;
+/** Internal log provider instance */
+let loggerProvider;
 /** Whether telemetry has been initialized */
 let initialized = false;
 /** Current resolved config */
@@ -34,14 +38,23 @@ function resolveTelemetryFilePath() {
 async function loadOTELModules() {
     if (api)
         return; // Already loaded
-    [sdkNode, api, sdkLogs, exporterTraceOtlpHttp, exporterLogsOtlpHttp] =
-        await Promise.all([
-            import("@opentelemetry/sdk-node"),
-            import("@opentelemetry/api"),
-            import("@opentelemetry/sdk-logs"),
-            import("@opentelemetry/exporter-trace-otlp-http"),
-            import("@opentelemetry/exporter-logs-otlp-http"),
-        ]);
+    [
+        sdkTraceBase,
+        otelResources,
+        api,
+        apiLogs,
+        sdkLogs,
+        exporterTraceOtlpHttp,
+        exporterLogsOtlpHttp,
+    ] = await Promise.all([
+        import("@opentelemetry/sdk-trace-base"),
+        import("@opentelemetry/resources"),
+        import("@opentelemetry/api"),
+        import("@opentelemetry/api-logs"),
+        import("@opentelemetry/sdk-logs"),
+        import("@opentelemetry/exporter-trace-otlp-http"),
+        import("@opentelemetry/exporter-logs-otlp-http"),
+    ]);
 }
 /**
  * Resolve the exporter target from environment variable or config.
@@ -281,33 +294,43 @@ export async function initializeTelemetry(config) {
             return;
         }
         const { tracesExporter, logsExporter } = currentConfig;
-        // Build resource attributes using new API (sdk-node 0.217+)
-        const { resources } = sdkNode;
-        const resource = resources.defaultResource().merge(resources.resourceFromAttributes({
+        // Build resource attributes (lightweight assembly: sdk-trace-base + resources)
+        const resource = otelResources.defaultResource().merge(otelResources.resourceFromAttributes({
             "service.name": "wave",
             "service.version": process.env.npm_package_version || "unknown",
             "os.type": process.platform,
             "host.arch": process.arch,
         }));
-        // Configure trace provider
-        const nodeSdkOptions = { resource };
+        const spanProcessors = [];
         if (tracesExporter === "otlp" && currentConfig.endpoint) {
-            nodeSdkOptions.traceExporter = createOTLPTraceExporter(currentConfig);
+            spanProcessors.push(new sdkTraceBase.BatchSpanProcessor(createOTLPTraceExporter(currentConfig)));
         }
         else if (tracesExporter === "jsonl") {
-            nodeSdkOptions.traceExporter = new JsonlSpanExporter();
+            spanProcessors.push(new sdkTraceBase.BatchSpanProcessor(new JsonlSpanExporter()));
         }
-        // Configure logs provider
+        const logProcessors = [];
         if (logsExporter === "otlp" && currentConfig.endpoint) {
-            nodeSdkOptions.logRecordProcessor = new sdkLogs.BatchLogRecordProcessor(createOTLPLogExporter(currentConfig));
+            logProcessors.push(new sdkLogs.BatchLogRecordProcessor(createOTLPLogExporter(currentConfig)));
         }
         else if (logsExporter === "jsonl") {
-            nodeSdkOptions.logRecordProcessor = new sdkLogs.BatchLogRecordProcessor(new JsonlLogExporter());
+            logProcessors.push(new sdkLogs.BatchLogRecordProcessor(new JsonlLogExporter()));
         }
-        // Only initialize SDK if at least one exporter is configured
-        if (nodeSdkOptions.traceExporter || nodeSdkOptions.logRecordProcessor) {
-            otelSdk = new sdkNode.NodeSDK(nodeSdkOptions);
-            await otelSdk.start();
+        // Only initialize providers if at least one exporter is configured
+        if (spanProcessors.length > 0 || logProcessors.length > 0) {
+            if (spanProcessors.length > 0) {
+                tracerProvider = new sdkTraceBase.BasicTracerProvider({
+                    resource,
+                    spanProcessors,
+                });
+                api.trace.setGlobalTracerProvider(tracerProvider);
+            }
+            if (logProcessors.length > 0) {
+                loggerProvider = new sdkLogs.LoggerProvider({
+                    resource,
+                    processors: logProcessors,
+                });
+                apiLogs.logs.setGlobalLoggerProvider(loggerProvider);
+            }
             initialized = true;
             logger?.info("OpenTelemetry initialized", {
                 tracesExporter,
@@ -329,7 +352,7 @@ export async function initializeTelemetry(config) {
  * Respects shutdownTimeoutMs config.
  */
 export async function shutdownTelemetry() {
-    if (!otelSdk || !initialized) {
+    if (!tracerProvider && !loggerProvider) {
         return;
     }
     try {
@@ -337,14 +360,20 @@ export async function shutdownTelemetry() {
         const timeoutPromise = new Promise((_, reject) => {
             setTimeout(() => reject(new Error("Telemetry shutdown timed out")), timeout);
         });
-        await Promise.race([otelSdk.shutdown(), timeoutPromise]);
+        const shutdowns = [];
+        if (tracerProvider)
+            shutdowns.push(tracerProvider.shutdown());
+        if (loggerProvider)
+            shutdowns.push(loggerProvider.shutdown());
+        await Promise.race([Promise.all(shutdowns), timeoutPromise]);
         logger?.debug("OpenTelemetry shut down successfully");
     }
     catch (error) {
         logger?.warn("OpenTelemetry shutdown failed:", error);
     }
     finally {
-        otelSdk = undefined;
+        tracerProvider = undefined;
+        loggerProvider = undefined;
         initialized = false;
         currentConfig = undefined;
     }

package/dist/tools/bashTool.js

@@ -152,6 +152,13 @@ The working directory persists between commands. Try to maintain your current wo
                 error: "Command parameter is required and must be a string",
             };
         }
+        // If the session cwd was auto-recovered (e.g. the previous worktree
+        // directory was removed manually via `git worktree remove`), surface
+        // the notice in this tool's result so the model is aware of the switch.
+        const cwdRecovery = context.aiManager?.consumeCwdRecovery?.();
+        const recoveryNotice = cwdRecovery
+            ? `Note: working directory ${cwdRecovery.from} no longer exists; session working directory recovered to ${cwdRecovery.to}.\n`
+            : "";
         // Resolve shell path: on Windows, use Git Bash; on macOS/Linux, use bash or zsh
         const shellPath = resolveShellPath();
         if (!shellPath) {
@@ -221,7 +228,7 @@ The working directory persists between commands. Try to maintain your current wo
             ].join("\n");
             return {
                 success: true,
-                content: backgroundMsg,
+                content: recoveryNotice + backgroundMsg,
                 shortResult: `Background process ${taskId} started${outputPath ? ` → ${outputPath}` : ""}`,
             };
         }
@@ -387,9 +394,11 @@ The working directory persists between commands. Try to maintain your current wo
                     const processedOutput = processToolResult(outputBuffer + (errorBuffer ? "\n" + errorBuffer : ""), BASH_MAX_OUTPUT_CHARS, "bash");
                     resolve({
                         success: false,
-                        content: processedOutput
-                            ? `${processedOutput}\n\n${reason}`
-                            : reason,
+                        content: recoveryNotice
+                            ? recoveryNotice + (processedOutput || reason)
+                            : processedOutput
+                                ? `${processedOutput}\n\n${reason}`
+                                : reason,
                         error: reason,
                     });
                 }
@@ -460,7 +469,8 @@ The working directory persists between commands. Try to maintain your current wo
                     const exitCode = code ?? 0;
                     const combinedOutput = outputBuffer + (errorBuffer ? "\n" + errorBuffer : "");
                     // Prepend CWD change message to output if present
-                    const finalOutput = (cwdMessage ? cwdMessage + "\n" : "") +
+                    const finalOutput = recoveryNotice +
+                        (cwdMessage ? cwdMessage + "\n" : "") +
                         (combinedOutput || `Command executed with exit code: ${exitCode}`);
                     const content = processToolResult(finalOutput, BASH_MAX_OUTPUT_CHARS, "bash");
                     const lines = combinedOutput.trim().split("\n");
@@ -490,7 +500,7 @@ The working directory persists between commands. Try to maintain your current wo
                     resolve({
                         success: false,
                         content: "",
-                        error: `Failed to execute command: ${error.message}`,
+                        error: `${recoveryNotice}Failed to execute command: ${error.message}`.trim(),
                     });
                 }
             });

package/dist/tools/grepTool.js

@@ -131,6 +131,13 @@ export const grepTool = {
         }
         try {
             const workdir = context.workdir;
+            // If the session cwd was auto-recovered (e.g. the previous worktree
+            // directory was removed manually via `git worktree remove`), surface
+            // the notice in this tool's result so the model is aware of the switch.
+            const cwdRecovery = context.aiManager?.consumeCwdRecovery?.();
+            const recoveryNotice = cwdRecovery
+                ? `Note: working directory ${cwdRecovery.from} no longer exists; session working directory recovered to ${cwdRecovery.to}.\n`
+                : "";
             const rgArgs = [
                 "--color=never",
                 "--max-columns=500",
@@ -207,7 +214,7 @@ export const grepTool = {
                 return {
                     success: false,
                     content: "",
-                    error: `ripgrep failed: ${result.stderr}`,
+                    error: `${recoveryNotice}ripgrep failed: ${result.stderr}`.trim(),
                 };
             }
             if (result.exitCode !== 0 && result.exitCode !== 1) {
@@ -217,7 +224,8 @@ export const grepTool = {
             if (!output) {
                 return {
                     success: true,
-                    content: "No matches found. Suggestion: specify the 'path' field to search in ignored or other directories (e.g., 'node_modules'), as the default search path is the current working directory and respects .gitignore.",
+                    content: recoveryNotice +
+                        "No matches found. Suggestion: specify the 'path' field to search in ignored or other directories (e.g., 'node_modules'), as the default search path is the current working directory and respects .gitignore.",
                     shortResult: "No matches found",
                     metadata: {
                         numMatches: 0,
@@ -256,7 +264,7 @@ export const grepTool = {
             }
             return {
                 success: true,
-                content: finalOutput,
+                content: recoveryNotice + finalOutput,
                 shortResult,
                 metadata: {
                     numMatches: totalMatches,

package/dist/types/core.d.ts

@@ -2,7 +2,6 @@
  * Core foundational types used across multiple domains
  * Dependencies: None (foundation layer)
  */
-import type { CompletionUsage } from "openai/resources";
 /**
  * Logger interface definition
  * Compatible with OpenAI package Logger interface
@@ -15,7 +14,7 @@ export interface Logger {
 }
 /**
  * Usage statistics for AI operations
- * Extends OpenAI's Usage format with additional tracking fields
+ * Extends OpenAI's Usage format with normalized cache fields
  */
 export interface Usage {
     prompt_tokens: number;
@@ -25,38 +24,6 @@ export interface Usage {
     operation_type?: "agent" | "compact";
     cache_read_input_tokens?: number;
     cache_creation_input_tokens?: number;
-    cache_creation?: {
-        ephemeral_5m_input_tokens: number;
-        ephemeral_1h_input_tokens: number;
-    };
-}
-/**
- * Enhanced usage metrics including Claude cache information
- * Backward compatible with standard OpenAI CompletionUsage
- */
-export interface ClaudeUsage extends CompletionUsage {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-    /**
-     * Number of tokens read from existing cache
-     * Indicates cost savings from cache hits
-     */
-    cache_read_input_tokens?: number;
-    /**
-     * Number of tokens used to create new cache entries
-     * Investment in future cache hits
-     */
-    cache_creation_input_tokens?: number;
-    /**
-     * Detailed breakdown of cache creation by duration
-     */
-    cache_creation?: {
-        /** Tokens cached for 5 minute duration */
-        ephemeral_5m_input_tokens: number;
-        /** Tokens cached for 1 hour duration */
-        ephemeral_1h_input_tokens: number;
-    };
 }
 /**
  * Represents a diff change for tool parameter-based diff display

package/dist/types/index.d.ts

@@ -35,3 +35,7 @@ export * from "./cron.js";
 export * from "./telemetry.js";
 export * from "./auth.js";
 export * from "./workflow.js";
+export type { SessionMetadata, SessionData } from "../services/session.js";
+export type { ToolBlockUpdateCallbackParams } from "../utils/messageOperations.js";
+export type { QueuedMessage } from "../managers/messageQueue.js";
+export type { SubagentConfiguration } from "../utils/subagentParser.js";

package/dist/types/messaging.d.ts

@@ -88,4 +88,6 @@ export interface TaskNotificationBlock {
     status: "completed" | "failed" | "killed" | "aborted";
     summary: string;
     outputFile?: string;
+    /** Full final response of the task (e.g. a fork subagent's result). */
+    result?: string;
 }

package/dist/utils/cacheControlUtils.d.ts

@@ -7,6 +7,7 @@
  */
 import type { ChatCompletionMessageParam, ChatCompletionContentPart, ChatCompletionContentPartText, CompletionUsage } from "openai/resources";
 import type { ModelCapabilities } from "../types/config.js";
+import type { Usage } from "../types/core.js";
 /**
  * Cache control directive for Claude models
  */
@@ -28,22 +29,6 @@ export interface ClaudeChatCompletionContentPartText extends ChatCompletionConte
 export interface ExtendedPromptTokensDetails extends CompletionUsage.PromptTokensDetails {
     cache_creation_input_tokens?: number;
 }
-/**
- * Enhanced usage metrics including cache information
- * Supports both Claude-specific top-level fields and OpenAI-standard prompt_tokens_details
- */
-export interface ClaudeUsage extends CompletionUsage {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-    cache_read_input_tokens?: number;
-    cache_creation_input_tokens?: number;
-    cache_creation?: {
-        ephemeral_5m_input_tokens: number;
-        ephemeral_1h_input_tokens: number;
-    };
-    prompt_tokens_details?: ExtendedPromptTokensDetails;
-}
 /**
  * Validates cache control structure
  * @param control - Object to validate
@@ -85,16 +70,9 @@ export declare function countContentBlocks(messages: ChatCompletionMessageParam[
 export declare function transformMessagesForExplicitCache(messages: ChatCompletionMessageParam[], capabilities?: ModelCapabilities): ChatCompletionMessageParam[];
 /**
  * Extends standard usage with cache metrics
- * Extracts cache tokens from both Claude-specific top-level fields and
- * OpenAI-standard prompt_tokens_details (used by Gemini, DeepSeek, etc.)
- * @param standardUsage - OpenAI usage response
- * @param cacheMetrics - Additional cache metrics from the API response
+ * Extracts cache tokens from OpenAI-standard prompt_tokens_details
+ * (cached_tokens and the gateway-provided cache_creation_input_tokens)
+ * @param usage - OpenAI usage response
  * @returns Extended usage with cache information
  */
-export declare function extendUsageWithCacheMetrics(standardUsage: CompletionUsage, cacheMetrics?: Partial<ClaudeUsage>): ClaudeUsage;
-/**
- * Validates Claude usage structure
- * @param usage - Usage object to validate
- * @returns True if usage structure is valid
- */
-export declare function isValidClaudeUsage(usage: unknown): usage is ClaudeUsage;
+export declare function extendUsageWithCacheMetrics(usage: CompletionUsage): Usage;

package/dist/utils/cacheControlUtils.js

@@ -207,84 +207,23 @@ export function transformMessagesForExplicitCache(messages, capabilities) {
 }
 /**
  * Extends standard usage with cache metrics
- * Extracts cache tokens from both Claude-specific top-level fields and
- * OpenAI-standard prompt_tokens_details (used by Gemini, DeepSeek, etc.)
- * @param standardUsage - OpenAI usage response
- * @param cacheMetrics - Additional cache metrics from the API response
+ * Extracts cache tokens from OpenAI-standard prompt_tokens_details
+ * (cached_tokens and the gateway-provided cache_creation_input_tokens)
+ * @param usage - OpenAI usage response
  * @returns Extended usage with cache information
  */
-export function extendUsageWithCacheMetrics(standardUsage, cacheMetrics) {
+export function extendUsageWithCacheMetrics(usage) {
     const baseUsage = {
-        prompt_tokens: standardUsage.prompt_tokens,
-        completion_tokens: standardUsage.completion_tokens,
-        total_tokens: standardUsage.total_tokens,
+        prompt_tokens: usage.prompt_tokens,
+        completion_tokens: usage.completion_tokens,
+        total_tokens: usage.total_tokens,
     };
-    if (!cacheMetrics) {
-        return baseUsage;
+    const details = usage.prompt_tokens_details;
+    if (details?.cached_tokens != null) {
+        baseUsage.cache_read_input_tokens = details.cached_tokens;
     }
-    // Extract cache_read_input_tokens from Claude top-level field
-    if (typeof cacheMetrics.cache_read_input_tokens === "number") {
-        baseUsage.cache_read_input_tokens = cacheMetrics.cache_read_input_tokens;
-    }
-    // Fallback to prompt_tokens_details.cached_tokens (OpenAI standard)
-    else if (cacheMetrics.prompt_tokens_details?.cached_tokens != null) {
-        baseUsage.cache_read_input_tokens =
-            cacheMetrics.prompt_tokens_details.cached_tokens;
-    }
-    // Extract cache_creation_input_tokens from Claude top-level field
-    if (typeof cacheMetrics.cache_creation_input_tokens === "number") {
-        baseUsage.cache_creation_input_tokens =
-            cacheMetrics.cache_creation_input_tokens;
-    }
-    // Fallback to prompt_tokens_details.cache_creation_input_tokens
-    else if (cacheMetrics.prompt_tokens_details?.cache_creation_input_tokens != null) {
-        baseUsage.cache_creation_input_tokens =
-            cacheMetrics.prompt_tokens_details.cache_creation_input_tokens;
-    }
-    // Extract cache_creation breakdown (Claude-specific)
-    if (cacheMetrics.cache_creation &&
-        typeof cacheMetrics.cache_creation.ephemeral_5m_input_tokens === "number" &&
-        typeof cacheMetrics.cache_creation.ephemeral_1h_input_tokens === "number") {
-        baseUsage.cache_creation = {
-            ephemeral_5m_input_tokens: cacheMetrics.cache_creation.ephemeral_5m_input_tokens,
-            ephemeral_1h_input_tokens: cacheMetrics.cache_creation.ephemeral_1h_input_tokens,
-        };
+    if (details?.cache_creation_input_tokens != null) {
+        baseUsage.cache_creation_input_tokens = details.cache_creation_input_tokens;
     }
     return baseUsage;
 }
-/**
- * Validates Claude usage structure
- * @param usage - Usage object to validate
- * @returns True if usage structure is valid
- */
-export function isValidClaudeUsage(usage) {
-    if (!usage || typeof usage !== "object") {
-        return false;
-    }
-    const usageObj = usage;
-    // Check required standard fields
-    const hasStandardFields = typeof usageObj.prompt_tokens === "number" &&
-        typeof usageObj.completion_tokens === "number" &&
-        typeof usageObj.total_tokens === "number";
-    if (!hasStandardFields) {
-        return false;
-    }
-    // Check optional cache fields
-    const hasCacheFields = (usageObj.cache_read_input_tokens === undefined ||
-        typeof usageObj.cache_read_input_tokens === "number") &&
-        (usageObj.cache_creation_input_tokens === undefined ||
-            typeof usageObj.cache_creation_input_tokens === "number");
-    if (!hasCacheFields) {
-        return false;
-    }
-    // Check cache_creation object if present
-    if (usageObj.cache_creation !== undefined) {
-        const cacheCreation = usageObj.cache_creation;
-        if (typeof cacheCreation !== "object" ||
-            typeof cacheCreation.ephemeral_5m_input_tokens !== "number" ||
-            typeof cacheCreation.ephemeral_1h_input_tokens !== "number") {
-            return false;
-        }
-    }
-    return true;
-}

package/dist/utils/containerSetup.js

@@ -20,7 +20,6 @@ import { WorkflowManager } from "../managers/workflowManager.js";
 import { MemoryRuleManager } from "../managers/MemoryRuleManager.js";
 import { ReversionManager } from "../managers/reversionManager.js";
 import { SubagentManager } from "../managers/subagentManager.js";
-import { ForkedAgentManager } from "../managers/forkedAgentManager.js";
 import { LiveConfigManager } from "../managers/liveConfigManager.js";
 import { ReversionService } from "../services/reversionService.js";
 import { cleanupMetaOnlySessions } from "../services/session.js";
@@ -245,8 +244,6 @@ export function setupAgentContainer(setupOptions) {
         stream,
     });
     container.register("SubagentManager", subagentManager);
-    const forkedAgentManager = new ForkedAgentManager(container);
-    container.register("ForkedAgentManager", forkedAgentManager);
     const aiManager = new AIManager(container, {
         callbacks: {
             ...callbacks,

package/dist/utils/messageOperations.d.ts

@@ -132,5 +132,6 @@ export interface AddNotificationMessageParams {
     status: "completed" | "failed" | "killed" | "aborted";
     summary: string;
     outputFile?: string;
+    result?: string;
 }
-export declare const addNotificationMessageToMessages: ({ messages, taskId, taskType, status, summary, outputFile, }: AddNotificationMessageParams) => Message[];
+export declare const addNotificationMessageToMessages: ({ messages, taskId, taskType, status, summary, outputFile, result, }: AddNotificationMessageParams) => Message[];