@tyvm/knowhow 0.0.158 → 0.0.160

package/src/chat/modules/AgentModule.ts

@@ -1,1664 +0,0 @@
-/**
- * Agent Chat Module - Handles agent interactions
- */
-import { EventService } from "../../services/EventService";
-import { ConsoleRenderer, AgentRenderer } from "../renderer";
-import {
-  SessionManager,
-  TaskRegistry,
-  SyncedAgentWatcher,
-  SyncerService,
-  AgentService,
-} from "../../services/index";
-import { AttachableAgent } from "../../services/SyncedAgentWatcher";
-import * as fs from "fs";
-import * as fsPromises from "fs/promises";
-import * as path from "path";
-
-import { BaseChatModule } from "./BaseChatModule";
-import { services } from "../../services/index";
-import { BaseAgent } from "../../agents/index";
-import { ChatCommand, ChatMode, ChatContext, ChatService } from "../types";
-import {
-  Message,
-  CompletionOptions,
-  REASONING_EFFORTS,
-  isReasoningEffort,
-} from "../../clients/types";
-import { ChatInteraction } from "../../types";
-import { Marked } from "../../utils/index";
-import { TokenCompressor } from "../../processors/TokenCompressor";
-import { ToolResponseCache } from "../../processors/ToolResponseCache";
-import {
-  CustomVariables,
-  XmlToolCallProcessor,
-  HarmonyToolProcessor,
-  GemmaToolProcessor,
-  Base64ImageProcessor,
-  MinimalToolsMessageProcessor,
-} from "../../processors/index";
-import { TaskInfo } from "../types";
-import { createAgent, agentConstructors, AgentName } from "../../agents";
-import { ToolCallEvent } from "../../agents/base/base";
-import { rollbackAgentInteractions } from "../../agents/historyRollback";
-import { KnowhowSimpleClient } from "../../services/KnowhowClient";
-import { TraceAll } from "../../util/Trace";
-
-@TraceAll()
-export class AgentModule extends BaseChatModule {
-  name = "agent";
-  description = "Agent interaction functionality";
-
-  /** Currently attached agent (for agent:attached mode commands) */
-  private attachedAgent: AttachableAgent | undefined;
-
-  // Service instances for task management, session management, and synchronization
-  private taskRegistry: TaskRegistry;
-  private sessionManager: SessionManager;
-  /** Timestamp when this process started - used to filter sessions */
-  private processStartTime: number = Date.now();
-  /** Currently attached agent task ID */
-  private activeAgentTaskId: string | undefined;
-  /** Currently active synced agent watcher (for FS or Web agents) */
-  private activeSyncedWatcher: SyncedAgentWatcher | undefined;
-
-  /** Reasoning effort to apply to agents started from this module */
-  private reasoningEffort: CompletionOptions["reasoning_effort"] | undefined = undefined;
-  /** Whether to request a reasoning summary from supporting models */
-  private summarizeReasoning: boolean = true;
-
-  /** Delayed finalAnswer output, cancelled when the task's done event arrives. */
-  private pendingFinalAnswers = new Map<string, ReturnType<typeof setTimeout>>();
-
-  /** Stored wire params for rewireAgentRendering */
-  private _wireAgentEvents: EventService | undefined;
-  private _wireTaskId: string | undefined;
-  private _wireAgentName: string | undefined;
-  /** Optional reference to RemoteSyncModule for auto-sync on new tasks */
-  private remoteSyncModule: any | undefined;
-
-  private _wireEventTypes:
-    | { toolCall?: string; toolUsed?: string; agentSay?: string; done: string }
-    | undefined;
-
-  private agentService: AgentService;
-  private eventService: EventService;
-
-  constructor() {
-    super();
-    this.taskRegistry = new TaskRegistry();
-    this.sessionManager = new SessionManager();
-    this.agentService = services().Agents;
-    this.eventService = services().Events;
-  }
-
-  /**
-   * Set the RemoteSyncModule reference for auto-sync support.
-   * Called from InternalChatModule after both modules are created.
-   */
-  public setRemoteSyncModule(module: any): void {
-    this.remoteSyncModule = module;
-  }
-
-  getCommands(): ChatCommand[] {
-    return [
-      {
-        name: "agent",
-        description: "Start an agent by name",
-        handler: this.handleAgentCommand.bind(this),
-      },
-      {
-        name: "agents",
-        description: "List available agents",
-        handler: this.handleAgentsCommand.bind(this),
-      },
-      {
-        name: "pause",
-        description: "Pause the currently attached agent",
-        modes: ["agent:attached"],
-        handler: async (_args: string[]): Promise<void> => {
-          if (this.attachedAgent) {
-            await this.attachedAgent.pause();
-            console.log("Agent paused.");
-          }
-        },
-      },
-      {
-        name: "unpause",
-        description: "Unpause the currently attached agent",
-        modes: ["agent:attached"],
-        handler: async (_args: string[]): Promise<void> => {
-          if (this.attachedAgent) {
-            await this.attachedAgent.unpause();
-            console.log("Agent unpaused.");
-          }
-        },
-      },
-      {
-        name: "kill",
-        description: "Kill the currently attached agent",
-        modes: ["agent:attached"],
-        handler: async (_args: string[]): Promise<void> => {
-          if (this.attachedAgent) {
-            await this.attachedAgent.kill();
-            console.log("Agent terminated.");
-            this.detachFromAgent();
-          }
-        },
-      },
-      {
-        name: "poke",
-        description:
-          "Interrupt the agent's current tool call or AI completion, so it can continue with the next step",
-        modes: ["agent:attached"],
-        handler: async (args: string[]): Promise<void> => {
-          if (this.attachedAgent) {
-            const message = args.length > 0 ? args.join(" ") : undefined;
-            this.attachedAgent.interrupt(message);
-            console.log(
-              "Agent interrupted — it will continue with the next step."
-            );
-          }
-        },
-      },
-      {
-        name: "compact",
-        description:
-          "Force the attached agent to compact (summarize) its conversation now, dropping back to a much cheaper context size",
-        modes: ["agent:attached"],
-        handler: async (_args: string[]): Promise<void> => {
-          if (!this.attachedAgent) {
-            console.log("No attached agent to compact.");
-            return;
-          }
-          if (typeof this.attachedAgent.requestCompact !== "function") {
-            console.log(
-              "This agent does not support manual compaction (remote/watcher-backed agents compact automatically)."
-            );
-            return;
-          }
-          this.attachedAgent.requestCompact();
-          // Do NOT interrupt — compaction should not cancel the in-progress
-          // tool call / AI completion. The _forceCompact flag is picked up at
-          // the compression check on the next loop iteration, once the current
-          // step finishes naturally.
-          console.log(
-            "🗜  Compaction requested — the agent will summarize and shrink its context on the next step."
-          );
-        },
-      },
-      {
-        name: "reasoning_effort",
-        description:
-          `Set the reasoning effort for the agent (${REASONING_EFFORTS.join(", ")}). Individual models support different subsets.`,
-        handler: async (args: string[]): Promise<void> => {
-          const effort = args[0];
-          if (!isReasoningEffort(effort)) {
-            console.log(
-              `Current reasoning effort: ${this.reasoningEffort ?? "(not set — model default)"}`
-            );
-            console.log(
-              `Usage: /reasoning_effort <${REASONING_EFFORTS.join("|")}>`
-            );
-            return;
-          }
-          this.reasoningEffort = effort;
-          const agent = (this.chatService?.getContext()?.selectedAgent as BaseAgent);
-          if (agent) agent.setReasoningEffort(effort);
-          console.log(`Reasoning effort set to: ${effort}`);
-        },
-      },
-      {
-        name: "effort",
-        description: "Alias for /reasoning_effort",
-        handler: async (args: string[]): Promise<void> => {
-          const effort = args[0];
-          if (!isReasoningEffort(effort)) {
-            console.log(
-              `Current reasoning effort: ${this.reasoningEffort ?? "(not set — model default)"}`
-            );
-            console.log(
-              `Usage: /effort <${REASONING_EFFORTS.join("|")}>`
-            );
-            return;
-          }
-          this.reasoningEffort = effort;
-          const agent = (this.chatService?.getContext()?.selectedAgent as BaseAgent);
-          if (agent) agent.setReasoningEffort(effort);
-          console.log(`Reasoning effort set to: ${effort}`);
-        },
-      },
-      {
-        name: "reasoning_summary",
-        description:
-          "Toggle whether the agent displays a reasoning summary (true/false). Supported by reasoning models only.",
-        handler: async (args: string[]): Promise<void> => {
-          const val = args[0];
-          if (val !== "true" && val !== "false") {
-            console.log(
-              `Current reasoning summary: ${this.summarizeReasoning}`
-            );
-            console.log(`Usage: /reasoning_summary <true|false>`);
-            return;
-          }
-          this.summarizeReasoning = val === "true";
-          const agent = (this.chatService?.getContext()?.selectedAgent as BaseAgent);
-          if (agent) agent.setSummarizeReasoning(this.summarizeReasoning);
-          console.log(`Reasoning summary set to: ${this.summarizeReasoning}`);
-        },
-      },
-      {
-        name: "detach",
-        description: "Detach from the currently attached agent",
-        modes: ["agent:attached"],
-        handler: async (_args: string[]): Promise<void> => {
-          const agent = this.attachedAgent;
-          console.log("Detached from agent");
-          // Only detach if we are still attached to THIS agent. If the user
-          // killed this agent and started a new one while this agent was
-          // finishing a long tool call, detachFromAgent() would rip out the
-          // new agent's rendering and reset the mode.
-          if (agent && this.attachedAgent === agent) {
-            this.detachFromAgent();
-          }
-        },
-      },
-      {
-        name: "done",
-        description: "Exit the current agent interaction",
-        modes: ["agent:attached"],
-        handler: async (_args: string[]): Promise<void> => {
-          this.detachFromAgent();
-        },
-      },
-    ];
-  }
-
-  /**
-   * Clean up attached agent state and restore default mode/prompt.
-   */
-  private detachFromAgent(): void {
-    this.attachedAgent = undefined;
-
-    // Unregister rendering event listeners
-    this.unwireAgentRendering();
-
-    if (this.chatService) {
-      this.chatService.setMode("default");
-    }
-
-    // Stop any active synced watcher
-    if (this.activeSyncedWatcher) {
-      this.activeSyncedWatcher.stopWatching();
-      this.activeSyncedWatcher = undefined;
-    }
-
-    const context = this.chatService?.getContext();
-    if (context) context.activeAgentTaskId = undefined;
-  }
-
-  getModes(): ChatMode[] {
-    return [
-      {
-        name: "agent",
-        description: "Agent interaction mode",
-        active: true,
-        promptText: () => {
-          const ctx = this.chatService?.getContext();
-          return ctx?.currentAgent
-            ? `\nAsk knowhow ${ctx.currentAgent}: `
-            : `\nAsk knowhow: `;
-        },
-      },
-      {
-        name: "agent:attached",
-        description: "Attached to a running agent",
-        active: false,
-        promptText: () =>
-          this.attachedAgent
-            ? `Enter command or message for ${this.attachedAgent.name}: `
-            : `Enter command or message for agent: `,
-      },
-    ];
-  }
-
-  /**
-   * Get the current renderer from the chat context, falling back to a ConsoleRenderer.
-   */
-  private get renderer(): AgentRenderer {
-    return (
-      (this.chatService?.getContext()?.renderer as AgentRenderer) ??
-      new ConsoleRenderer()
-    );
-  }
-
-  async initialize(service: ChatService): Promise<void> {
-    await super.initialize(service);
-
-    // Set up plugin log event handler - use setListener so re-init doesn't double-subscribe
-    const Events = this.eventService;
-    Events.setListener(
-      { key: "agentModule:pluginLog", event: Events.eventTypes.pluginLog },
-      (logEvent: any) => {
-        const activeTasks = this.taskRegistry.getAll();
-        this.renderer.render({
-          type: "log",
-          taskId: this.activeAgentTaskId,
-          agentName: logEvent.source,
-          message: logEvent.message,
-          level: logEvent.level || "info",
-          timestamp: logEvent.timestamp || new Date().toISOString(),
-        });
-      }
-    );
-
-    // Determine the default agent from context (set by chat.ts from config.chat.defaultAgent)
-    // falling back to "Patcher" if not configured.
-    const context = this.chatService?.getContext();
-    const defaultAgentName = context?.defaultAgent ?? "Patcher";
-    await this.handleAgentCommand([defaultAgentName]);
-
-    // Apply defaultModel and defaultProvider if configured
-    const defaultModel = context?.defaultModel;
-    const defaultProvider = context?.defaultProvider;
-    if (defaultModel || defaultProvider) {
-      const selectedAgent = context?.selectedAgent;
-      if (selectedAgent) {
-        if (defaultModel) {
-          selectedAgent.setModel(defaultModel);
-          selectedAgent.setModelPreferences([
-            { model: defaultModel, provider: defaultProvider as any },
-          ]);
-        }
-        if (defaultProvider) {
-          selectedAgent.setProvider(defaultProvider as any);
-        }
-        // Refresh context model/provider display
-        if (context) {
-          if (defaultModel) context.currentModel = defaultModel;
-          if (defaultProvider) context.currentProvider = defaultProvider;
-        }
-      }
-    }
-  }
-
-
-  async handleAgentCommand(args: string[]): Promise<void> {
-    const context = this.chatService?.getContext();
-
-    // If no args provided, toggle agent mode
-    if (args.length === 0) {
-      if (context?.agentMode) {
-        // Disable agent mode
-        if (context) {
-          context.agentMode = false;
-          context.selectedAgent = undefined;
-          context.currentAgent = undefined;
-          this.chatService.disableMode("agent");
-        }
-        console.log("Agent mode disabled. Switched to chat mode.");
-        return;
-      } else {
-        // Show usage when not in agent mode and no args
-        console.log(
-          "Agent mode is currently disabled. Use /agent <agent_name> to enable it, or /agents to list available agents."
-        );
-        return;
-      }
-    }
-
-    const agentName = args[0];
-
-    try {
-      if (agentConstructors[agentName as AgentName]) {
-        // Set selected agent in context and enable agent mode
-        if (context) {
-          // Create a temporary agent instance to read its default model/provider
-          const agentContext = this.agentService.getAgentContext();
-          const tempAgent = createAgent(
-            agentName as AgentName,
-            agentContext
-          ) as BaseAgent;
-          context.selectedAgent = tempAgent;
-          context.agentMode = true;
-          context.currentAgent = agentName;
-          // Update context's model/provider to reflect the agent's settings
-          // so /model and /provider commands show accurate information
-
-          const clientInfo = await tempAgent.clientService.getClient(
-            undefined,
-            tempAgent.getModel()
-          );
-
-          context.currentModel = clientInfo.model;
-          context.currentProvider = clientInfo.provider;
-
-          this.chatService.setMode("agent");
-        }
-
-        console.log(
-          `Agent mode enabled. Selected agent: ${agentName}. Type your task to get started.`
-        );
-      } else if (this.agentService.listAgents().includes(agentName)) {
-        // Config agent from knowhow.json
-        if (context) {
-          const configAgent = this.agentService.getAgent<BaseAgent>(agentName);
-          context.selectedAgent = configAgent;
-          context.agentMode = true;
-          context.currentAgent = agentName;
-          const clientInfo = await configAgent.clientService.getClient(
-            undefined,
-            configAgent.getModel()
-          );
-          context.currentModel = clientInfo.model;
-          context.currentProvider = clientInfo.provider;
-
-          this.chatService.setMode("agent");
-        }
-        console.log(
-          `Agent mode enabled. Selected agent: ${agentName}. Type your task to get started.`
-        );
-      } else {
-        console.log(
-          `Agent "${agentName}" not found. Use /agents to list available agents.`
-        );
-      }
-    } catch (error) {
-      console.error(`Error selecting agent ${agentName}:`, error);
-    }
-  }
-
-  /**
-   * Get the task registry for CLI access
-   */
-  public getTaskRegistry(): TaskRegistry {
-    return this.taskRegistry;
-  }
-
-  /**
-   * Get the session manager
-   */
-  public getSessionManager(): SessionManager {
-    return this.sessionManager;
-  }
-
-  /**
-   * Get the current renderer from the chat context, falling back to a ConsoleRenderer.
-   */
-  public getRenderer(): AgentRenderer {
-    return this.renderer;
-  }
-
-  /**
-   * Get the currently active synced watcher
-   */
-  public getActiveSyncedWatcher(): SyncedAgentWatcher | undefined {
-    return this.activeSyncedWatcher;
-  }
-
-  /**
-   * Set the currently active synced watcher
-   */
-  public setActiveSyncedWatcher(w: SyncedAgentWatcher | undefined): void {
-    this.activeSyncedWatcher = w;
-  }
-
-  /**
-   * Get the currently active agent task ID
-   */
-  public getActiveAgentTaskId(): string | undefined {
-    return this.activeAgentTaskId;
-  }
-
-  /**
-   * Set the currently active agent task ID
-   */
-  public setActiveAgentTaskId(id: string | undefined): void {
-    this.activeAgentTaskId = id;
-  }
-
-  private scheduleFinalAnswer(taskId: string, answer: unknown): void {
-    this.cancelFinalAnswer(taskId);
-    const renderedAnswer = typeof answer === "string"
-      ? answer
-      : JSON.stringify(answer) ?? String(answer);
-    const timeout = setTimeout(() => {
-      this.pendingFinalAnswers.delete(taskId);
-      console.log(Marked.parse(renderedAnswer));
-    }, 50);
-    this.pendingFinalAnswers.set(taskId, timeout);
-  }
-
-  private cancelFinalAnswer(taskId: string): void {
-    const timeout = this.pendingFinalAnswers.get(taskId);
-    if (!timeout) {
-      return;
-    }
-
-    clearTimeout(timeout);
-    this.pendingFinalAnswers.delete(taskId);
-  }
-
-  /**
-   * Wire up agentEvents to the renderer for a given task.
-   * Uses setListener with stable keys so re-calling automatically replaces old listeners.
-   *
-   * @param taskId    The task ID to pass through to render events
-   * @param agentEvents   An EventEmitter that emits toolCall / toolUsed / agentSay events
-   * @param eventTypes    Object with event name constants (toolCall, toolUsed, agentSay, done)
-   * @param agentName     Display name for the agent
-   */
-  public wireAgentRendering(
-    taskId: string,
-    agentEvents: EventService,
-    eventTypes: {
-      toolCall?: string;
-      toolUsed?: string;
-      agentSay?: string;
-      done: string;
-    },
-    agentName: string
-  ): void {
-    if (eventTypes.toolCall) {
-      agentEvents.setListener(
-        { key: "agentModule:render:toolCall", event: eventTypes.toolCall },
-        (data: any) =>
-          this.renderer.render({
-            type: "toolCall",
-            taskId,
-            agentName,
-            toolCall: data.toolCall,
-          })
-      );
-    }
-    if (eventTypes.toolUsed) {
-      agentEvents.setListener(
-        { key: "agentModule:render:toolUsed", event: eventTypes.toolUsed },
-        (data: any) => {
-          this.renderer.render({
-            type: "toolResult",
-            taskId,
-            agentName,
-            toolCall: data.toolCall,
-            result: data.functionResp,
-          });
-          // Give the done event a chance to render the same answer first. If the
-          // agent continues, the tool result becomes the fallback output.
-          const toolName: string = data.toolCall?.function?.name ?? "";
-          if (toolName === "finalAnswer" || toolName.endsWith("finalAnswer")) {
-            this.scheduleFinalAnswer(taskId, data.functionResp);
-          }
-        }
-      );
-    }
-    agentEvents.setListener(
-      { key: "agentModule:render:done", event: eventTypes.done },
-      () => this.cancelFinalAnswer(taskId)
-    );
-    if (eventTypes.agentSay) {
-      agentEvents.setListener(
-        { key: "agentModule:render:agentSay", event: eventTypes.agentSay },
-        (data: any) =>
-          this.renderer.render({
-            type: "agentMessage",
-            taskId,
-            agentName,
-            message: data.message,
-            role: "assistant",
-          })
-      );
-    }
-
-    // Set active task on the renderer
-    this.activeAgentTaskId = taskId;
-    this.renderer.setActiveTaskId(taskId);
-
-    // Store agentEvents reference for unwire/rewire
-    this._wireAgentEvents = agentEvents;
-    this._wireAgentName = agentName;
-    this._wireEventTypes = eventTypes;
-    this._wireTaskId = taskId;
-  }
-
-  /**
-   * Unwire rendering event listeners that were set up by wireAgentRendering().
-   * Clears the active task on the renderer.
-   */
-  public unwireAgentRendering(): void {
-    if (this._wireTaskId) {
-      this.cancelFinalAnswer(this._wireTaskId);
-    }
-    if (this._wireAgentEvents) {
-      this._wireAgentEvents.removeManagedListenersByPrefix(
-        "agentModule:render:"
-      );
-      this._wireAgentEvents = undefined;
-    }
-    this.activeAgentTaskId = undefined;
-    this.renderer.setActiveTaskId(undefined);
-  }
-
-  /**
-   * Rewire rendering event listeners to the current renderer.
-   * Call this after switching the active renderer (e.g. via /render) so that
-   * in-progress agents forward events to the new renderer.
-   * Since setListener auto-replaces, just re-call wireAgentRendering with stored params.
-   */
-  public rewireAgentRendering(): void {
-    if (
-      !this._wireAgentEvents ||
-      !this._wireTaskId ||
-      !this._wireEventTypes ||
-      !this._wireAgentName
-    )
-      return;
-    this.wireAgentRendering(
-      this._wireTaskId,
-      this._wireAgentEvents,
-      this._wireEventTypes,
-      this._wireAgentName
-    );
-  }
-
-  /**
-   * List available agents and optionally select one interactively
-   */
-  async handleAgentsCommand(args: string[]): Promise<void> {
-    try {
-      const builtinNames = Object.keys(agentConstructors);
-      const configAgentNames = this.agentService.listAgents();
-      // Merge, deduplicate, preserving built-ins first
-      const agentNames = [...new Set([...builtinNames, ...configAgentNames])];
-
-      if (agentNames.length > 0) {
-        console.log("\nAvailable agents:");
-        agentNames.forEach((name) => {
-          const isConfig = !builtinNames.includes(name);
-          console.log(`  - ${name}${isConfig ? " (config)" : ""}`);
-        });
-        console.log("─".repeat(80), "\n");
-
-        const selectedAgent = await this.chatService?.getInput(
-          "Select an agent to start: ",
-          agentNames
-        );
-
-        if (
-          selectedAgent &&
-          selectedAgent.trim() &&
-          agentNames.includes(selectedAgent.trim())
-        ) {
-          await this.handleAgentCommand([selectedAgent.trim()]);
-        } else if (selectedAgent && selectedAgent.trim()) {
-          console.log(`Agent "${selectedAgent.trim()}" not found.`);
-        }
-      }
-    } catch (error) {
-      console.error("Error listing agents:", error);
-      console.log("Could not load agents list.");
-    }
-  }
-
-  /**
-   * Get the process start time
-   */
-  public getProcessStartTime(): number {
-    return this.processStartTime;
-  }
-
-  /**
-   * Resume a session from saved state
-   */
-  public async resumeSession(
-    sessionId: string,
-    resumeReason?: string,
-    rollback: number = 0
-  ): Promise<void> {
-    try {
-      const session = this.sessionManager.loadSession(sessionId);
-      if (!session) {
-        console.error(`Session ${sessionId} not found.`);
-        return;
-      }
-      // Session files from older runs may not contain model/provider settings.
-      // Prefer task metadata, which is updated from the live agent on every
-      // thread update and is therefore the authoritative resume configuration.
-      const savedSettings = await this.loadTaskSettings(
-        session.taskId || sessionId
-      );
-      console.log(`\n🔄 Resuming session: ${sessionId}`);
-      console.log(`Agent: ${savedSettings.agentName || session.agentName}`);
-      console.log(`Original task: ${session.initialInput}`);
-      console.log(`Status: ${session.status}`);
-
-      // Build resume prompt (same pattern as resumeFromMessages)
-      const resumePrompt = [
-        "You are resuming a previously started task.",
-        session.initialInput ? `ORIGINAL REQUEST: ${session.initialInput}` : "",
-        "Please continue from where you left off and complete the original request.",
-        resumeReason ? `Reason for resuming: ${resumeReason}` : "",
-      ]
-        .filter(Boolean)
-        .join("\n");
-
-      // Restore the full message history from the last thread
-      const threads = session.threads || [];
-      // Guard against sessions saved with a flat Message[] instead of Message[][]
-      // (a bug where threadUpdate emitted a single thread instead of all threads)
-      const normalizedThreads: Message[][] =
-        threads.length > 0 && !Array.isArray(threads[0])
-          ? [threads as unknown as Message[]]
-          : (threads as Message[][]);
-      const rolledBackThreads = rollbackAgentInteractions(normalizedThreads, rollback);
-      const resumeMessages = rolledBackThreads[rolledBackThreads.length - 1] || [];
-
-      // Append the resume prompt to the last user message (or add a new one)
-      const reversedIndex = [...resumeMessages]
-        .reverse()
-        .findIndex((e) => e.role === "user" && typeof e.content === "string");
-
-      if (reversedIndex === -1) {
-        resumeMessages.push({ role: "user", content: resumePrompt });
-      } else {
-        const actualIndex = resumeMessages.length - 1 - reversedIndex;
-        resumeMessages[actualIndex] = {
-          ...resumeMessages[actualIndex],
-          content:
-            resumeMessages[actualIndex].content +
-            `\n\n<Workflow>[RESUME CONTEXT]: ${resumePrompt}</Workflow>`,
-        };
-      }
-
-      console.log("🚀 Session resuming...");
-      const context = this.chatService?.getContext();
-      const agentName =
-        savedSettings.agentName || session.agentName || context.currentAgent;
-      const previousAgentMode = context?.agentMode;
-
-      if (!agentName) {
-        console.error(`Agent ${agentName} not found.`);
-        return;
-      }
-
-      // setupAgent resolves both built-in agents and custom ConfigAgents. Do
-      // not reject config-defined agents here before it gets that opportunity.
-
-      // Start agent with Knowhow task context and restored message history
-      const remoteTaskId = asRemoteTaskId(
-        savedSettings.remoteTaskId || session.knowhowTaskId
-      );
-      const { agent, taskId } = await this.setupAgent({
-        agentName,
-        input: resumePrompt,
-        // Resume attaches to the persisted remote task; it must not create a
-        // new task from the original message placeholder.
-        remoteTaskId,
-        remoteMessageId: session.knowhowMessageId,
-        chatSessionId: session.chatSessionId,
-        syncRemote: !!remoteTaskId,
-        taskId: session.taskId || sessionId,
-        chatHistory: [],
-        run: false, // Don't run yet, we need to set up event listeners first
-        // Prefer authoritative task metadata over potentially incomplete sessions.
-        model: savedSettings.model || session.model,
-        provider: savedSettings.provider || session.provider,
-        reasoningEffort: savedSettings.reasoningEffort ?? session.reasoningEffort,
-        summarizeReasoning: savedSettings.summarizeReasoning ?? session.summarizeReasoning,
-        enabledTools: savedSettings.enabledTools || session.enabledTools,
-      });
-
-      // Match new interactive threads: local-only sessions get a fresh remote
-      // task when auto-sync is enabled.
-      if (!remoteTaskId && this.remoteSyncModule?.isAutoSyncEnabled()) {
-        this.remoteSyncModule.syncTaskInBackground(taskId);
-      }
-
-      // After resume finishes, revert to normal chat (non-agent mode) so the
-      // user can start a fresh conversation instead of staying locked in agent mode.
-      agent.agentEvents.once(agent.eventTypes.done, () => {
-        const ctx = this.chatService?.getContext();
-        if (ctx && !previousAgentMode) {
-          ctx.agentMode = false;
-          ctx.selectedAgent = undefined;
-          ctx.currentAgent = undefined;
-          this.chatService?.disableMode("agent");
-        }
-      });
-
-      await this.attachedAgentChatLoop(
-        taskId,
-        agent,
-        resumePrompt,
-        resumeMessages
-      );
-    } catch (error) {
-      console.error(
-        `Failed to resume session ${sessionId}:`,
-        (error as Error).message
-      );
-    }
-  }
-
-  async handleInput(input: string, context: ChatContext): Promise<boolean> {
-    // If in agent mode, start agent with the input as initial task (like original chat.ts)
-    if (context.agentMode && context.selectedAgent) {
-      // If we're attached to a running agent, forward input to it
-      if (this.attachedAgent) {
-        this.attachedAgent.addPendingUserMessage({
-          role: "user",
-          content: input,
-        });
-        return true;
-      }
-
-      context.chatHistory = context.chatHistory || [];
-
-      const { taskId } = await this.startAgent(
-        context.selectedAgent,
-        input,
-        context.chatHistory
-      );
-
-      context.chatHistory.push({
-        input,
-        output: "", // Output will be filled in when the agent responds and the session is updated
-        taskId,
-      });
-
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * Setup and run an agent directly with CLI options (for CLI usage)
-   */
-  public async setupAgent(options: {
-    agentName: string;
-    input: string;
-    remoteTaskId?: string;
-    remoteMessageId?: string;
-    chatSessionId?: string;
-    messageId?: string;
-    syncFs?: boolean;
-    syncRemote?: boolean;
-    provider?: string;
-    model?: string;
-    maxTimeLimit?: number; // in minutes
-    maxSpendLimit?: number; // in dollars
-    chatHistory?: ChatInteraction[];
-    run?: boolean; // whether to run immediately
-    taskId?: string; // optional pre-generated taskId
-    parentTaskId?: string; // taskId of the parent agent that spawned this task
-    // Reasoning settings to restore (e.g. on resume). When provided these take
-    // precedence over the module-level CLI defaults.
-    reasoningEffort?: CompletionOptions["reasoning_effort"];
-    summarizeReasoning?: boolean;
-    enabledTools?: string[];
-  }) {
-    const { input, chatHistory = [], agentName } = options;
-    const agentContext = this.agentService.getAgentContext();
-
-    // Resolve agent: built-in agents first, then fall back to ConfigAgents from knowhow.json
-    let agent: BaseAgent;
-    if (agentConstructors[options.agentName as AgentName]) {
-      agent = createAgent(options.agentName as AgentName, agentContext) as BaseAgent;
-    } else {
-      // Try to find a ConfigAgent registered via loadAgentsFromConfig (from knowhow.json agents[])
-      try {
-        const configAgent = this.agentService.getAgent(options.agentName);
-        agent = configAgent as unknown as BaseAgent;
-      } catch {
-        throw new Error(
-          `Agent "${options.agentName}" not found. Available agents: ${Object.keys(agentConstructors).join(", ")} (plus any agents defined in knowhow.json)`
-        );
-      }
-    }
-
-    if (options.enabledTools) {
-      agent.restoreEnabledTools(options.enabledTools);
-    }
-
-    // Restore persisted configuration before registering or saving this task.
-    // Otherwise the newly constructed agent's defaults can overwrite the
-    // original run settings during resume setup.
-    if (options.model) {
-      console.log("Setting model:", options.model);
-      agent.setModel(options.model);
-      agent.setModelPreferences([
-        { model: options.model, provider: options.provider as any },
-      ]);
-    }
-
-    if (options.provider) {
-      agent.setProvider(options.provider as any);
-    }
-
-    const effectiveReasoningEffort =
-      options.reasoningEffort !== undefined
-        ? options.reasoningEffort
-        : this.reasoningEffort;
-    if (effectiveReasoningEffort !== undefined) {
-      agent.setReasoningEffort(effectiveReasoningEffort);
-    }
-    agent.setSummarizeReasoning(
-      options.summarizeReasoning !== undefined
-        ? options.summarizeReasoning
-        : this.summarizeReasoning
-    );
-
-    let done = false;
-    let output = "Done";
-    const taskId = options.taskId || this.sessionManager.generateTaskId(input);
-    // Backwards compatibility for callers that historically supplied a remote
-    // UUID as taskId with syncRemote. Timestamped local slugs never qualify.
-    const remoteTaskId =
-      asRemoteTaskId(options.remoteTaskId) ||
-      (options.syncRemote ? asRemoteTaskId(taskId) : undefined);
-    let knowhowTaskId: string | undefined;
-
-    try {
-      // Get context for plugins
-      const context = this.chatService?.getContext();
-      const plugins = context?.plugins || [];
-
-      // Format the prompt with plugins and chat history
-      const formattedPrompt = await this.chatService.formatChatInput(
-        input,
-        plugins,
-        chatHistory
-      );
-
-      // Create task info object
-      let taskInfo: TaskInfo = {
-        taskId,
-        knowhowMessageId: options.remoteMessageId || options.messageId,
-        knowhowTaskId: remoteTaskId,
-        chatSessionId: options.chatSessionId,
-        agentName,
-        agent,
-        initialInput: input,
-        formattedPrompt,
-        status: "running",
-        startTime: Date.now(),
-        totalCost: 0,
-        enabledTools: agent.getEnabledToolNames(),
-        model: agent.getModel(),
-        provider: agent.getProvider(),
-        reasoningEffort: agent.getReasoningEffort?.(),
-        summarizeReasoning: agent.getSummarizeReasoning?.(),
-      };
-
-      // Add to task registry
-      this.taskRegistry.register(taskId, taskInfo);
-
-      // Save initial session
-      this.saveSession(taskId, taskInfo, []);
-
-      // Create a fresh SyncerService per agent task so that detaching from one
-      // agent and starting another doesn't tear down the first agent's sync.
-      const syncer = new SyncerService();
-
-      // Create sync task (SyncerService decides web vs fs internally)
-      const syncTaskId = await syncer.createTask({
-        taskId,
-        prompt: input,
-        remoteTaskId,
-        messageId: options.messageId,
-        syncFs: options.syncFs,
-        syncRemote: options.syncRemote,
-        agentName,
-        parentTaskId: options.parentTaskId,
-      });
-
-      const webTaskId = syncer.getCreatedWebTaskId();
-      taskInfo.knowhowTaskId = webTaskId;
-      this.taskRegistry.register(taskId, taskInfo);
-
-      await syncer.setupAgentSync(agent, syncTaskId);
-
-      // Set up session update listener
-      const threadUpdateHandler = async (threadState: any) => {
-        taskInfo.totalCost = agent.getTotalCostUsd();
-        // Capture the live run configuration so it's persisted for an exact
-        // resume (including mid-run model/provider fallbacks).
-        taskInfo.model = agent.getModel();
-        taskInfo.provider = agent.getProvider();
-        taskInfo.reasoningEffort = agent.getReasoningEffort?.();
-        taskInfo.summarizeReasoning = agent.getSummarizeReasoning?.();
-        taskInfo.enabledTools = agent.getEnabledToolNames();
-        // updateSession pulls the (mutated) taskInfo from the registry.
-        this.updateSession(taskId, agent.getThreads());
-      };
-      agent.agentEvents.on(agent.eventTypes.threadUpdate, threadUpdateHandler);
-
-      console.log(
-        Marked.parse(`**Starting ${agent.name} with task ID: ${taskId}...**`)
-      );
-      console.log(Marked.parse(`**Task:** ${input}`));
-
-      // Initialize new task
-      await agent.newTask(taskId);
-
-      // Record the parent task id on the agent so self-referential tools
-      // (e.g. replyToParent) can resolve who spawned this agent without
-      // relying solely on reading metadata.json off disk.
-      if (options.parentTaskId) {
-        agent.setParentTaskId(options.parentTaskId);
-      }
-
-      // Set up message processors like in original startAgent
-
-      // Register an override for askHuman to use CLI input method
-      // This keeps the askHuman tool CLI-agnostic while enabling CLI-specific behavior
-      // through the override system, achieving better separation of concerns
-      agent.tools.registerOverride(
-        "askHuman",
-        async (originalArgs: any[], originalTool: any) => {
-          const question = originalArgs[0];
-
-          // Use CLI-specific input method from CliChatService
-          const chatService = this.chatService;
-          if (!chatService) {
-            throw new Error("ChatService not available in tools context");
-          }
-          console.log("AI has asked: ");
-          console.log(Marked.parse(question), "\n");
-          return await chatService.getInput("response: ");
-        },
-        10 // Priority level
-      );
-
-      const caching = [
-        new ToolResponseCache(agent.tools).createProcessor(),
-        new TokenCompressor(agent.tools).createProcessor((msg) =>
-          Boolean(msg.role === "tool" && msg.tool_call_id)
-        ),
-      ];
-
-      const customVariables = new CustomVariables(agent.tools);
-
-      agent.messageProcessor.setProcessors("pre_call", [
-        new Base64ImageProcessor(agent.tools).createProcessor(),
-        ...caching,
-        customVariables.createProcessor(),
-      ]);
-
-      agent.messageProcessor.setProcessors("post_call", [
-        new XmlToolCallProcessor().createProcessor(),
-        new HarmonyToolProcessor().createProcessor(),
-        new GemmaToolProcessor().createProcessor(),
-      ]);
-
-      agent.messageProcessor.setProcessors("pre_tools", [
-        new MinimalToolsMessageProcessor().createProcessor(),
-      ]);
-
-      agent.messageProcessor.setProcessors("post_tools", [
-        new Base64ImageProcessor(agent.tools).createProcessor(),
-        ...caching,
-        customVariables.createRepetitionHintProcessor(),
-      ]);
-
-      // Set up event listeners
-      // Each task gets a fresh agent instance (via createAgent), so no stale listeners exist.
-      const agentLogHandler = (logData: any) => {
-        this.renderer.render({
-          type: "log",
-          taskId,
-          agentName: logData.agentName,
-          message: logData.message,
-          level: logData.level,
-          timestamp: logData.timestamp,
-        });
-      };
-      const agentStatusHandler = (statusData: any) => {
-        this.renderer.render({
-          type: "agentStatus",
-          taskId,
-          agentName: statusData.agentName,
-          statusMessage: statusData.statusMessage,
-          details: statusData.details,
-          timestamp: statusData.timestamp,
-        });
-      };
-
-      agent.agentEvents.on(agent.eventTypes.agentLog, agentLogHandler);
-      agent.agentEvents.on(agent.eventTypes.agentStatus, agentStatusHandler);
-
-      // Wire tool call / tool result / agent message rendering so that all
-      // renderer types (including PlainRenderer for non-TTY) receive events
-      // even when running via the CLI `knowhow agent` command (which uses
-      // run:true and does NOT go through attachedAgentChatLoop / wireAgentRendering).
-      const toolCallHandler = (data: any) => {
-        this.renderer.render({
-          type: "toolCall",
-          taskId,
-          agentName: agent.name,
-          toolCall: data.toolCall,
-        });
-      };
-      const toolResultHandler = (data: any) => {
-        this.renderer.render({
-          type: "toolResult",
-          taskId,
-          agentName: agent.name,
-          toolCall: data.toolCall,
-          result: data.functionResp,
-        });
-        // Give the done event a chance to render the same answer first. If the
-        // agent continues, the tool result becomes the fallback output.
-        const toolName: string = data.toolCall?.function?.name ?? "";
-        if (toolName === "finalAnswer" || toolName.endsWith("finalAnswer")) {
-          this.scheduleFinalAnswer(taskId, data.functionResp);
-        }
-      };
-      const agentSayHandler = (data: any) => {
-        this.renderer.render({
-          type: "agentMessage",
-          taskId,
-          agentName: agent.name,
-          message: data.message,
-          role: "assistant",
-        });
-      };
-      // Only register these inline render listeners for the direct CLI path
-      // (options.run === true). The interactive chat / resume / attach paths
-      // call attachedAgentChatLoop -> wireAgentRendering, which registers its
-      // own keyed render listeners. Registering both would render every
-      // toolCall / toolResult / agentMessage twice.
-      if (options.run) {
-        if (agent.eventTypes.toolCall) {
-          agent.agentEvents.on(agent.eventTypes.toolCall, toolCallHandler);
-        }
-        if (agent.eventTypes.toolUsed) {
-          agent.agentEvents.on(agent.eventTypes.toolUsed, toolResultHandler);
-        }
-        if (agent.eventTypes.agentSay) {
-          agent.agentEvents.on(agent.eventTypes.agentSay, agentSayHandler);
-        }
-      }
-      // Track the active task on the renderer so it doesn't filter out events
-      this.renderer.setActiveTaskId(taskId);
-      this.activeAgentTaskId = taskId;
-
-      const taskCompleted = new Promise<string>((resolve) => {
-        agent.agentEvents.once(agent.eventTypes.done, async (doneMsg) => {
-          console.log("🎯 [AgentModule] Task Completed");
-          this.cancelFinalAnswer(taskId);
-          done = true;
-          output = doneMsg || "No response from the AI";
-          // Remove threadUpdate listener to prevent cost sharing across tasks
-          agent.agentEvents.removeListener(
-            agent.eventTypes.threadUpdate,
-            threadUpdateHandler
-          );
-          // Remove task-specific listeners so they don't fire for the next task
-          agent.agentEvents.removeListener(
-            agent.eventTypes.agentLog,
-            agentLogHandler
-          );
-          agent.agentEvents.removeListener(
-            agent.eventTypes.agentStatus,
-            agentStatusHandler
-          );
-          // Update task info
-          taskInfo = this.taskRegistry.get(taskId);
-          // Remove tool rendering listeners
-          if (agent.eventTypes.toolCall) {
-            agent.agentEvents.removeListener(agent.eventTypes.toolCall, toolCallHandler);
-          }
-          if (agent.eventTypes.toolUsed) {
-            agent.agentEvents.removeListener(agent.eventTypes.toolUsed, toolResultHandler);
-          }
-          if (agent.eventTypes.agentSay) {
-            agent.agentEvents.removeListener(agent.eventTypes.agentSay, agentSayHandler);
-          }
-          // Clear active task on renderer
-          this.renderer.setActiveTaskId(undefined);
-          this.activeAgentTaskId = undefined;
-
-          // Wait for AgentSync to finish before resolving
-          await syncer.waitForFinalization();
-
-          if (taskInfo) {
-            taskInfo.status = "completed";
-            // Update final cost from agent
-            taskInfo.totalCost = agent.getTotalCostUsd();
-            // Update session with final state
-            this.updateSession(taskId, agent.getThreads());
-            taskInfo.endTime = Date.now();
-          }
-
-          console.log(Marked.parse(output));
-          console.log("🎯 [AgentModule] Task Complete");
-          resolve(doneMsg);
-        });
-      });
-
-      // Set up time limit if provided
-      if (options.maxTimeLimit) {
-        agent.setMaxRunTime(options.maxTimeLimit * 60 * 1000); // Convert minutes to milliseconds
-      }
-
-      console.log(`🤖 Starting agent: ${options.agentName}`);
-      console.log(`📝 Task: ${options.input}`);
-
-      if (options.maxTimeLimit) {
-        console.log(`⏱️  Time limit: ${options.maxTimeLimit} minutes`);
-      }
-      if (options.maxSpendLimit) {
-        console.log(`💰 Spend limit: $${options.maxSpendLimit}`);
-      }
-      console.log("─".repeat(50));
-
-      if (options.run) {
-        agent.call(formattedPrompt);
-      }
-
-      return {
-        agent,
-        taskId,
-        formattedPrompt,
-        initialInput: input,
-        taskCompleted,
-      };
-    } catch (error) {
-      console.error("Agent setup failed:", error);
-      this.taskRegistry.delete(taskId);
-    }
-  }
-
-  public async loadThreadsForTask(taskId: string, messageId?: string) {
-    const resumeTaskId: string = taskId;
-    const localMetadataPath = path.join(
-      ".knowhow",
-      "processes",
-      "agents",
-      resumeTaskId,
-      "metadata.json"
-    );
-
-    let threads: Message[][] = [];
-
-    // Try local FS first
-    if (!messageId && fs.existsSync(localMetadataPath)) {
-      try {
-        const raw = await fsPromises.readFile(localMetadataPath, "utf-8");
-        const metadata = JSON.parse(raw);
-        threads = metadata.threads || [];
-        console.log(`📁 Loaded threads from local FS: ${localMetadataPath}`);
-      } catch (e) {
-        console.warn(`⚠️ Failed to parse local metadata: ${e.message}`);
-      }
-    } else {
-      // Try remote via KnowhowSimpleClient
-      try {
-        const client = new KnowhowSimpleClient();
-        threads = await client.getTaskThreads(resumeTaskId);
-        console.log(`🌐 Loaded threads from remote for task: ${resumeTaskId}`);
-      } catch (e) {
-        console.warn(`⚠️ Could not load threads from remote: ${e.message}`);
-      }
-    }
-
-    return threads;
-  }
-
-  /**
-   * Load the persisted run settings (model / provider / reasoning) for a task
-   * from local FS metadata, so a headless --resume can restore the exact
-   * configuration the original run used instead of falling back to agent
-   * defaults. Returns an empty object when no local metadata is found (e.g.
-   * remote-only tasks).
-   */
-  public async loadTaskSettings(
-    taskId: string,
-    messageId?: string
-  ): Promise<{
-    model?: string;
-    provider?: string;
-    reasoningEffort?: CompletionOptions["reasoning_effort"];
-    summarizeReasoning?: boolean;
-    agentName?: string;
-    remoteTaskId?: string;
-    enabledTools?: string[];
-  }> {
-    const localMetadataPath = path.join(
-      ".knowhow",
-      "processes",
-      "agents",
-      taskId,
-      "metadata.json"
-    );
-
-    if (!messageId && fs.existsSync(localMetadataPath)) {
-      try {
-        const raw = await fsPromises.readFile(localMetadataPath, "utf-8");
-        const metadata = JSON.parse(raw);
-        return {
-          model: metadata.model,
-          provider: metadata.provider,
-          reasoningEffort: metadata.reasoningEffort,
-          summarizeReasoning: metadata.summarizeReasoning,
-          agentName: metadata.agentName,
-          remoteTaskId: asRemoteTaskId(
-            metadata.remoteTaskId || metadata.knowhowTaskId
-          ),
-          enabledTools: Array.isArray(metadata.enabledTools)
-            ? metadata.enabledTools
-            : undefined,
-        };
-      } catch (e) {
-        console.warn(`⚠️ Failed to parse local metadata for settings: ${e.message}`);
-      }
-    }
-
-    return {};
-  }
-
-  /**
-   * Resume an agent from a set of existing message threads
-   * Used by `knowhow agents resume` and interactive history commands.
-   */
-  public async resumeFromMessages(options: {
-    agentName: string;
-    input: string;
-    threads: Message[][];
-    messageId?: string;
-    taskId?: string;
-    remoteTaskId?: string;
-    syncFs?: boolean;
-    interactive?: boolean;
-    // Restore the exact model/provider/reasoning/tools the original run used.
-    model?: string;
-    provider?: string;
-    reasoningEffort?: CompletionOptions["reasoning_effort"];
-    summarizeReasoning?: boolean;
-    enabledTools?: string[];
-    rollback?: number;
-    fork?: boolean;
-  }): Promise<{ taskCompleted: Promise<string>; taskId: string }> {
-    const { agentName, input, threads, messageId, taskId } = options;
-    const action = options.fork ? "forking" : "resuming";
-
-    const remoteTaskId = asRemoteTaskId(options.remoteTaskId);
-    // Try to extract the original request from the first user message in threads
-    let originalRequest = "";
-    if (threads && threads.length > 0) {
-      const firstThread = threads[0];
-      if (Array.isArray(firstThread)) {
-        const firstUserMsg = firstThread.find(
-          (m: any) => m.role === "user" && m.content
-        );
-        if (firstUserMsg) {
-          originalRequest =
-            typeof firstUserMsg.content === "string"
-              ? firstUserMsg.content
-              : JSON.stringify(firstUserMsg.content);
-        }
-      }
-    }
-
-    // Build the resume prompt
-    const resumePrompt = [
-      `You are ${action} a previously started task.`,
-      originalRequest ? `ORIGINAL REQUEST: ${originalRequest}` : "",
-      "Please continue from where you left off.",
-      input ? input : "",
-    ]
-      .filter(Boolean)
-      .join("\n");
-
-    // Roll back at assistant boundaries so tool calls and their results are
-    // removed together, never leaving an invalid orphaned tool message.
-    const rolledBackThreads = rollbackAgentInteractions(
-      threads || [],
-      options.rollback || 0
-    );
-    const lastThread =
-      rolledBackThreads.length > 0
-        ? rolledBackThreads[rolledBackThreads.length - 1]
-        : [];
-    const resumeMessages = [...lastThread];
-
-    // find last user message index
-    const resumeIndex = [...lastThread]
-      .reverse()
-      .findIndex((e) => e.role === "user" && typeof e.content === "string");
-
-    if (resumeIndex === -1) {
-      resumeMessages.push({
-        role: "user",
-        content: resumePrompt,
-      });
-    } else {
-      const actualIndex = resumeMessages.length - 1 - resumeIndex;
-      resumeMessages[actualIndex] = {
-        ...resumeMessages[actualIndex],
-        content: `${resumeMessages[actualIndex].content}\n\n<Workflow>[RESUME CONTEXT]: ${resumePrompt}</Workflow>`,
-      };
-    }
-
-    const result = await this.setupAgent({
-      agentName,
-      input: resumePrompt,
-      // An existing task UUID always wins. messageId is only the create-new
-      // path when there is no remote task to reattach to.
-      messageId: remoteTaskId ? undefined : messageId,
-      remoteMessageId: remoteTaskId ? messageId : undefined,
-      taskId,
-      syncFs: options.syncFs,
-      remoteTaskId,
-      run: false,
-      syncRemote: !options.fork && !!remoteTaskId,
-      model: options.model,
-      provider: options.provider,
-      reasoningEffort: options.reasoningEffort,
-      summarizeReasoning: options.summarizeReasoning,
-      enabledTools: options.enabledTools,
-    });
-
-    // Interactive (chat REPL) resume: route through the attached chat loop so the
-    // renderer is wired the same way as a normal chat interaction / /attach, and
-    // the user gets agent:attached mode commands (/poke, /detach, /kill, /logs).
-    if (options.interactive) {
-      // A local-only historical task has no remote UUID to reattach to. When
-      // auto-sync is enabled, create the remote task through the exact same
-      // path used for a newly started interactive thread.
-      if (
-        !options.fork &&
-        !remoteTaskId &&
-        this.remoteSyncModule?.isAutoSyncEnabled()
-      ) {
-        this.remoteSyncModule.syncTaskInBackground(result.taskId);
-      }
-
-      await this.attachedAgentChatLoop(
-        result.taskId,
-        result.agent,
-        resumePrompt,
-        resumeMessages
-      );
-      return {
-        taskCompleted: result.taskCompleted,
-        taskId: result.taskId,
-      };
-    }
-
-    // Non-interactive (headless CLI `knowhow agents resume`) path: setupAgent was
-    // called with run:false, so no inline render listeners were registered. Wire
-    // rendering here (same keyed listeners as attachedAgentChatLoop) so the CLI
-    // still shows the agent's messages / tool calls, then start the agent.
-    this.wireAgentRendering(
-      result.taskId,
-      result.agent.agentEvents,
-      result.agent.eventTypes,
-      result.agent.name
-    );
-    result.agent.call(resumePrompt, resumeMessages);
-
-    return { taskCompleted: result.taskCompleted, taskId: result.taskId };
-  }
-
-  /**
-   * Get list of active agent tasks
-   */
-  getActiveTasks(): { taskId: string; agent: TaskInfo }[] {
-    return Array.from(this.taskRegistry.getEntries()).map(
-      ([taskId, taskInfo]) => ({
-        taskId,
-        agent: taskInfo,
-      })
-    );
-  }
-
-  /**
-   * Attach to an existing agent task
-   */
-  attachToTask(taskId: string): boolean {
-    if (this.taskRegistry.has(taskId)) {
-      console.log(Marked.parse(`**Attached to agent task: ${taskId}**`));
-      return true;
-    }
-    console.log(
-      Marked.parse(`**Task ${taskId} not found or already completed.**`)
-    );
-    return false;
-  }
-
-  /**
-   * Save session to file
-   */
-  private saveSession(
-    taskId: string,
-    taskInfo: TaskInfo,
-    threads: any[]
-  ): void {
-    this.sessionManager.saveSession(taskId, taskInfo, threads);
-  }
-
-  /**
-   * Update existing session with new thread state
-   */
-  private updateSession(taskId: string, threads: any[]): void {
-    const taskInfo = this.taskRegistry.get(taskId);
-    this.sessionManager.updateSession(taskId, taskInfo, threads);
-  }
-
-  /**
-   * Start an agent with an initial task (simplified version for now)
-   */
-  private async startAgent(
-    selectedAgent: BaseAgent,
-    initialInput: string,
-    chatHistory: ChatInteraction[] = []
-  ) {
-    try {
-      const { agent, taskId, formattedPrompt } = await this.setupAgent({
-        agentName: selectedAgent.name,
-        input: initialInput,
-        chatHistory,
-        model: selectedAgent.getModel(),
-        provider: selectedAgent.getProvider() as any,
-        run: false, // Don't run yet, we need to set up event listeners first
-      });
-
-      // If auto-sync is enabled, push this task to the remote KnowHow app
-      if (this.remoteSyncModule?.isAutoSyncEnabled()) {
-        this.remoteSyncModule.syncTaskInBackground(taskId);
-      }
-
-      await this.attachedAgentChatLoop(taskId, agent, formattedPrompt);
-
-      return { taskId };
-    } catch (error) {
-      console.error("Error starting agent:", error);
-    }
-  }
-
-  async attachedAgentChatLoop(
-    taskId: string,
-    agent: AttachableAgent,
-    initialInput?: string,
-    initialMessages?: any[]
-  ): Promise<void> {
-    try {
-      let agentFinalOutput: string | undefined;
-
-      // Set mode to agent:attached so mode-specific commands are available
-      if (this.chatService) {
-        this.chatService.setMode("agent:attached");
-      }
-
-      // Wire up rendering event listeners and track the active task
-      this.wireAgentRendering(
-        taskId,
-        agent.agentEvents,
-        agent.eventTypes,
-        agent.name
-      );
-      const context = this.chatService?.getContext();
-      if (context) context.activeAgentTaskId = taskId;
-
-      // Store the agent so the registered agent:attached commands can reference it
-      this.attachedAgent = agent;
-
-      // Set up the event listener BEFORE starting the agent to avoid race condition
-      const donePromise = new Promise<string>((resolve) => {
-        agent.agentEvents.once(agent.eventTypes.done, (doneMsg) => {
-          // Capture the agent's final output
-          agentFinalOutput = doneMsg || "No response from the AI";
-          console.log("Finished", taskId, `$${agent.getTotalCostUsd()}`);
-
-          // Update final task status
-          const finalTaskInfo = this.taskRegistry.get(taskId);
-          if (finalTaskInfo) {
-            if (finalTaskInfo.status === "running") {
-              finalTaskInfo.status = "completed";
-              finalTaskInfo.totalCost = agent.getTotalCostUsd();
-              finalTaskInfo.endTime = Date.now();
-            }
-          }
-
-          if (context.chatHistory) {
-            const found = context.chatHistory.find((h) => h.taskId === taskId);
-            if (found) found.output = agentFinalOutput;
-          }
-
-          resolve("done");
-          // Exit agent:attached mode so the prompt resets back to the default.
-          // Only detach if we are still attached to THIS agent. If the user
-          // killed this agent and started a new one (or /attached to a different
-          // one) while this agent was finishing a long tool call, calling
-          // detachFromAgent() unconditionally would rip out the new agent's
-          // rendering listeners and reset the mode, making new output invisible.
-          if (this.attachedAgent === agent) {
-            this.detachFromAgent();
-          }
-        });
-      });
-
-      // Now start the agent if we have an initial input (this means we're starting, not just attaching)
-      if (initialInput) {
-        const taskInfo = this.taskRegistry.get(taskId);
-        (agent as BaseAgent).call(
-          taskInfo?.formattedPrompt || taskInfo?.initialInput || initialInput,
-          initialMessages
-        );
-      }
-    } catch (error) {
-      console.error("Agent execution failed:", error);
-    }
-  }
-}
-
-/** Accept only backend task UUIDs; local task slugs intentionally fail. */
-function asRemoteTaskId(value: string | undefined): string | undefined {
-  return value &&
-    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
-      value
-    )
-    ? value
-    : undefined;
-}