@tyvm/knowhow 0.0.159 → 0.0.161

package/src/services/AgentSyncFs.ts

@@ -1,775 +0,0 @@
-/**
- * Agent Synchronization Service - Filesystem-based synchronization
- * Handles synchronization via filesystem files in .knowhow/processes/agents/taskId/
- */
-import { BaseAgent } from "../agents/base/base";
-import { TraceAll } from "../util/Trace";
-import { promises as fs } from "fs";
-import * as path from "path";
-import { watch } from "fs";
-
-export interface FsSyncOptions {
-  taskId: string;
-  prompt: string;
-  agentName?: string;
-  /** The taskId of the parent agent that spawned this task, if any. */
-  parentTaskId?: string;
-}
-
-/**
- * AgentSyncFs handles filesystem-based synchronization for agent tasks
- * Creates files in .knowhow/processes/agents/{taskId}/ for status and input
- */
-@TraceAll()
-export class AgentSyncFs {
-  /** Shared cleanup interval across all instances to avoid duplicate cleanup runs */
-  private static sharedCleanupInterval: NodeJS.Timeout | null = null;
-  private static sharedBasePath: string = ".knowhow/processes/agents";
-  private static cleanupStarted: boolean = false;
-
-  private taskId: string | undefined;
-  private basePath: string = ".knowhow/processes/agents";
-  private taskPath: string | undefined;
-  private eventHandlersSetup: boolean = false;
-  private watcher: ReturnType<typeof watch> | null = null;
-  private lastInputContent: string = "";
-  private finalizationPromise: Promise<void> | null = null;
-  private agent: BaseAgent | undefined;
-  private threadUpdateHandler: ((...args: any[]) => void) | undefined;
-  private doneHandler: ((...args: any[]) => void) | undefined;
-  private tokenUsageHandler: ((...args: any[]) => void) | undefined;
-  /**
-   * Tracks the most recent in-flight filesystem metadata update.
-   * The done handler awaits this before finalizing, preventing a race where
-   * the completion call writes before the last thread sync finishes.
-   */
-  private pendingThreadUpdatePromise: Promise<void> | null = null;
-
-  constructor() {
-    // Start cleanup process when created
-    AgentSyncFs.startSharedCleanupProcess();
-  }
-
-  /**
-   * Create filesystem sync for a task
-   */
-  async createTask(options: FsSyncOptions): Promise<string> {
-    this.taskId = options.taskId;
-    this.taskPath = path.join(this.basePath, this.taskId);
-
-    try {
-      // Create directory structure
-      await fs.mkdir(this.taskPath, { recursive: true });
-
-      // Create initial files
-      await this.writeStatus("running");
-      await this.writeInput("");
-      await this.writeMetadata({
-        taskId: this.taskId,
-        // Record the OS process id of this agent subprocess so orchestrating
-        // tools (e.g. waitForAgentCompleted) can detect a crashed-but-not-
-        // finalized task via process-liveness. This is the child's own pid,
-        // so it needs no coordination with the spawner and never touches
-        // execCommand's child processes.
-        pid: process.pid,
-        prompt: options.prompt,
-        agentName: options.agentName || "unknown",
-        ...(options.parentTaskId ? { parentTaskId: options.parentTaskId } : {}),
-        startTime: new Date().toISOString(),
-        status: "running",
-      });
-
-      console.log(`✅ Created filesystem sync at: ${this.taskPath}`);
-      return this.taskId;
-    } catch (error) {
-      console.error(`❌ Failed to create filesystem sync:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Clean up old managed-process directories (.knowhow/processes/<id>/) that
-   * were created by spawnManaged / execCommand.  These are identified by the
-   * presence of a status.json file inside the directory.  Only directories
-   * older than maxAgeMs are removed.
-   */
-  static async cleanupOldManagedProcessDirs(maxAgeMs: number): Promise<void> {
-    try {
-      const processesPath = path.dirname(AgentSyncFs.sharedBasePath);
-
-      try {
-        await fs.access(processesPath);
-      } catch {
-        return;
-      }
-
-      const entries = await fs.readdir(processesPath, { withFileTypes: true });
-      const now = Date.now();
-
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const dirPath = path.join(processesPath, entry.name);
-        const statusPath = path.join(dirPath, "status.json");
-
-        try {
-          await fs.access(statusPath);
-          const stats = await fs.stat(dirPath);
-          const age = now - stats.mtimeMs;
-          if (age > maxAgeMs) {
-            console.log(`🧹 Cleaning up old process directory: ${entry.name}`);
-            await fs.rm(dirPath, { recursive: true, force: true });
-          }
-        } catch {
-          // No status.json or can't stat — skip (e.g. the agents/ subdir)
-        }
-      }
-    } catch (error) {
-      console.error(`❌ Error during managed process dir cleanup:`, error);
-    }
-  }
-
-  /**
-   * Update task status
-   */
-  private async writeStatus(status: string): Promise<void> {
-    if (!this.taskPath) return;
-
-    try {
-      const statusPath = path.join(this.taskPath, "status.txt");
-      await fs.writeFile(statusPath, status, "utf8");
-    } catch (error) {
-      console.error(`❌ Failed to write status:`, error);
-    }
-  }
-
-  /**
-   * Write input file (used for initial state)
-   */
-  private async writeInput(content: string): Promise<void> {
-    if (!this.taskPath) return;
-
-    try {
-      const inputPath = path.join(this.taskPath, "input.txt");
-      await fs.writeFile(inputPath, content, "utf8");
-      this.lastInputContent = content;
-    } catch (error) {
-      console.error(`❌ Failed to write input:`, error);
-    }
-  }
-
-  /**
-   * Write metadata file
-   */
-  private async writeMetadata(data: any): Promise<void> {
-    if (!this.taskPath) return;
-
-    try {
-      const metadataPath = path.join(this.taskPath, "metadata.json");
-      // Thread/status updates are partial snapshots. Merge them so stable
-      // orchestration identity written by createTask (taskId, pid and parent)
-      // is never discarded by a later update.
-      let existing: Record<string, unknown> = {};
-      try {
-        existing = JSON.parse(await fs.readFile(metadataPath, "utf8"));
-      } catch { /* first write or an interrupted legacy write */ }
-      await fs.writeFile(
-        metadataPath,
-        JSON.stringify({ ...existing, ...data }, null, 2),
-        "utf8"
-      );
-    } catch (error) {
-      console.error(`❌ Failed to write metadata:`, error);
-    }
-  }
-
-  /**
-   * Persist the remote identity alongside the local task. Keeping the local
-   * slug and remote UUID as separate fields lets resume reconnect without ever
-   * mistaking one for the other.
-   */
-  static async persistRemoteIdentity(
-    taskId: string,
-    remoteTaskId: string,
-    remoteMessageId?: string
-  ): Promise<void> {
-    const taskPath = path.join(AgentSyncFs.sharedBasePath, taskId);
-    await AgentSyncFs.writeRemoteIdentity(
-      taskPath,
-      remoteTaskId,
-      remoteMessageId
-    );
-  }
-
-  async setRemoteIdentity(
-    remoteTaskId: string,
-    remoteMessageId?: string
-  ): Promise<void> {
-    if (!this.taskPath) return;
-    await AgentSyncFs.writeRemoteIdentity(this.taskPath, remoteTaskId, remoteMessageId);
-  }
-
-  private static async writeRemoteIdentity(
-    taskPath: string,
-    remoteTaskId: string,
-    remoteMessageId?: string
-  ): Promise<void> {
-    try {
-      const metadataPath = path.join(taskPath, "metadata.json");
-      let metadata: any = {};
-      try {
-        metadata = JSON.parse(await fs.readFile(metadataPath, "utf8"));
-      } catch {
-        // The normal path already created metadata, but recover if it was
-        // removed or malformed while the task was running.
-      }
-
-      metadata.remoteTaskId = remoteTaskId;
-      // Preserve the established session field name for compatibility with
-      // callers that already read knowhowTaskId.
-      metadata.knowhowTaskId = remoteTaskId;
-      if (remoteMessageId) {
-        metadata.remoteMessageId = remoteMessageId;
-        metadata.knowhowMessageId = remoteMessageId;
-      }
-
-      await fs.writeFile(
-        metadataPath,
-        JSON.stringify(metadata, null, 2),
-        "utf8"
-      );
-    } catch (error) {
-      console.error(`❌ Failed to persist remote task identity:`, error);
-    }
-  }
-
-  /**
-   * Append a token usage entry (including the full message chain sent for
-   * that call) to usage.json. This is intended for debugging cache-hit
-   * issues, where comparing the message chains and usage values between
-   * consecutive calls can reveal when a cache prefix was invalidated.
-   *
-   * To prevent exponential file growth, if the new entry's message thread
-   * fully contains the previous entry's thread as a prefix, the previous
-   * thread is replaced with { PREV_CACHE_HIT: true } so only the new
-   * messages (the delta) are stored alongside the new usage data.
-   */
-  private async appendUsageEntry(entry: any): Promise<void> {
-    if (!this.taskPath) return;
-
-    try {
-      const usagePath = path.join(this.taskPath, "usage.json");
-      let entries: any[] = [];
-
-      try {
-        const existingData = await fs.readFile(usagePath, "utf8");
-        entries = JSON.parse(existingData);
-      } catch {
-        // File doesn't exist or is invalid, start fresh
-      }
-
-      // If the new entry's messages are a superset of the last entry's
-      // messages (i.e. the last thread is a prefix of the new thread),
-      // collapse the last entry's messages to { PREV_CACHE_HIT: true }
-      // and store only the new delta — preventing exponential growth.
-      if (entries.length > 0) {
-        const lastEntry = entries[entries.length - 1];
-        const prevMessages: any[] = lastEntry?.messages;
-        const newMessages: any[] = entry?.messages;
-        if (
-          Array.isArray(prevMessages) &&
-          Array.isArray(newMessages) &&
-          prevMessages.length > 0 &&
-          newMessages.length >= prevMessages.length &&
-          JSON.stringify(newMessages.slice(0, prevMessages.length)) ===
-            JSON.stringify(prevMessages)
-        ) {
-          // Replace the previous full thread with a compact sentinel
-          lastEntry.messages = [{ PREV_CACHE_HIT: true }];
-        }
-      }
-
-      entries.push(entry);
-      await fs.writeFile(usagePath, JSON.stringify(entries, null, 2), "utf8");
-    } catch (error) {
-      console.error(`❌ Failed to append usage entry:`, error);
-    }
-  }
-
-  /**
-   * Update metadata file with current agent state
-   */
-  private async updateMetadata(
-    agent: BaseAgent,
-    inProgress: boolean,
-    result?: string
-  ): Promise<void> {
-    if (!this.taskPath) return;
-
-    try {
-      const metadataPath = path.join(this.taskPath, "metadata.json");
-      let metadata: any = {};
-
-      try {
-        const existingData = await fs.readFile(metadataPath, "utf8");
-        metadata = JSON.parse(existingData);
-      } catch {
-        // File doesn't exist or is invalid, start fresh
-      }
-
-      metadata.threads = agent.getThreads();
-      metadata.totalCostUsd = agent.getTotalCostUsd();
-      metadata.tokenUsage = agent.getTokenUsage();
-      metadata.agentName = agent.name;
-      // Record the model/provider actually in use at this sync so task
-      // history reflects the real model (including mid-run fallbacks), not
-      // just the named agent.
-      metadata.model = agent.getModel();
-      metadata.provider = agent.getProvider();
-      // Persist reasoning settings so a resume can restore the exact
-      // reasoning effort / summarize behavior the run was using. (The
-      // encrypted reasoning items + summaries themselves ride along on the
-      // thread messages via `_reasoning_details` / `reasoning_summary`.)
-      metadata.reasoningEffort = agent.getReasoningEffort?.();
-      metadata.summarizeReasoning = agent.getSummarizeReasoning?.();
-      // Tool schemas are part of the provider cache prefix. Preserve the exact
-      // request-visible list so resume/fork can recreate the same request.
-      metadata.enabledTools = agent.getEnabledToolNames();
-      metadata.inProgress = inProgress;
-      metadata.lastUpdate = new Date().toISOString();
-
-      if (result !== undefined) {
-        metadata.result = result;
-        metadata.status = "completed";
-        await this.writeStatus("completed");
-      }
-
-      await fs.writeFile(
-        metadataPath,
-        JSON.stringify(metadata, null, 2),
-        "utf8"
-      );
-    } catch (error) {
-      console.error(`❌ Failed to update metadata:`, error);
-    }
-  }
-
-  /**
-   * Read and process status file changes
-   */
-  private async readStatus(): Promise<string | null> {
-    if (!this.taskPath) return null;
-
-    try {
-      const statusPath = path.join(this.taskPath, "status.txt");
-      const content = await fs.readFile(statusPath, "utf8");
-      return content.trim();
-    } catch (error) {
-      // File might not exist or be accessible
-      return null;
-    }
-  }
-
-  /**
-   * Read and process input file changes
-   */
-  private async readInput(): Promise<string | null> {
-    if (!this.taskPath) return null;
-
-    try {
-      const inputPath = path.join(this.taskPath, "input.txt");
-      const content = await fs.readFile(inputPath, "utf8");
-      return content;
-    } catch (error) {
-      // File might not exist or be accessible
-      return null;
-    }
-  }
-
-  /**
-   * Check for file changes and process them
-   */
-  private async checkForChanges(agent: BaseAgent): Promise<void> {
-    if (!this.taskPath) return;
-
-    try {
-      // Check status changes
-      const status = await this.readStatus();
-      if (status === "paused") {
-        console.log(`⏸️ Agent task ${this.taskId} paused via filesystem`);
-        await agent.pause();
-        await this.waitForResume(agent);
-      } else if (status === "killed") {
-        console.log(`🛑 Agent task ${this.taskId} killed via filesystem`);
-        await agent.kill();
-      }
-
-      // Check for new input/messages
-      const input = await this.readInput();
-      if (input && input !== this.lastInputContent && input.trim() !== "") {
-        console.log(
-          `📬 New message received via filesystem for task ${this.taskId}`
-        );
-        this.lastInputContent = input;
-
-        // Detect slash commands in the input
-        if (input.trim().startsWith("/")) {
-          await this.handleInputCommand(agent, input.trim());
-        } else {
-          agent.addPendingUserMessage({
-            role: "user",
-            content: input,
-          });
-        }
-
-        // Clear the input file after processing
-        await this.writeInput("");
-      }
-    } catch (error) {
-      console.error(`❌ Error checking for changes:`, error);
-    }
-  }
-
-  /**
-   * Handle slash commands sent via input.txt
-   */
-  private async handleInputCommand(agent: BaseAgent, input: string): Promise<void> {
-    const [command, ...rest] = input.split(" ");
-    const message = rest.join(" ").trim() || undefined;
-
-    if (command === "/poke") {
-      console.log(`🫵 Received /poke command for task ${this.taskId}`);
-      agent.interrupt(message);
-    } else {
-      // Unknown command — treat as a regular message
-      console.warn(`⚠️ Unknown command "${command}", treating as message`);
-      agent.addPendingUserMessage({ role: "user", content: input });
-    }
-  }
-
-  /**
-   * Wait for resume by monitoring status file
-   */
-  private async waitForResume(agent: BaseAgent): Promise<void> {
-    const POLL_INTERVAL_MS = 2000;
-    const MAX_WAIT_MS = 60 * 60 * 1000; // 1 hour
-    const startTime = Date.now();
-
-    while (Date.now() - startTime < MAX_WAIT_MS) {
-      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-
-      const status = await this.readStatus();
-
-      if (status === "killed") {
-        console.log(`🛑 Agent task ${this.taskId} killed while paused`);
-        await agent.kill();
-        return;
-      }
-
-      if (status === "running") {
-        console.log(`▶️ Agent task ${this.taskId} resumed`);
-        await agent.unpause();
-        return;
-      }
-    }
-
-    console.warn(`⚠️ Timeout waiting for resume on task ${this.taskId}`);
-  }
-
-  /**
-   * Setup filesystem watching for the task
-   */
-  private setupFileWatcher(agent: BaseAgent): void {
-    if (!this.taskPath || this.watcher) return;
-
-    try {
-      this.watcher = watch(this.taskPath, async (eventType, filename) => {
-        if (filename === "status.txt" || filename === "input.txt") {
-          await this.checkForChanges(agent);
-        }
-      });
-
-      console.log(`👁️ Watching filesystem at: ${this.taskPath}`);
-    } catch (error) {
-      console.error(`❌ Failed to setup file watcher:`, error);
-    }
-  }
-
-  /**
-   * Set up event-based synchronization for an agent task
-   */
-  async setupAgentSync(agent: BaseAgent, taskId?: string): Promise<void> {
-    if (!taskId) return;
-
-    this.taskId = taskId;
-    this.taskPath = path.join(this.basePath, this.taskId);
-
-    // Ensure directory exists (might have been created by createTask)
-    try {
-      await fs.mkdir(this.taskPath, { recursive: true });
-    } catch (error) {
-      // Directory might already exist
-    }
-
-    if (!this.eventHandlersSetup) {
-      this.setupEventHandlers(agent);
-      this.setupFileWatcher(agent);
-      this.eventHandlersSetup = true;
-    }
-  }
-
-  /**
-   * Set up event handlers for automatic synchronization
-   */
-  private setupEventHandlers(agent: BaseAgent): void {
-    this.agent = agent;
-
-    // Listen to thread updates to sync state (store reference for cleanup)
-    this.threadUpdateHandler = async () => {
-      if (!this.taskId) return;
-
-      try {
-        // Track the pending update so the done handler can await it.
-        this.pendingThreadUpdatePromise = (async () => {
-          await this.updateMetadata(agent, true);
-          await this.checkForChanges(agent);
-        })();
-        await this.pendingThreadUpdatePromise;
-      } catch (error) {
-        console.error(`❌ Error during threadUpdate sync:`, error);
-      }
-    };
-    agent.agentEvents.on(
-      agent.eventTypes.threadUpdate,
-      this.threadUpdateHandler
-    );
-
-    // Listen to token usage events to record per-call usage + message chain
-    // (store reference for cleanup). This is written to usage.json so that
-    // cache-hit/cache-miss issues can be debugged by comparing the message
-    // chain and usage values sent/received on consecutive AI calls.
-    this.tokenUsageHandler = (usage: any) => {
-      this.appendUsageEntry(usage).catch((error) => {
-        console.error(`❌ Error recording token usage:`, error);
-      });
-    };
-    agent.agentEvents.on(
-      agent.eventTypes.tokenUsage,
-      this.tokenUsageHandler
-    );
-
-    // Listen to completion event to finalize task (store reference for cleanup)
-    this.doneHandler = (result: string) => {
-      if (!this.taskId) {
-        console.warn(`⚠️ [AgentSyncFs] Cannot finalize: taskId=${this.taskId}`);
-        return;
-      }
-
-      console.log(
-        `🎯 [AgentSyncFs] Done event received for task: ${this.taskId}`
-      );
-
-      // Store finalization promise so callers can await it (same pattern as AgentSyncKnowhowWeb)
-      this.finalizationPromise = (async () => {
-        try {
-          // Flush any in-flight thread update before finalizing.
-          // This prevents the race where a pending "inProgress: true" metadata write
-          // overwrites the finalization write.
-          if (this.pendingThreadUpdatePromise) {
-            console.log(
-              `⏳ [AgentSyncFs] Awaiting pending thread update before finalizing...`
-            );
-            await this.pendingThreadUpdatePromise.catch(() => {
-              // Ignore errors in pending update — we still want to finalize
-            });
-            this.pendingThreadUpdatePromise = null;
-          }
-
-          await this.updateMetadata(agent, false, result);
-          console.log(`✅ Completed filesystem sync for task: ${this.taskId}`);
-          await this.cleanup();
-        } catch (error) {
-          console.error(`❌ Error finalizing task:`, error);
-          throw error;
-        }
-      })();
-    };
-    agent.agentEvents.on(agent.eventTypes.done, this.doneHandler);
-  }
-
-  /**
-   * Wait for finalization to complete (for CLI usage)
-   */
-  async waitForFinalization(): Promise<void> {
-    if (this.finalizationPromise) {
-      await this.finalizationPromise;
-    }
-  }
-
-  /**
-   * Cleanup task directory and watcher
-   */
-  async cleanup(): Promise<void> {
-    if (this.watcher) {
-      this.watcher.close();
-      this.watcher = null;
-    }
-
-    // Note: We don't delete the directory here to preserve task history
-    // The cleanup process will handle old directories
-  }
-
-  /**
-   * Clean up old task directories (older than 3 days)
-   */
-  private static async cleanupOldTasks(): Promise<void> {
-    try {
-      const agentsPath = AgentSyncFs.sharedBasePath;
-
-      // Check if directory exists
-      try {
-        await fs.access(agentsPath);
-      } catch {
-        // Directory doesn't exist, nothing to clean
-        return;
-      }
-
-      const entries = await fs.readdir(agentsPath, { withFileTypes: true });
-      const now = Date.now();
-      const threeDaysMs = 3 * 24 * 60 * 60 * 1000;
-
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-
-        const taskPath = path.join(agentsPath, entry.name);
-
-        try {
-          const stats = await fs.stat(taskPath);
-          const age = now - stats.mtimeMs;
-
-          if (age > threeDaysMs) {
-            console.log(`🧹 Cleaning up old task directory: ${entry.name}`);
-            await fs.rm(taskPath, { recursive: true, force: true });
-          }
-        } catch (error) {
-          // Skip if we can't stat or delete
-          console.error(`❌ Error cleaning up ${entry.name}:`, error);
-        }
-      }
-
-      // Also clean up old execCommand background log files in .knowhow/processes/*.txt
-      await AgentSyncFs.cleanupOldProcessLogs(threeDaysMs);
-      await AgentSyncFs.cleanupOldManagedProcessDirs(threeDaysMs);
-    } catch (error) {
-      console.error(`❌ Error during cleanup:`, error);
-    }
-  }
-
-  /**
-   * Clean up old execCommand background log files (.knowhow/processes/*.txt).
-   * These are created by the execCommand tool when running background/long-lived
-   * commands, and are never cleaned up otherwise.
-   */
-  private static async cleanupOldProcessLogs(maxAgeMs: number): Promise<void> {
-    try {
-      // execCommand writes logs to the parent of the agents dir: .knowhow/processes
-      const processesPath = path.dirname(AgentSyncFs.sharedBasePath);
-
-      try {
-        await fs.access(processesPath);
-      } catch {
-        return;
-      }
-
-      const entries = await fs.readdir(processesPath, { withFileTypes: true });
-      const now = Date.now();
-
-      for (const entry of entries) {
-        // Only target the .txt log files that execCommand creates; leave the
-        // agents/ directory (and any other subdirectories) alone.
-        if (!entry.isFile() || !entry.name.endsWith(".txt")) continue;
-
-        const logPath = path.join(processesPath, entry.name);
-
-        try {
-          const stats = await fs.stat(logPath);
-          const age = now - stats.mtimeMs;
-
-          if (age > maxAgeMs) {
-            console.log(`🧹 Cleaning up old process log file: ${entry.name}`);
-            await fs.rm(logPath, { force: true });
-          }
-        } catch (error) {
-          // Skip if we can't stat or delete
-          console.error(`❌ Error cleaning up log ${entry.name}:`, error);
-        }
-      }
-    } catch (error) {
-      console.error(`❌ Error during process log cleanup:`, error);
-    }
-  }
-
-  /**
-   * Start periodic cleanup process
-   */
-  private static startSharedCleanupProcess(): void {
-    if (AgentSyncFs.cleanupStarted) return;
-    AgentSyncFs.cleanupStarted = true;
-
-    // Run cleanup every hour (shared across all instances)
-    AgentSyncFs.sharedCleanupInterval = setInterval(() => {
-      AgentSyncFs.cleanupOldTasks();
-    }, 60 * 60 * 1000);
-
-    // Also run once on startup
-    AgentSyncFs.cleanupOldTasks();
-  }
-
-  /**
-   * Stop cleanup process
-   */
-  stopCleanup(): void {
-    if (AgentSyncFs.sharedCleanupInterval) {
-      clearInterval(AgentSyncFs.sharedCleanupInterval);
-      AgentSyncFs.sharedCleanupInterval = null;
-      AgentSyncFs.cleanupStarted = false;
-    }
-  }
-
-  /**
-   * Reset synchronization state
-   */
-  reset(): void {
-    // Remove old event listeners from the agent before resetting
-    if (this.agent) {
-      if (this.threadUpdateHandler) {
-        this.agent.agentEvents.removeListener(
-          this.agent.eventTypes.threadUpdate,
-          this.threadUpdateHandler
-        );
-        this.threadUpdateHandler = undefined;
-      }
-      if (this.tokenUsageHandler) {
-        this.agent.agentEvents.removeListener(
-          this.agent.eventTypes.tokenUsage,
-          this.tokenUsageHandler
-        );
-        this.tokenUsageHandler = undefined;
-      }
-      if (this.doneHandler) {
-        this.agent.agentEvents.removeListener(
-          this.agent.eventTypes.done,
-          this.doneHandler
-        );
-        this.doneHandler = undefined;
-      }
-      this.agent = undefined;
-    }
-    this.cleanup();
-    this.taskId = undefined;
-    this.taskPath = undefined;
-    this.eventHandlersSetup = false;
-    this.lastInputContent = "";
-    this.finalizationPromise = null;
-    this.pendingThreadUpdatePromise = null;
-  }
-}