wave-agent-sdk 0.17.1 → 0.17.3

package/src/tools/workflowTool.ts

@@ -0,0 +1,205 @@
+import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
+import { WORKFLOW_TOOL_NAME } from "../constants/tools.js";
+import { logger } from "../utils/globalLogger.js";
+
+/**
+ * Workflow tool plugin for executing deterministic multi-subagent orchestration scripts.
+ *
+ * The AI model calls this tool with a JavaScript script that orchestrates
+ * multiple subagents via agent(), parallel(), pipeline(), phase(), log() APIs.
+ * Workflows run in the background — the tool returns immediately with a run ID,
+ * and a <task-notification> arrives when the workflow completes.
+ */
+export const workflowTool: ToolPlugin = {
+  name: WORKFLOW_TOOL_NAME,
+  config: {
+    type: "function" as const,
+    function: {
+      name: WORKFLOW_TOOL_NAME,
+      description:
+        "Execute a workflow script that orchestrates multiple subagents deterministically. Workflows run in the background — this tool returns immediately with a run ID, and a <task-notification> arrives when the workflow completes. Use /workflows to watch live progress.",
+      parameters: {
+        type: "object",
+        properties: {
+          script: {
+            type: "string",
+            description:
+              "Inline workflow script (JavaScript). Must start with 'export const meta = {name, description, phases}'. Pass the script inline — do not Write it to a file first. Every Workflow invocation automatically persists its script.",
+          },
+          scriptPath: {
+            type: "string",
+            description:
+              "Path to a saved workflow script file. Use this to re-run or iterate on a previously saved script. One of 'script' or 'scriptPath' is required.",
+          },
+          args: {
+            description:
+              "Arguments passed to the workflow script as the `args` global. Pass arrays/objects as actual JSON values, NOT as a JSON-encoded string.",
+          },
+          resumeFromRunId: {
+            type: "string",
+            description:
+              "Resume from a previous run's journal. Cached agent results are replayed instantly; the first edited/new call and everything after it runs live.",
+          },
+        },
+      },
+    },
+  },
+
+  prompt: () =>
+    `Execute a workflow script that orchestrates multiple subagents deterministically. Workflows run in the background — this tool returns immediately with a task ID, and a <task-notification> arrives when the workflow completes. Use /workflows to watch live progress.
+
+A workflow structures work across many agents — to be comprehensive (decompose and cover in parallel), to be confident (independent perspectives and adversarial checks before committing), or to take on scale one context can't hold (migrations, audits, broad sweeps). The script is where you encode that structure: what fans out, what verifies, what synthesizes.
+
+ONLY call this tool when the user has explicitly opted into multi-agent orchestration. Workflows can spawn dozens of agents and consume a large amount of tokens; the user must request that scale, not have it inferred. Explicit opt-in means one of:
+- The user directly asked you to run a workflow or use multi-agent orchestration in their own words ("use a workflow", "run a workflow", "fan out agents", "orchestrate this with subagents"). The ask must be in the user's words — a task that would merely benefit from a workflow does not count.
+- The user invoked a skill or slash command whose instructions tell you to call Workflow.
+- The user asked you to run a specific named or saved workflow.
+
+For any other task — even one that would clearly benefit from parallelism — do NOT call this tool. Use the Agent tool for individual subagents, or briefly describe what a multi-agent workflow could do and how much it would roughly cost, and ask the user whether to run it.
+
+When you do call it, the right move is often **hybrid**: scout inline first (list the files, find the channels, scope the diff) to discover the work-list, then call Workflow to pipeline over it.
+
+Common single-phase workflows you can chain across turns:
+- **Understand** — parallel readers over relevant subsystems → structured map
+- **Design** — judge panel of N independent approaches → scored synthesis
+- **Review** — dimensions → find → adversarially verify
+- **Research** — multi-modal sweep → deep-read → synthesize
+- **Migrate** — discover sites → transform each (worktree isolation) → verify
+
+For larger work, run several in sequence — read each result before deciding the next phase.
+
+Every script must begin with \`export const meta = {...}\`:
+  export const meta = {
+    name: 'find-flaky-tests',
+    description: 'Find flaky tests and propose fixes',
+    phases: [
+      { title: 'Scan', detail: 'grep test logs for retries' },
+      { title: 'Fix', detail: 'one agent per flaky test' },
+    ],
+  }
+  // script body starts here — use agent()/parallel()/pipeline()/phase()/log()
+
+Script body hooks:
+- **agent(prompt, opts?)**: Promise<any> — spawn a subagent. Without schema, returns its final text as a string. With schema (a JSON Schema), the subagent is forced to call a StructuredOutput tool and agent() returns the validated object — no parsing needed. Returns null if the user skips the agent mid-run or the subagent dies on a terminal API error (filter with .filter(Boolean)). opts.label overrides the display label. opts.phase assigns this agent to a progress group. opts.model overrides the model for this agent call. opts.agentType uses a custom subagent type instead of the default.
+- **pipeline(items, stage1, stage2, ...)**: Promise<any[]> — run each item through all stages independently, NO barrier between stages. Item A can be in stage 3 while item B is still in stage 1. This is the DEFAULT for multi-stage work. Every stage callback receives (prevResult, originalItem, index). In the first stage prevResult is undefined; in later stages it is the return value of the previous stage. A stage that throws drops that item to null. Example single-stage: \`pipeline(files, (prev, file) => agent('Read ' + file))\`. Example two-stage: \`pipeline(files, (prev, file) => agent('Read ' + file), (prev, file) => agent('Summarize: ' + prev))\`.
+- **parallel(thunks: Array<() => Promise<any>>)**: Promise<any[]> — run tasks concurrently. This is a BARRIER: awaits all thunks before returning. A thunk that throws resolves to null in the result array. Use ONLY when you genuinely need all results together.
+- **log(message: string)**: void — emit a progress message
+- **phase(title: string)**: void — start a new phase; subsequent agent() calls are grouped under this title
+- **args**: any — the value passed as Workflow's args input, verbatim
+- **budget**: {total: number|null, spent(): number, remaining(): number} — the turn's token target
+
+Scripts are plain JavaScript, NOT TypeScript — type annotations fail to parse. The script body runs in an async context — use await directly. Standard JS built-ins (JSON, Math, Array, etc.) are available — EXCEPT Date.now()/Math.random()/argless new Date(), which throw (they would break resume). No filesystem or Node.js API access.
+
+DEFAULT TO pipeline(). Only reach for a barrier (parallel between stages) when you genuinely need ALL prior-stage results together.
+
+Concurrent agent() calls are capped at min(16, cpu cores - 2) per workflow. Total agent count is capped at 1000 per run. A single parallel()/pipeline() call accepts at most 4096 items.
+
+Quality patterns:
+- **Adversarial verify**: spawn N independent skeptics per finding, each prompted to REFUTE. Kill if >=majority refute.
+- **Judge panel**: generate N independent approaches, score with parallel judges, synthesize from the winner.
+- **Loop-until-dry**: keep spawning finders until K consecutive rounds return nothing new.
+- **Multi-modal sweep**: parallel agents each searching a different way (by-container, by-content, by-entity).
+- **Completeness critic**: a final agent that asks "what's missing?" — findings become next round of work.
+- **No silent caps**: if a workflow bounds coverage, log() what was dropped.
+
+## Resume
+
+The tool result includes a runId. To resume after a pause, kill, or script edit, relaunch with Workflow({scriptPath, resumeFromRunId}) — the longest unchanged prefix of agent() calls returns cached results instantly; the first edited/new call and everything after it runs live.
+
+Use this tool for multi-step orchestration where control flow should be deterministic (loops, conditionals, fan-out) rather than model-driven.`,
+
+  execute: async (
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    const workflowManager = context.workflowManager;
+    if (!workflowManager) {
+      return {
+        success: false,
+        content: "",
+        error: "Workflow manager not available in tool context",
+        shortResult: "Workflow execution failed",
+      };
+    }
+
+    const script = args.script as string | undefined;
+    const scriptPath = args.scriptPath as string | undefined;
+    const workflowArgs = args.args;
+    const resumeFromRunId = args.resumeFromRunId as string | undefined;
+
+    // Resolve script text
+    let scriptText: string;
+    if (script) {
+      scriptText = script;
+    } else if (scriptPath) {
+      try {
+        const fs = await import("fs/promises");
+        scriptText = await fs.readFile(scriptPath, "utf-8");
+      } catch (error) {
+        return {
+          success: false,
+          content: "",
+          error: `Failed to read script file: ${error instanceof Error ? error.message : String(error)}`,
+          shortResult: "Workflow script read failed",
+        };
+      }
+    } else {
+      return {
+        success: false,
+        content: "",
+        error: "Either 'script' or 'scriptPath' parameter is required",
+        shortResult: "Workflow execution failed",
+      };
+    }
+
+    try {
+      // Create run
+      const run = await workflowManager.createRun(scriptText, workflowArgs, {
+        resumeFromRunId,
+      });
+
+      // Start execution in background
+      await workflowManager.startRun(run.runId);
+
+      return {
+        success: true,
+        content: [
+          `Workflow started with run ID: ${run.runId}`,
+          `Name: ${run.meta.name}`,
+          `Description: ${run.meta.description}`,
+          run.meta.phases?.length
+            ? `Phases: ${run.meta.phases.map((p) => p.title).join(" → ")}`
+            : "",
+          `The workflow is running in the background. You will be notified automatically when it completes.`,
+          `Use /workflows to watch live progress.`,
+          `Script saved to: ${run.scriptPath}`,
+        ]
+          .filter(Boolean)
+          .join("\n"),
+        shortResult: `Workflow started: ${run.meta.name} (${run.runId})`,
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`[Workflow Tool] execution failed: ${msg}`);
+      return {
+        success: false,
+        content: `Workflow failed: ${msg}. Fix the error and try again.`,
+        error: `Workflow execution failed: ${msg}`,
+        shortResult: "Workflow execution failed",
+      };
+    }
+  },
+
+  formatCompactParams: (params: Record<string, unknown>) => {
+    if (params.scriptPath) {
+      return `scriptPath: ${params.scriptPath}`;
+    }
+    const script = params.script as string;
+    if (script) {
+      // Extract meta.name from the script
+      const nameMatch = script.match(/name:\s*['"]([^'"]+)['"]/);
+      return nameMatch ? nameMatch[1] : script.slice(0, 50) + "...";
+    }
+    return "workflow";
+  },
+};

package/src/types/agent.ts

@@ -121,4 +121,10 @@ export interface AgentCallbacks
   onCommandRunningChange?: (running: boolean) => void;
   onWorkdirChange?: (newCwd: string) => void;
   onQueuedMessagesChange?: (messages: QueuedMessage[]) => void;
+  onGoalStateChange?: (
+    active: boolean,
+    condition?: string,
+    elapsed?: string,
+  ) => void;
+  onGoalEvaluating?: (evaluating: boolean) => void;
 }

package/src/types/commands.ts

@@ -8,6 +8,10 @@ export interface SlashCommand {
   name: string;
   description: string;
   handler: (args?: string, signal?: AbortSignal) => Promise<void> | void;
+  /** Whether this command should bypass the message queue when AI is busy.
+   * - `true`: always immediate
+   * - Function: receives args, returns true for immediate variants */
+  immediate?: boolean | ((args?: string) => boolean);
 }
 
 export interface CustomSlashCommandConfig {

package/src/types/config.ts

@@ -15,8 +15,8 @@ export interface GatewayConfig {
 }
 
 export interface ModelConfig {
-  model: string;
-  fastModel: string;
+  model?: string;
+  fastModel?: string;
   maxTokens?: number;
   permissionMode?: PermissionMode;
   [key: string]: unknown;

package/src/types/core.ts

@@ -25,10 +25,10 @@ export interface Usage {
   completion_tokens: number; // Tokens generated in completions
   total_tokens: number; // Sum of prompt + completion tokens
   model?: string; // Model used for the operation (e.g., "gpt-4", "gpt-3.5-turbo")
-  operation_type?: "agent" | "compact"; // Type of operation that generated usage
+  operation_type?: "agent" | "compact" | "goal_evaluation"; // Type of operation that generated usage
 
-  // Cache-related tokens (Claude models only)
-  cache_read_input_tokens?: number; // Tokens read from cache
+  // Cache-related tokens (Claude top-level + OpenAI prompt_tokens_details)
+  cache_read_input_tokens?: number; // Tokens read from cache (Claude) or cached_tokens (OpenAI prompt_tokens_details)
   cache_creation_input_tokens?: number; // Tokens used to create cache entries
   cache_creation?: {
     ephemeral_5m_input_tokens: number; // Tokens cached for 5 minutes

package/src/types/hooks.ts

@@ -51,6 +51,7 @@ export interface HookExecutionContext {
   timestamp: Date;
   worktreeName?: string; // Present for WorktreeCreate
   worktreePath?: string; // Present for WorktreeRemove
+  planFilePath?: string; // Present when in plan mode
 }
 
 // Result of hook execution
@@ -183,6 +184,7 @@ export interface HookJsonInput {
   tool_name?: string; // Present for PreToolUse, PostToolUse, PermissionRequest
   tool_input?: unknown; // Present for PreToolUse, PostToolUse, PermissionRequest
   tool_response?: unknown; // Present for PostToolUse only
+  plan_file_path?: string; // Present when in plan mode
   user_prompt?: string; // Present for UserPromptSubmit only
   subagent_type?: string; // Present when hook is executed by a subagent
   name?: string; // Present for WorktreeCreate events

package/src/types/index.ts

@@ -38,3 +38,4 @@ export * from "./agent.js";
 export * from "./cron.js";
 export * from "./telemetry.js";
 export * from "./auth.js";
+export * from "./workflow.js";

package/src/types/messaging.ts

@@ -106,8 +106,8 @@ export interface FileHistoryBlock {
 export interface TaskNotificationBlock {
   type: "task_notification";
   taskId: string;
-  taskType: "shell" | "agent";
-  status: "completed" | "failed" | "killed";
+  taskType: "shell" | "agent" | "workflow";
+  status: "completed" | "failed" | "killed" | "aborted";
   summary: string;
   outputFile?: string;
 }

package/src/types/processes.ts

@@ -10,7 +10,7 @@ export type BackgroundTaskStatus =
   | "completed"
   | "failed"
   | "killed";
-export type BackgroundTaskType = "shell" | "subagent";
+export type BackgroundTaskType = "shell" | "subagent" | "workflow";
 
 export interface BackgroundTaskBase {
   id: string;
@@ -49,7 +49,15 @@ export interface BackgroundSubagent extends BackgroundTaskBase {
   type: "subagent";
 }
 
-export type BackgroundTask = BackgroundShell | BackgroundSubagent;
+export interface BackgroundWorkflow extends BackgroundTaskBase {
+  type: "workflow";
+  runId: string;
+}
+
+export type BackgroundTask =
+  | BackgroundShell
+  | BackgroundSubagent
+  | BackgroundWorkflow;
 
 export interface ForegroundTask {
   id: string;

package/src/types/workflow.ts

@@ -0,0 +1,5 @@
+export type {
+  WorkflowRun,
+  WorkflowMeta,
+  WorkflowPhaseState,
+} from "../workflow/types.js";

package/src/utils/cacheControlUtils.ts

@@ -11,7 +11,6 @@ import type {
   ChatCompletionContentPart,
   ChatCompletionContentPartText,
   ChatCompletionFunctionTool,
-  ChatCompletionMessageToolCall,
   CompletionUsage,
 } from "openai/resources";
 import { logger } from "./globalLogger.js";
@@ -48,20 +47,33 @@ export interface ClaudeChatCompletionFunctionTool
 }
 
 /**
- * Enhanced usage metrics including Claude cache information
+ * Extended prompt_tokens_details with cache_creation_input_tokens
+ * Some models (e.g. Gemini, DeepSeek) return this field inside prompt_tokens_details
+ */
+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;
 
-  // Claude cache extensions
-  cache_read_input_tokens?: number;
-  cache_creation_input_tokens?: number;
+  // Cache extensions (from Claude top-level or OpenAI prompt_tokens_details)
+  cache_read_input_tokens?: number; // Claude: cache_read_input_tokens / OpenAI: prompt_tokens_details.cached_tokens
+  cache_creation_input_tokens?: number; // Claude: cache_creation_input_tokens / OpenAI: prompt_tokens_details.cache_creation_input_tokens
   cache_creation?: {
     ephemeral_5m_input_tokens: number;
     ephemeral_1h_input_tokens: number;
   };
+
+  // Override prompt_tokens_details to include cache_creation_input_tokens
+  prompt_tokens_details?: ExtendedPromptTokensDetails;
 }
 
 // ============================================================================
@@ -122,30 +134,6 @@ export function isValidCacheControl(control: unknown): control is CacheControl {
   );
 }
 
-/**
- * Adds cache control to the last tool call in an array
- * @param toolCalls - Array of tool calls
- * @returns Tool calls array with cache control on the last tool call
- */
-function addCacheControlToLastToolCall(
-  toolCalls: ChatCompletionMessageToolCall[],
-): ChatCompletionMessageToolCall[] {
-  if (!toolCalls || toolCalls.length === 0) {
-    return toolCalls;
-  }
-
-  const result = [...toolCalls];
-  const lastIndex = result.length - 1;
-
-  // Add cache control to the last tool call
-  result[lastIndex] = {
-    ...result[lastIndex],
-    cache_control: { type: "ephemeral" },
-  } as ChatCompletionMessageToolCall & { cache_control: CacheControl };
-
-  return result;
-}
-
 /**
  * Adds cache control markers to message content
  * @param content - Original content (string or structured)
@@ -208,19 +196,36 @@ export function addCacheControlToContent(
     return [];
   }
 
-  // Handle structured content - preserve existing structure, add cache control to text parts
-  return content
-    .filter((part): part is ChatCompletionContentPartText => {
-      if (!part || typeof part !== "object") {
-        return false;
-      }
-      return part.type === "text" && typeof part.text === "string";
-    })
-    .map((part) => ({
-      type: "text",
-      text: part.text,
-      cache_control: { type: "ephemeral" },
-    }));
+  // Handle structured content - preserve all parts, add cache control to last text part only
+  let lastTextIndex = -1;
+  for (let i = content.length - 1; i >= 0; i--) {
+    const part = content[i];
+    if (
+      part &&
+      typeof part === "object" &&
+      part.type === "text" &&
+      typeof (part as ChatCompletionContentPartText).text === "string"
+    ) {
+      lastTextIndex = i;
+      break;
+    }
+  }
+
+  return content.map((part, index) => {
+    if (
+      index === lastTextIndex &&
+      part &&
+      typeof part === "object" &&
+      part.type === "text" &&
+      typeof (part as ChatCompletionContentPartText).text === "string"
+    ) {
+      return {
+        ...(part as ChatCompletionContentPartText),
+        cache_control: { type: "ephemeral" },
+      };
+    }
+    return part;
+  }) as ClaudeChatCompletionContentPartText[];
 }
 
 /**
@@ -272,35 +277,6 @@ export function addCacheControlToLastTool(
   return result;
 }
 
-/**
- * Finds the latest message index at 20-message intervals (sliding window approach)
- * @param messages - Array of chat completion messages
- * @returns Index of the latest interval message (20th, 40th, 60th, etc.) or -1 if none
- */
-export function findIntervalMessageIndex(
-  messages: ChatCompletionMessageParam[],
-): number {
-  if (!Array.isArray(messages) || messages.length === 0) {
-    return -1;
-  }
-
-  const interval = 20; // Hardcoded interval
-  const messageCount = messages.length;
-
-  // Find the largest interval that fits within the message count
-  // Math.floor(messageCount / interval) gives us how many complete intervals we have
-  // Multiply by interval to get the position of the latest interval message
-  const latestIntervalPosition = Math.floor(messageCount / interval) * interval;
-
-  // If no complete intervals exist, return -1
-  if (latestIntervalPosition === 0) {
-    return -1;
-  }
-
-  // Convert from 1-based position to 0-based index
-  return latestIntervalPosition - 1;
-}
-
 /**
  * Transforms messages for Claude cache control with hardcoded strategy
  * @param messages - Original OpenAI message array
@@ -328,12 +304,18 @@ export function transformMessagesForClaudeCache(
     return messages;
   }
 
-  // Find the latest interval message index (20th, 40th, 60th, etc.)
-  const intervalMessageIndex = findIntervalMessageIndex(messages);
-
   // Find first system message index
   const firstSystemIndex = messages.findIndex((m) => m.role === "system");
 
+  // Find last user message index
+  let lastUserIndex = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      lastUserIndex = i;
+      break;
+    }
+  }
+
   const result = messages.map((message, index) => {
     // Validate message structure
     if (!message || typeof message !== "object" || !message.role) {
@@ -365,40 +347,16 @@ export function transformMessagesForClaudeCache(
       } as ChatCompletionMessageParam;
     }
 
-    // Interval-based message caching: cache message at latest interval position (sliding window)
-    if (index === intervalMessageIndex) {
-      // If the message is a tool role, add cache control to the content block
-      if (message.role === "tool") {
-        const content =
-          typeof message.content === "string" ? message.content : "";
-        const transformedContent = addCacheControlToContent(content, true);
-
-        return {
-          ...message,
-          content: transformedContent,
-        } as ChatCompletionMessageParam;
-      }
-      // If the message has tool calls, cache the last tool call instead of content
-      else if (
-        message.role === "assistant" &&
-        message.tool_calls &&
-        message.tool_calls.length > 0
-      ) {
-        return {
-          ...message,
-          tool_calls: addCacheControlToLastToolCall(message.tool_calls),
-        } as ChatCompletionMessageParam;
-      } else {
-        // For other message types without tool calls, cache the content
-        const content =
-          (message.content as string | ChatCompletionContentPart[]) || "";
-        const transformedContent = addCacheControlToContent(content, true);
-
-        return {
-          ...message,
-          content: transformedContent,
-        } as ChatCompletionMessageParam;
-      }
+    // Last user message: cache recent conversation history
+    if (message.role === "user" && index === lastUserIndex) {
+      const content =
+        (message.content as string | ChatCompletionContentPart[]) || "";
+      const transformedContent = addCacheControlToContent(content, true);
+
+      return {
+        ...message,
+        content: transformedContent,
+      } as ChatCompletionMessageParam;
     }
 
     // Return message unchanged
@@ -410,8 +368,10 @@ export function transformMessagesForClaudeCache(
 
 /**
  * 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 Claude
+ * @param cacheMetrics - Additional cache metrics from the API response
  * @returns Extended usage with cache information
  */
 export function extendUsageWithCacheMetrics(
@@ -424,30 +384,45 @@ export function extendUsageWithCacheMetrics(
     total_tokens: standardUsage.total_tokens,
   };
 
-  // Add cache metrics if provided
-  if (cacheMetrics) {
-    if (typeof cacheMetrics.cache_read_input_tokens === "number") {
-      baseUsage.cache_read_input_tokens = cacheMetrics.cache_read_input_tokens;
-    }
+  if (!cacheMetrics) {
+    return baseUsage;
+  }
 
-    if (typeof cacheMetrics.cache_creation_input_tokens === "number") {
-      baseUsage.cache_creation_input_tokens =
-        cacheMetrics.cache_creation_input_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;
+  }
 
-    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,
-      };
-    }
+  // 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,
+    };
   }
 
   return baseUsage;

package/src/utils/containerSetup.ts

@@ -17,6 +17,8 @@ import { SlashCommandManager } from "../managers/slashCommandManager.js";
 import { PluginManager } from "../managers/pluginManager.js";
 import { BangManager } from "../managers/bangManager.js";
 import { CronManager } from "../managers/cronManager.js";
+import { GoalManager } from "../managers/goalManager.js";
+import { WorkflowManager } from "../managers/workflowManager.js";
 import { MemoryRuleManager } from "../managers/MemoryRuleManager.js";
 import { ReversionManager } from "../managers/reversionManager.js";
 import { SubagentManager } from "../managers/subagentManager.js";
@@ -224,6 +226,7 @@ export function setupAgentContainer(
             cwd: workdir,
             toolName: context.toolName,
             toolInput: context.toolInput,
+            planFilePath: permissionManager.getPlanFilePath(),
             env: mergedEnv,
           });
 
@@ -347,5 +350,11 @@ export function setupAgentContainer(
   container.register("CronManager", cronManager);
   cronManager.start();
 
+  const goalManager = new GoalManager(container);
+  container.register("GoalManager", goalManager);
+
+  const workflowManager = new WorkflowManager(container);
+  container.register("WorkflowManager", workflowManager);
+
   return container;
 }