@mastra/core 1.5.0 → 1.6.0

package/dist/harness/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunk7S6LA43E_cjs = require('../chunk-7S6LA43E.cjs');
-var chunkS4VVZI4E_cjs = require('../chunk-S4VVZI4E.cjs');
+var chunkVJWRJWSC_cjs = require('../chunk-VJWRJWSC.cjs');
+var chunkAYHSPIT6_cjs = require('../chunk-AYHSPIT6.cjs');
 var chunkEAZ6YDCQ_cjs = require('../chunk-EAZ6YDCQ.cjs');
 var chunkVDKWYUGC_cjs = require('../chunk-VDKWYUGC.cjs');
 var zod = require('zod');
@@ -38,9 +38,12 @@ var askUserTool = chunkEAZ6YDCQ_cjs.createTool({
         }
         const onAbort = () => reject(new DOMException("Aborted", "AbortError"));
         signal?.addEventListener("abort", onAbort, { once: true });
-        harnessCtx.registerQuestion(questionId, (answer2) => {
-          signal?.removeEventListener("abort", onAbort);
-          resolve(answer2);
+        harnessCtx.registerQuestion({
+          questionId,
+          resolve: (answer2) => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve(answer2);
+          }
         });
         harnessCtx.emitEvent({
           type: "ask_question",
@@ -85,9 +88,12 @@ ${plan}`,
         }
         const onAbort = () => reject(new DOMException("Aborted", "AbortError"));
         signal?.addEventListener("abort", onAbort, { once: true });
-        harnessCtx.registerPlanApproval(planId, (res) => {
-          signal?.removeEventListener("abort", onAbort);
-          resolve(res);
+        harnessCtx.registerPlanApproval({
+          planId,
+          resolve: (res) => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve(res);
+          }
         });
         harnessCtx.emitEvent({
           type: "plan_approval_required",
@@ -117,6 +123,135 @@ Please revise the plan based on the feedback and submit again with submit_plan.`
     }
   }
 });
+var taskItemSchema = zod.z.object({
+  content: zod.z.string().min(1).describe("Task description in imperative form (e.g., 'Fix authentication bug')"),
+  status: zod.z.enum(["pending", "in_progress", "completed"]).describe("Current task status"),
+  activeForm: zod.z.string().min(1).describe("Present continuous form shown during execution (e.g., 'Fixing authentication bug')")
+});
+var taskWriteTool = chunkEAZ6YDCQ_cjs.createTool({
+  id: "task_write",
+  description: `Create and manage a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
+
+Usage:
+- Pass the FULL task list each time (replaces previous list)
+- Each task has: content (imperative), status (pending|in_progress|completed), activeForm (present continuous)
+- Mark tasks in_progress BEFORE starting work (only ONE at a time)
+- Mark tasks completed IMMEDIATELY after finishing
+- Use this for multi-step tasks requiring 3+ distinct actions
+
+States:
+- pending: Not yet started
+- in_progress: Currently working on (limit to ONE)
+- completed: Finished successfully`,
+  inputSchema: zod.z.object({
+    tasks: zod.z.array(taskItemSchema).describe("The complete updated task list")
+  }),
+  execute: async ({ tasks }, context) => {
+    try {
+      const harnessCtx = context?.requestContext?.get("harness");
+      if (harnessCtx) {
+        await harnessCtx.setState({ tasks });
+        harnessCtx.emitEvent?.({
+          type: "task_updated",
+          tasks
+        });
+      }
+      const completed = tasks.filter((t) => t.status === "completed").length;
+      const inProgress = tasks.find((t) => t.status === "in_progress");
+      const total = tasks.length;
+      let summary = `Tasks updated: [${completed}/${total} completed]`;
+      if (inProgress) {
+        summary += `
+Currently: ${inProgress.activeForm}`;
+      }
+      return {
+        content: summary,
+        isError: false
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: `Failed to update tasks: ${msg}`,
+        isError: true
+      };
+    }
+  }
+});
+var taskCheckTool = chunkEAZ6YDCQ_cjs.createTool({
+  id: "task_check",
+  description: `Check the completion status of your current task list. Use this before deciding to end work on a task to ensure all tasks are completed.
+
+Returns:
+- Total number of tasks
+- Number of completed, in progress, and pending tasks
+- List of incomplete tasks (if any)
+- Boolean indicating if all tasks are done`,
+  inputSchema: zod.z.object({}),
+  // No input needed
+  execute: async ({}, context) => {
+    try {
+      const harnessCtx = context?.requestContext?.get("harness");
+      if (!harnessCtx) {
+        return {
+          content: "Unable to access task list (no harness context)",
+          isError: true
+        };
+      }
+      const state = harnessCtx.getState ? harnessCtx.getState() : harnessCtx.state;
+      const typedState = state;
+      const tasks = typedState.tasks || [];
+      if (tasks.length === 0) {
+        return {
+          content: "No tasks found. Consider using task_write to create a task list for complex work.",
+          isError: false
+        };
+      }
+      const completed = tasks.filter((t) => t.status === "completed");
+      const inProgress = tasks.filter((t) => t.status === "in_progress");
+      const pending = tasks.filter((t) => t.status === "pending");
+      const incomplete = [...inProgress, ...pending];
+      const allDone = incomplete.length === 0;
+      let response = `Task Status: [${completed.length}/${tasks.length} completed]
+`;
+      response += `- Completed: ${completed.length}
+`;
+      response += `- In Progress: ${inProgress.length}
+`;
+      response += `- Pending: ${pending.length}
+`;
+      response += `
+All tasks completed: ${allDone ? "\u2713 YES" : "\u2717 NO"}`;
+      if (!allDone) {
+        response += "\n\nIncomplete tasks:";
+        if (inProgress.length > 0) {
+          response += "\n\nIn Progress:";
+          inProgress.forEach((t) => {
+            response += `
+- ${t.content}`;
+          });
+        }
+        if (pending.length > 0) {
+          response += "\n\nPending:";
+          pending.forEach((t) => {
+            response += `
+- ${t.content}`;
+          });
+        }
+        response += "\n\nContinue working on these tasks before ending.";
+      }
+      return {
+        content: response,
+        isError: false
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: `Failed to check tasks: ${msg}`,
+        isError: true
+      };
+    }
+  }
+});
 function createSubagentTool(opts) {
   const { subagents, resolveModel, harnessTools, fallbackModelId } = opts;
   const subagentIds = subagents.map((s) => s.id);
@@ -160,7 +295,7 @@ Use this tool when:
           }
         }
       }
-      const harnessModelId = harnessCtx?.getSubagentModelId?.(agentType) ?? void 0;
+      const harnessModelId = harnessCtx?.getSubagentModelId?.({ agentType }) ?? void 0;
       const resolvedModelId = modelId ?? harnessModelId ?? definition.defaultModelId ?? fallbackModelId;
       if (!resolvedModelId) {
         return { content: "No model ID available for subagent. Configure defaultModelId.", isError: true };
@@ -174,7 +309,7 @@ Use this tool when:
           isError: true
         };
       }
-      const subagent = new chunk7S6LA43E_cjs.Agent({
+      const subagent = new chunkVJWRJWSC_cjs.Agent({
         id: `subagent-${definition.id}`,
         name: `${definition.name} Subagent`,
         instructions: definition.instructions,
@@ -334,7 +469,7 @@ var Harness = class {
       throw new Error("Harness requires at least one agent mode");
     }
     this.currentModeId = defaultMode.id;
-    if (config.workspace instanceof chunkS4VVZI4E_cjs.Workspace) {
+    if (config.workspace instanceof chunkAYHSPIT6_cjs.Workspace) {
       this.workspace = config.workspace;
     } else if (typeof config.workspace === "function") {
       this.workspaceFn = config.workspace;
@@ -358,7 +493,7 @@ var Harness = class {
     if (this.config.workspace && !this.workspaceInitialized && !this.workspaceFn) {
       try {
         if (!this.workspace) {
-          this.workspace = new chunkS4VVZI4E_cjs.Workspace(this.config.workspace);
+          this.workspace = new chunkAYHSPIT6_cjs.Workspace(this.config.workspace);
         }
         this.emit({ type: "workspace_status_changed", status: "initializing" });
         await this.workspace.init();
@@ -400,6 +535,7 @@ var Harness = class {
     }
     const sortedThreads = [...threads].sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
     const mostRecent = sortedThreads[0];
+    this.config.threadLock?.acquire(mostRecent.id);
     this.currentThreadId = mostRecent.id;
     await this.loadThreadMetadata();
     return mostRecent;
@@ -459,7 +595,7 @@ var Harness = class {
   // ===========================================================================
   // Mode Management
   // ===========================================================================
-  getModes() {
+  listModes() {
     return this.config.modes;
   }
   getCurrentModeId() {
@@ -476,7 +612,7 @@ var Harness = class {
    * Switch to a different mode.
    * Aborts any in-progress generation and switches to the mode's default model.
    */
-  async switchMode(modeId) {
+  async switchMode({ modeId }) {
     const mode = this.config.modes.find((m) => m.id === modeId);
     if (!mode) {
       throw new Error(`Mode not found: ${modeId}`);
@@ -484,11 +620,11 @@ var Harness = class {
     this.abort();
     const currentModelId = this.getCurrentModelId();
     if (currentModelId) {
-      await this.persistThreadSetting(`modeModelId_${this.currentModeId}`, currentModelId);
+      await this.setThreadSetting({ key: `modeModelId_${this.currentModeId}`, value: currentModelId });
     }
     const previousModeId = this.currentModeId;
     this.currentModeId = modeId;
-    await this.persistThreadSetting("currentModeId", modeId);
+    await this.setThreadSetting({ key: "currentModeId", value: modeId });
     const modeModelId = await this.loadModeModelId(modeId);
     if (modeModelId) {
       void this.setState({ currentModelId: modeModelId });
@@ -543,13 +679,17 @@ var Harness = class {
   /**
    * Switch to a different model at runtime.
    */
-  async switchModel(modelId, scope = "thread", modeId) {
+  async switchModel({
+    modelId,
+    scope = "thread",
+    modeId
+  }) {
     const targetModeId = modeId ?? this.currentModeId;
     if (targetModeId === this.currentModeId) {
       void this.setState({ currentModelId: modelId });
     }
     if (scope === "thread") {
-      await this.persistThreadSetting(`modeModelId_${targetModeId}`, modelId);
+      await this.setThreadSetting({ key: `modeModelId_${targetModeId}`, value: modelId });
     }
     this.emit({ type: "model_changed", modelId, scope, modeId: targetModeId });
   }
@@ -577,7 +717,7 @@ var Harness = class {
       }
     }
     try {
-      const { PROVIDER_REGISTRY } = await import('../provider-registry-4PH2JPIA.cjs');
+      const { PROVIDER_REGISTRY } = await import('../provider-registry-HMTFO5FV.cjs');
       const registry = PROVIDER_REGISTRY;
       const providerConfig = registry[provider];
       const envVars = providerConfig?.apiKeyEnvVar;
@@ -594,9 +734,9 @@ var Harness = class {
    * Get all available models from the provider registry with auth status.
    * Uses the optional `modelAuthChecker` and `modelUseCountProvider` hooks.
    */
-  async getAvailableModels() {
+  async listAvailableModels() {
     try {
-      const { PROVIDER_REGISTRY } = await import('../provider-registry-4PH2JPIA.cjs');
+      const { PROVIDER_REGISTRY } = await import('../provider-registry-HMTFO5FV.cjs');
       if (!PROVIDER_REGISTRY) return [];
       const registry = PROVIDER_REGISTRY;
       const providers = Object.keys(registry);
@@ -634,7 +774,7 @@ var Harness = class {
   }
   async getProviderApiKeyEnvVar(provider) {
     try {
-      const { PROVIDER_REGISTRY } = await import('../provider-registry-4PH2JPIA.cjs');
+      const { PROVIDER_REGISTRY } = await import('../provider-registry-HMTFO5FV.cjs');
       const registry = PROVIDER_REGISTRY;
       const envVars = registry[provider]?.apiKeyEnvVar;
       return Array.isArray(envVars) ? envVars[0] : envVars;
@@ -651,11 +791,11 @@ var Harness = class {
   getResourceId() {
     return this.resourceId;
   }
-  setResourceId(resourceId) {
+  setResourceId({ resourceId }) {
     this.resourceId = resourceId;
     this.currentThreadId = null;
   }
-  async createThread(title) {
+  async createThread({ title } = {}) {
     const now = /* @__PURE__ */ new Date();
     const thread = {
       id: this.generateId(),
@@ -672,6 +812,10 @@ var Harness = class {
       metadata.currentModelId = modelId;
       metadata[`modeModelId_${this.currentModeId}`] = modelId;
     }
+    const projectPath = this.state.projectPath;
+    if (projectPath) {
+      metadata.projectPath = projectPath;
+    }
     if (this.config.storage) {
       const memoryStorage = await this.getMemoryStorage();
       await memoryStorage.saveThread({
@@ -685,6 +829,23 @@ var Harness = class {
         }
       });
     }
+    const oldThreadId = this.currentThreadId;
+    if (this.config.threadLock) {
+      try {
+        this.config.threadLock.acquire(thread.id);
+      } catch (err) {
+        if (oldThreadId) {
+          try {
+            this.config.threadLock.acquire(oldThreadId);
+          } catch {
+          }
+        }
+        throw err;
+      }
+      if (oldThreadId) {
+        this.config.threadLock.release(oldThreadId);
+      }
+    }
     this.currentThreadId = thread.id;
     if (modelId && !currentStateModel) {
       void this.setState({ currentModelId: modelId });
@@ -693,7 +854,7 @@ var Harness = class {
     this.emit({ type: "thread_created", thread });
     return thread;
   }
-  async renameThread(title) {
+  async renameThread({ title }) {
     if (!this.currentThreadId || !this.config.storage) return;
     const memoryStorage = await this.getMemoryStorage();
     const thread = await memoryStorage.getThreadById({ threadId: this.currentThreadId });
@@ -703,7 +864,7 @@ var Harness = class {
       });
     }
   }
-  async switchThread(threadId) {
+  async switchThread({ threadId }) {
     this.abort();
     if (this.config.storage) {
       const memoryStorage = await this.getMemoryStorage();
@@ -712,7 +873,11 @@ var Harness = class {
         throw new Error(`Thread not found: ${threadId}`);
       }
     }
+    this.config.threadLock?.acquire(threadId);
     const previousThreadId = this.currentThreadId;
+    if (previousThreadId) {
+      this.config.threadLock?.release(previousThreadId);
+    }
     this.currentThreadId = threadId;
     await this.loadThreadMetadata();
     this.emit({ type: "thread_changed", threadId, previousThreadId });
@@ -731,7 +896,7 @@ var Harness = class {
       metadata: thread.metadata
     }));
   }
-  async persistThreadSetting(key, value) {
+  async setThreadSetting({ key, value }) {
     if (!this.currentThreadId || !this.config.storage) return;
     try {
       const memoryStorage = await this.getMemoryStorage();
@@ -748,7 +913,7 @@ var Harness = class {
     } catch {
     }
   }
-  async removeThreadSetting(key) {
+  async deleteThreadSetting({ key }) {
     if (!this.currentThreadId || !this.config.storage) return;
     try {
       const memoryStorage = await this.getMemoryStorage();
@@ -959,10 +1124,26 @@ var Harness = class {
     if (!modelId || !this.config.resolveModel) return void 0;
     return this.config.resolveModel(modelId);
   }
+  /**
+   * Switch the Observer model.
+   */
+  async switchObserverModel({ modelId }) {
+    void this.setState({ observerModelId: modelId });
+    await this.setThreadSetting({ key: "observerModelId", value: modelId });
+    this.emit({ type: "om_model_changed", role: "observer", modelId });
+  }
+  /**
+   * Switch the Reflector model.
+   */
+  async switchReflectorModel({ modelId }) {
+    void this.setState({ reflectorModelId: modelId });
+    await this.setThreadSetting({ key: "reflectorModelId", value: modelId });
+    this.emit({ type: "om_model_changed", role: "reflector", modelId });
+  }
   // ===========================================================================
   // Subagent Model Management
   // ===========================================================================
-  getSubagentModelId(agentType) {
+  getSubagentModelId({ agentType } = {}) {
     const state = this.state;
     if (agentType) {
       const perType = state[`subagentModelId_${agentType}`];
@@ -971,19 +1152,19 @@ var Harness = class {
     const global = state.subagentModelId;
     return typeof global === "string" ? global : null;
   }
-  async setSubagentModelId(modelId, agentType) {
+  async setSubagentModelId({ modelId, agentType }) {
     const key = agentType ? `subagentModelId_${agentType}` : "subagentModelId";
     void this.setState({ [key]: modelId });
-    await this.persistThreadSetting(key, modelId);
+    await this.setThreadSetting({ key, value: modelId });
     this.emit({ type: "subagent_model_changed", modelId, scope: "thread", agentType });
   }
   // ===========================================================================
   // Permissions
   // ===========================================================================
-  grantSessionCategory(category) {
+  grantSessionCategory({ category }) {
     this.sessionGrantedCategories.add(category);
   }
-  grantSessionTool(toolName) {
+  grantSessionTool({ toolName }) {
     this.sessionGrantedTools.add(toolName);
   }
   getSessionGrants() {
@@ -992,15 +1173,15 @@ var Harness = class {
       tools: [...this.sessionGrantedTools]
     };
   }
-  getToolCategory(toolName) {
+  getToolCategory({ toolName }) {
     return this.config.toolCategoryResolver?.(toolName) ?? null;
   }
-  setPermissionCategory(category, policy) {
+  setPermissionForCategory({ category, policy }) {
     const rules = this.getPermissionRules();
     rules.categories[category] = policy;
     void this.setState({ permissionRules: rules });
   }
-  setPermissionTool(toolName, policy) {
+  setPermissionForTool({ toolName, policy }) {
     const rules = this.getPermissionRules();
     rules.tools[toolName] = policy;
     void this.setState({ permissionRules: rules });
@@ -1022,7 +1203,7 @@ var Harness = class {
     const toolPolicy = rules.tools[toolName];
     if (toolPolicy) return toolPolicy;
     if (this.sessionGrantedTools.has(toolName)) return "allow";
-    const category = this.getToolCategory(toolName);
+    const category = this.getToolCategory({ toolName });
     if (category) {
       if (this.sessionGrantedCategories.has(category)) return "allow";
       const categoryPolicy = rules.categories[category];
@@ -1037,7 +1218,10 @@ var Harness = class {
    * Send a message to the current agent.
    * Streams the response and emits events.
    */
-  async sendMessage(content, options) {
+  async sendMessage({
+    content,
+    images
+  }) {
     if (!this.currentThreadId) {
       const thread = await this.createThread();
       this.currentThreadId = thread.id;
@@ -1059,12 +1243,16 @@ var Harness = class {
       };
       streamOptions.toolsets = await this.buildToolsets(requestContext);
       let messageInput = content;
-      if (options?.images?.length) {
+      if (images?.length) {
         messageInput = {
           role: "user",
           content: [
             { type: "text", text: content },
-            ...options.images.map((img) => ({ type: "file", data: img.data, mediaType: img.mimeType }))
+            ...images.map((img) => ({
+              type: "file",
+              data: img.data,
+              mediaType: img.mimeType
+            }))
           ]
         };
       }
@@ -1101,18 +1289,17 @@ var Harness = class {
       }
       if (this.currentOperationId === operationId && this.followUpQueue.length > 0) {
         const next = this.followUpQueue.shift();
-        await this.sendMessage(next);
+        await this.sendMessage({ content: next });
       }
     }
   }
-  async getMessages(options) {
+  async listMessages(options) {
     if (!this.currentThreadId) return [];
-    return this.getMessagesForThread(this.currentThreadId, options);
+    return this.listMessagesForThread({ threadId: this.currentThreadId, limit: options?.limit });
   }
-  async getMessagesForThread(threadId, options) {
+  async listMessagesForThread({ threadId, limit }) {
     if (!this.config.storage) return [];
     const memoryStorage = await this.getMemoryStorage();
-    const limit = options?.limit;
     if (limit) {
       const result2 = await memoryStorage.listMessages({
         threadId,
@@ -1125,7 +1312,7 @@ var Harness = class {
     const result = await memoryStorage.listMessages({ threadId, perPage: false });
     return result.messages.map((msg) => this.convertToHarnessMessage(msg));
   }
-  async getFirstUserMessageForThread(threadId) {
+  async getFirstUserMessageForThread({ threadId }) {
     if (!this.config.storage) return null;
     const memoryStorage = await this.getMemoryStorage();
     const result = await memoryStorage.listMessages({
@@ -1184,6 +1371,39 @@ var Harness = class {
             });
           }
           break;
+        case "data-om-observation-start": {
+          const data = part.data ?? {};
+          content.push({
+            type: "om_observation_start",
+            tokensToObserve: data.tokensToObserve ?? 0,
+            operationType: data.operationType ?? "observation"
+          });
+          break;
+        }
+        case "data-om-observation-end": {
+          const data = part.data ?? {};
+          content.push({
+            type: "om_observation_end",
+            tokensObserved: data.tokensObserved ?? 0,
+            observationTokens: data.observationTokens ?? 0,
+            durationMs: data.durationMs ?? 0,
+            operationType: data.operationType ?? "observation",
+            observations: data.observations ?? void 0,
+            currentTask: data.currentTask ?? void 0,
+            suggestedResponse: data.suggestedResponse ?? void 0
+          });
+          break;
+        }
+        case "data-om-observation-failed": {
+          const data = part.data ?? {};
+          content.push({
+            type: "om_observation_failed",
+            error: data.error ?? "Unknown error",
+            tokensAttempted: data.tokensAttempted ?? 0,
+            operationType: data.operationType ?? "observation"
+          });
+          break;
+        }
       }
     }
     return { id: msg.id, role: msg.role, content, createdAt: msg.createdAt };
@@ -1243,6 +1463,21 @@ var Harness = class {
           }
           break;
         }
+        case "tool-call-input-streaming-start": {
+          const { toolCallId, toolName } = chunk.payload;
+          this.emit({ type: "tool_input_start", toolCallId, toolName });
+          break;
+        }
+        case "tool-call-delta": {
+          const { toolCallId, argsTextDelta, toolName } = chunk.payload;
+          this.emit({ type: "tool_input_delta", toolCallId, argsTextDelta, toolName });
+          break;
+        }
+        case "tool-call-input-streaming-end": {
+          const { toolCallId } = chunk.payload;
+          this.emit({ type: "tool_input_end", toolCallId });
+          break;
+        }
         case "tool-call": {
           const toolCall = chunk.payload;
           currentMessage.content.push({
@@ -1345,6 +1580,169 @@ var Harness = class {
           }
           break;
         }
+        // Observational Memory data parts
+        // NOTE: OM data parts arrive as { type, data: { ... } } — NOT { type, payload }
+        case "data-om-status": {
+          const d = chunk.data;
+          if (d?.windows) {
+            const w = d.windows;
+            const active = w.active ?? {};
+            const msgs = active.messages ?? {};
+            const obs = active.observations ?? {};
+            const buffObs = w.buffered?.observations ?? {};
+            const buffRef = w.buffered?.reflection ?? {};
+            this.emit({
+              type: "om_status",
+              windows: {
+                active: {
+                  messages: { tokens: msgs.tokens ?? 0, threshold: msgs.threshold ?? 0 },
+                  observations: { tokens: obs.tokens ?? 0, threshold: obs.threshold ?? 0 }
+                },
+                buffered: {
+                  observations: {
+                    status: buffObs.status ?? "idle",
+                    chunks: buffObs.chunks ?? 0,
+                    messageTokens: buffObs.messageTokens ?? 0,
+                    projectedMessageRemoval: buffObs.projectedMessageRemoval ?? 0,
+                    observationTokens: buffObs.observationTokens ?? 0
+                  },
+                  reflection: {
+                    status: buffRef.status ?? "idle",
+                    inputObservationTokens: buffRef.inputObservationTokens ?? 0,
+                    observationTokens: buffRef.observationTokens ?? 0
+                  }
+                }
+              },
+              recordId: d.recordId ?? "",
+              threadId: d.threadId ?? "",
+              stepNumber: d.stepNumber ?? 0,
+              generationCount: d.generationCount ?? 0
+            });
+          }
+          break;
+        }
+        case "data-om-observation-start": {
+          const payload = chunk.data;
+          if (payload && payload.cycleId) {
+            if (payload.operationType === "observation") {
+              this.emit({
+                type: "om_observation_start",
+                cycleId: payload.cycleId,
+                operationType: payload.operationType,
+                tokensToObserve: payload.tokensToObserve ?? 0
+              });
+            } else if (payload.operationType === "reflection") {
+              this.emit({
+                type: "om_reflection_start",
+                cycleId: payload.cycleId,
+                tokensToReflect: payload.tokensToObserve ?? 0
+              });
+            }
+          }
+          break;
+        }
+        case "data-om-observation-end": {
+          const payload = chunk.data;
+          if (payload && payload.cycleId) {
+            if (payload.operationType === "reflection") {
+              this.emit({
+                type: "om_reflection_end",
+                cycleId: payload.cycleId,
+                durationMs: payload.durationMs ?? 0,
+                compressedTokens: payload.observationTokens ?? 0,
+                observations: payload.observations
+              });
+            } else {
+              this.emit({
+                type: "om_observation_end",
+                cycleId: payload.cycleId,
+                durationMs: payload.durationMs ?? 0,
+                tokensObserved: payload.tokensObserved ?? 0,
+                observationTokens: payload.observationTokens ?? 0,
+                observations: payload.observations,
+                currentTask: payload.currentTask,
+                suggestedResponse: payload.suggestedResponse
+              });
+            }
+          }
+          break;
+        }
+        case "data-om-observation-failed": {
+          const payload = chunk.data;
+          if (payload) {
+            if (payload.operationType === "reflection") {
+              this.emit({
+                type: "om_reflection_failed",
+                cycleId: payload.cycleId ?? "unknown",
+                error: payload.error ?? "Unknown error",
+                durationMs: payload.durationMs ?? 0
+              });
+            } else {
+              this.emit({
+                type: "om_observation_failed",
+                cycleId: payload.cycleId ?? "unknown",
+                error: payload.error ?? "Unknown error",
+                durationMs: payload.durationMs ?? 0
+              });
+            }
+          }
+          break;
+        }
+        // Async buffering lifecycle
+        case "data-om-buffering-start": {
+          const payload = chunk.data;
+          if (payload && payload.cycleId) {
+            this.emit({
+              type: "om_buffering_start",
+              cycleId: payload.cycleId,
+              operationType: payload.operationType ?? "observation",
+              tokensToBuffer: payload.tokensToBuffer ?? 0
+            });
+          }
+          break;
+        }
+        case "data-om-buffering-end": {
+          const payload = chunk.data;
+          if (payload && payload.cycleId) {
+            this.emit({
+              type: "om_buffering_end",
+              cycleId: payload.cycleId,
+              operationType: payload.operationType ?? "observation",
+              tokensBuffered: payload.tokensBuffered ?? 0,
+              bufferedTokens: payload.bufferedTokens ?? 0,
+              observations: payload.observations
+            });
+          }
+          break;
+        }
+        case "data-om-buffering-failed": {
+          const payload = chunk.data;
+          if (payload && payload.cycleId) {
+            this.emit({
+              type: "om_buffering_failed",
+              cycleId: payload.cycleId,
+              operationType: payload.operationType ?? "observation",
+              error: payload.error ?? "Unknown error"
+            });
+          }
+          break;
+        }
+        case "data-om-activation": {
+          const payload = chunk.data;
+          if (payload && payload.cycleId) {
+            this.emit({
+              type: "om_activation",
+              cycleId: payload.cycleId,
+              operationType: payload.operationType ?? "observation",
+              chunksActivated: payload.chunksActivated ?? 0,
+              tokensActivated: payload.tokensActivated ?? 0,
+              observationTokens: payload.observationTokens ?? 0,
+              messagesActivated: payload.messagesActivated ?? 0,
+              generationCount: payload.generationCount ?? 0
+            });
+          }
+          break;
+        }
       }
     }
     this.emit({ type: "message_end", message: currentMessage });
@@ -1369,20 +1767,20 @@ var Harness = class {
   /**
    * Steer the agent mid-stream: aborts current run and sends a new message.
    */
-  async steer(content) {
+  async steer({ content }) {
     this.abort();
     this.followUpQueue = [];
-    await this.sendMessage(content);
+    await this.sendMessage({ content });
   }
   /**
    * Queue a follow-up message to be processed after the current operation completes.
    */
-  async followUp(content) {
+  async followUp({ content }) {
     if (this.isRunning()) {
       this.followUpQueue.push(content);
       this.emit({ type: "follow_up_queued", count: this.followUpQueue.length });
     } else {
-      await this.sendMessage(content);
+      await this.sendMessage({ content });
     }
   }
   getFollowUpCount() {
@@ -1398,14 +1796,14 @@ var Harness = class {
    * Respond to a pending tool approval from the UI.
    * "always_allow_category" grants the tool's category for the rest of the session, then approves.
    */
-  resolveToolApprovalDecision(decision) {
+  respondToToolApproval({ decision }) {
     if (!this.pendingApprovalResolve) return;
     if (decision === "always_allow_category") {
       const tn = this.pendingApprovalToolName;
       if (tn) {
-        const category = this.getToolCategory(tn);
+        const category = this.getToolCategory({ toolName: tn });
         if (category) {
-          this.grantSessionCategory(category);
+          this.grantSessionCategory({ category });
         }
       }
       this.pendingApprovalResolve("approve");
@@ -1421,14 +1819,14 @@ var Harness = class {
    * Register a pending question resolver.
    * Called by agent tools (e.g., ask_user) to pause execution until the UI responds.
    */
-  registerQuestion(questionId, resolve) {
+  registerQuestion({ questionId, resolve }) {
     this.pendingQuestions.set(questionId, resolve);
   }
   /**
    * Resolve a pending question with the user's answer.
    * Called by the UI when the user responds to a question dialog.
    */
-  respondToQuestion(questionId, answer) {
+  respondToQuestion({ questionId, answer }) {
     const resolve = this.pendingQuestions.get(questionId);
     if (resolve) {
       this.pendingQuestions.delete(questionId);
@@ -1439,7 +1837,10 @@ var Harness = class {
    * Register a pending plan approval resolver.
    * Called by agent tools (e.g., submit_plan) to pause execution until approval.
    */
-  registerPlanApproval(planId, resolve) {
+  registerPlanApproval({
+    planId,
+    resolve
+  }) {
     this.pendingPlanApprovals.set(planId, resolve);
   }
   /**
@@ -1447,13 +1848,16 @@ var Harness = class {
    * On approval: switches to the default mode, then resolves the promise.
    * On rejection: resolves with feedback (stays in current mode).
    */
-  async respondToPlanApproval(planId, response) {
+  async respondToPlanApproval({
+    planId,
+    response
+  }) {
     const resolve = this.pendingPlanApprovals.get(planId);
     if (!resolve) return;
     if (response.action === "approved") {
       const defaultMode = this.config.modes.find((m) => m.default) ?? this.config.modes[0];
       if (defaultMode && defaultMode.id !== this.currentModeId) {
-        await this.switchMode(defaultMode.id);
+        await this.switchMode({ modeId: defaultMode.id });
       }
     }
     this.pendingPlanApprovals.delete(planId);
@@ -1537,7 +1941,9 @@ var Harness = class {
   async buildToolsets(requestContext) {
     const builtInTools = {
       ask_user: askUserTool,
-      submit_plan: submitPlanTool
+      submit_plan: submitPlanTool,
+      task_write: taskWriteTool,
+      task_check: taskCheckTool
     };
     let resolvedHarnessTools = void 0;
     if (this.config.tools) {
@@ -1576,9 +1982,9 @@ var Harness = class {
       abortSignal: this.abortController?.signal,
       workspace: this.workspace,
       emitEvent: (event) => this.emit(event),
-      registerQuestion: (questionId, resolve) => this.registerQuestion(questionId, resolve),
-      registerPlanApproval: (planId, resolve) => this.registerPlanApproval(planId, resolve),
-      getSubagentModelId: (agentType) => this.getSubagentModelId(agentType)
+      registerQuestion: (params) => this.registerQuestion(params),
+      registerPlanApproval: (params) => this.registerPlanApproval(params),
+      getSubagentModelId: (params) => this.getSubagentModelId(params)
     };
     const requestContext = new chunkVDKWYUGC_cjs.RequestContext([["harness", harnessContext]]);
     if (this.workspaceFn) {
@@ -1660,7 +2066,7 @@ var Harness = class {
     }
   }
   registerHeartbeat(handler) {
-    void this.removeHeartbeat(handler.id);
+    void this.removeHeartbeat({ id: handler.id });
     const run = async () => {
       try {
         await handler.handler();
@@ -1675,7 +2081,7 @@ var Harness = class {
     timer.unref();
     this.heartbeatTimers.set(handler.id, { timer, shutdown: handler.shutdown });
   }
-  async removeHeartbeat(id) {
+  async removeHeartbeat({ id }) {
     const entry = this.heartbeatTimers.get(id);
     if (entry) {
       clearInterval(entry.timer);
@@ -1724,5 +2130,7 @@ exports.Harness = Harness;
 exports.askUserTool = askUserTool;
 exports.parseSubagentMeta = parseSubagentMeta;
 exports.submitPlanTool = submitPlanTool;
+exports.taskCheckTool = taskCheckTool;
+exports.taskWriteTool = taskWriteTool;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map