@tyvm/knowhow 0.0.146 → 0.0.148

package/src/chat/modules/SessionsModule.ts

@@ -5,11 +5,13 @@
  * Command semantics:
  *   /attach <taskId>  - Attach to a RUNNING session (in-memory, filesystem, or web).
  *                       If the task is completed, the user is told to use /resume instead.
- *   /resume <taskId>  - Resume a COMPLETED/saved session with optional additional context.
+ *   /resume <taskId> [--rollback N] - Continue the same saved task.
+ *   /fork <taskId> [--rollback N]   - Start a new task from saved history.
  *   /sessions         - List sessions that can be attached to or resumed.
  *   /logs [N]         - Show the last N messages from the currently attached agent.
  */
 import { BaseChatModule } from "./BaseChatModule";
+import { TraceAll } from "../../util/Trace";
 import { ChatCommand, ChatMode, ChatContext } from "../types";
 import { AgentModule } from "./AgentModule";
 import {
@@ -24,6 +26,33 @@ import { Marked } from "../../utils/index";
 import * as fs from "fs";
 import * as path from "path";
 
+export function parseHistoryCommandArgs(args: string[]): {
+  id?: string;
+  rollback: number;
+  showAll: boolean;
+} {
+  let id: string | undefined;
+  let rollback = 0;
+  let showAll = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--all") {
+      showAll = true;
+    } else if (args[i] === "--rollback") {
+      const value = args[++i];
+      rollback = Number(value);
+      if (!Number.isInteger(rollback) || rollback < 0) {
+        throw new Error("--rollback must be a non-negative integer");
+      }
+    } else if (!id) {
+      id = args[i];
+    } else {
+      throw new Error(`Unexpected argument: ${args[i]}`);
+    }
+  }
+  return { id, rollback, showAll };
+}
+
+@TraceAll()
 export class SessionsModule extends BaseChatModule {
   name = "sessions";
   description = "Session and attachment management";
@@ -49,6 +78,12 @@ export class SessionsModule extends BaseChatModule {
           "Resume a completed/saved session with optional additional context",
         handler: this.handleResumeCommand.bind(this),
       },
+      {
+        name: "fork",
+        description:
+          "Fork a saved session into a new task; use --rollback N to discard recent agent interactions",
+        handler: this.handleForkCommand.bind(this),
+      },
       {
         name: "sessions",
         description:
@@ -305,10 +340,17 @@ export class SessionsModule extends BaseChatModule {
 
   async handleResumeCommand(args: string[]): Promise<void> {
     const sessionManager = this.agentModule.getSessionManager();
+    let parsed;
+    try {
+      parsed = parseHistoryCommandArgs(args);
+    } catch (error: any) {
+      console.error(`Usage: /resume <taskId> [--rollback N] [--all]\n${error.message}`);
+      return;
+    }
 
-    if (args.length === 0 || args[0] === "--all") {
+    if (!parsed.id) {
       // Interactive: show saved sessions for selection
-      const showAll = args[0] === "--all";
+      const showAll = parsed.showAll;
       const allSessions = sessionManager.listAvailableSessions();
       const savedSessions = showAll ? allSessions : allSessions.slice(0, 10);
       if (savedSessions.length === 0) {
@@ -328,18 +370,32 @@ export class SessionsModule extends BaseChatModule {
       );
 
       if (selectedId) {
-        await this.resumeById(selectedId);
+        await this.resumeById(selectedId, parsed.rollback);
       }
       return;
     }
 
-    await this.resumeById(args[0]);
+    await this.resumeById(parsed.id, parsed.rollback);
+  }
+
+  async handleForkCommand(args: string[]): Promise<void> {
+    let parsed;
+    try {
+      parsed = parseHistoryCommandArgs(args);
+    } catch (error: any) {
+      console.error(`Usage: /fork <taskId> [--rollback N]\n${error.message}`);
+      return;
+    }
+    if (!parsed.id) {
+      console.error("Usage: /fork <taskId> [--rollback N]");
+      return;
+    }
+    await this.resumeById(parsed.id, parsed.rollback, true);
   }
 
-  private async resumeById(id: string): Promise<void> {
+  private async resumeById(id: string, rollback = 0, fork = false): Promise<void> {
     const sessionManager = this.agentModule.getSessionManager();
 
-    // Check saved sessions first
     try {
       const session = sessionManager.loadSession(id);
       if (session) {
@@ -349,34 +405,46 @@ export class SessionsModule extends BaseChatModule {
         console.log(`   Status : ${session.status}`);
 
         const additionalContext = await this.chatService?.getInput(
-          "Add any additional context for resuming this session (or press Enter to skip): "
-        );
-        await this.agentModule.resumeSession(
-          id,
-          additionalContext?.trim() || undefined
+          `Add any additional context for ${fork ? "forking" : "resuming"} this session (or press Enter to skip): `
         );
+        if (fork) {
+          const result = await this.agentModule.resumeFromMessages({
+            agentName: session.agentName,
+            threads: session.threads,
+            input: additionalContext?.trim() || session.initialInput,
+            interactive: true,
+            rollback,
+            fork: true,
+            model: session.model,
+            provider: session.provider,
+            reasoningEffort: session.reasoningEffort,
+            summarizeReasoning: session.summarizeReasoning,
+            enabledTools: session.enabledTools,
+          });
+          console.log(`🌿 Forked ${id} into new task ${result.taskId}`);
+        } else {
+          await this.agentModule.resumeSession(
+            id,
+            additionalContext?.trim() || undefined,
+            rollback
+          );
+        }
         return;
       }
-    } catch {
+    } catch (e: any) {
+      if (e?.message?.includes("rollback")) throw e;
       // not found as a saved session
     }
 
-    // Check filesystem agent (may have metadata with threads)
     const fsAgentPath = path.join(".knowhow", "processes", "agents", id);
     if (fs.existsSync(fsAgentPath)) {
-      // Try to load threads from metadata.json and resume
       const metadataPath = path.join(fsAgentPath, "metadata.json");
       if (fs.existsSync(metadataPath)) {
         try {
-          const raw = fs.readFileSync(metadataPath, "utf-8");
-          const metadata = JSON.parse(raw);
+          const metadata = JSON.parse(fs.readFileSync(metadataPath, "utf-8"));
           const threads: any[] = metadata.threads || [];
           const agentName = metadata.agentName || "Developer";
-
-          // Try to get initialInput from the saved session file (more complete)
-          // since metadata.json doesn't always store it
-          const savedSession = sessionManager.loadSession(id);
-          const initialInput = savedSession?.initialInput || metadata.initialInput || metadata.prompt || "";
+          const initialInput = metadata.initialInput || metadata.prompt || "";
 
           console.log(`\n📋 Found task in filesystem: ${id}`);
           console.log(`   Agent  : ${agentName}`);
@@ -384,30 +452,33 @@ export class SessionsModule extends BaseChatModule {
           console.log(`   Status : ${metadata.status || "unknown"}`);
 
           const additionalContext = await this.chatService?.getInput(
-            "Add any additional context for resuming this session (or press Enter to skip): "
+            `Add any additional context for ${fork ? "forking" : "resuming"} this session (or press Enter to skip): `
           );
-
-          // Normalize threads: if flat Message[] (old buggy format), wrap in array
           const normalizedThreads = threads.length > 0 && !Array.isArray(threads[0])
             ? [threads]
             : threads;
-
-          await this.agentModule.resumeFromMessages({
+          const result = await this.agentModule.resumeFromMessages({
             agentName,
-            taskId: id,
+            remoteTaskId: fork
+              ? undefined
+              : metadata.remoteTaskId || metadata.knowhowTaskId,
+            taskId: fork ? undefined : id,
             threads: normalizedThreads,
-            input: additionalContext?.trim() || initialInput || "",
+            input: additionalContext?.trim() || initialInput,
             interactive: true,
-            // Restore the exact model/provider/reasoning the run used so
-            // resuming doesn't silently drop back to agent defaults.
+            rollback,
+            fork,
             model: metadata.model,
             provider: metadata.provider,
             reasoningEffort: metadata.reasoningEffort,
             summarizeReasoning: metadata.summarizeReasoning,
+            enabledTools: metadata.enabledTools,
           });
+          if (fork) console.log(`🌿 Forked ${id} into new task ${result.taskId}`);
           return;
         } catch (e: any) {
           console.error(`⚠️  Failed to load metadata for task ${id}: ${e.message}`);
+          return;
         }
       }
       console.log(
@@ -417,9 +488,7 @@ export class SessionsModule extends BaseChatModule {
       return;
     }
 
-    console.log(
-      `Session "${id}" not found. Use /sessions to list available sessions.`
-    );
+    console.log(`Session "${id}" not found. Use /sessions to list available sessions.`);
   }
 
   // ─────────────────────────────────────────────────────────────────────────────

package/src/chat/modules/SetupModule.ts

@@ -1,4 +1,5 @@
 import { services } from "../../services";
+import { TraceAll } from "../../util/Trace";
 import { login } from "../../login";
 import { ask } from "../../utils";
 import { CliChatService } from "../CliChatService";
@@ -6,6 +7,7 @@ import { ChatCommand, ChatMode } from "../types";
 import { AgentModule } from "./AgentModule";
 import { BaseChatModule } from "./BaseChatModule";
 
+@TraceAll()
 export class SetupModule extends BaseChatModule {
   name = "setup";
   description = "Setup commands";

package/src/chat/modules/ShellCommandModule.ts

@@ -1,4 +1,5 @@
 import { BaseChatModule } from "./BaseChatModule";
+import { TraceAll } from "../../util/Trace";
 import { ChatCommand, ChatContext, CommandResult } from "../types";
 import { execSync } from "child_process";
 
@@ -7,6 +8,7 @@ import { execSync } from "child_process";
  * /! - Execute command and display output in console (interactive if needed)
  * /!! - Execute command and send output to the AI agent
  */
+@TraceAll()
 export class ShellCommandModule extends BaseChatModule {
   name = "shell-command";
   description = "Execute shell commands with /! and /!!";

package/src/chat/modules/SystemModule.ts

@@ -1,10 +1,12 @@
 import { BaseChatModule } from "./BaseChatModule";
+import { TraceAll } from "../../util/Trace";
 import { CliChatService } from "../CliChatService";
 import { ChatCommand, ChatMode, ChatContext } from "../types";
 import { ask } from "../../utils";
 import { services } from "../../services";
 import { Models } from "../../types";
 
+@TraceAll()
 export class SystemModule extends BaseChatModule {
   name = "system";
   description = "System commands for model, provider, debug, and clear";

package/src/chat/modules/ToolCommandModule.ts

@@ -0,0 +1,102 @@
+import { ToolCall } from "../../clients/types";
+import { services } from "../../services";
+import { BaseChatModule } from "./BaseChatModule";
+import { ChatCommand, ChatContext, CommandResult } from "../types";
+
+/** Execute registered tools directly from interactive chat. */
+export class ToolCommandModule extends BaseChatModule {
+  name = "tool-command";
+  description = "Execute a tool with /tool";
+
+  public getCommands(): ChatCommand[] {
+    return [
+      {
+        name: "tool",
+        description: "Execute a tool call from JSON",
+        handler: (args: string[]) => this.handleToolCommand(args),
+      },
+    ];
+  }
+
+  private async handleToolCommand(args: string[]): Promise<CommandResult> {
+    const input = args.join(" ").trim();
+    if (!input) {
+      console.log('Usage: /tool {"name":"toolName","arguments":{"key":"value"}}');
+      return { handled: true };
+    }
+
+    let toolCall: ToolCall;
+    try {
+      toolCall = this.parseToolCall(input);
+    } catch (error: any) {
+      console.error(`Invalid tool call JSON: ${error.message}`);
+      return { handled: true };
+    }
+
+    const tools = this.chatService.getTools() || services().Tools;
+    if (!tools) {
+      console.error("Tool execution failed: no tool service is available");
+      return { handled: true };
+    }
+
+    try {
+      const context = this.chatService.getContext();
+      const result = await tools.callTool(
+        toolCall,
+        tools.getFunctionNames(),
+        {
+          caller: context.selectedAgent,
+          taskId: context.activeAgentTaskId,
+        }
+      );
+
+      const toolError = result.toolMessages?.find(
+        (message: any) => message.name === "error"
+      );
+      if (toolError) {
+        console.error(`Tool execution failed: ${toolError.content}`);
+      } else {
+        const output = result.functionResp;
+        console.log(
+          typeof output === "object"
+            ? JSON.stringify(output, null, 2)
+            : String(output)
+        );
+      }
+    } catch (error: any) {
+      console.error(`Tool execution failed: ${error.message || String(error)}`);
+    }
+
+    return { handled: true };
+  }
+
+  private parseToolCall(input: string): ToolCall {
+    const parsed = JSON.parse(input);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("expected a JSON object");
+    }
+
+    const fn = parsed.function || parsed;
+    if (!fn || typeof fn.name !== "string" || !fn.name.trim()) {
+      throw new Error('expected a non-empty "name" (or "function.name")');
+    }
+
+    const args = fn.arguments === undefined ? {} : fn.arguments;
+    if (typeof args !== "string" && (args === null || typeof args !== "object")) {
+      throw new Error('"arguments" must be a JSON object, array, or JSON string');
+    }
+
+    return {
+      id: typeof parsed.id === "string" ? parsed.id : `chat_tool_${Date.now()}`,
+      type: "function",
+      function: {
+        name: fn.name,
+        arguments: typeof args === "string" ? args : JSON.stringify(args),
+      },
+    };
+  }
+
+  async handleInput(input: string, context: ChatContext): Promise<boolean> {
+    return false;
+  }
+}

package/src/chat/modules/index.ts

@@ -4,4 +4,5 @@ export { AgentModule } from './AgentModule';
 export { VoiceModule } from './VoiceModule';
 export { InternalChatModule } from './InternalChatModule';
 export { ShellCommandModule } from './ShellCommandModule';
+export { ToolCommandModule } from './ToolCommandModule';
 export { RendererModule } from './RendererModule';

package/src/chat/types.ts

@@ -45,7 +45,7 @@ export interface CommandResult {
 export interface ChatCommand {
   name: string;
   description: string;
-  handler: (args: string[]) => Promise<void | CommandResult>;
+  handler: (args: string[], chatService?: ChatService) => Promise<void | CommandResult>;
   modes?: string[]; // Commands can specify which modes they're available in
 }
 
@@ -104,6 +104,7 @@ export interface TaskInfo {
   provider?: string;
   reasoningEffort?: ReasoningEffort;
   summarizeReasoning?: boolean;
+  enabledTools?: string[];
 }
 
 export interface ChatSession {
@@ -126,6 +127,7 @@ export interface ChatSession {
   provider?: string;
   reasoningEffort?: ReasoningEffort;
   summarizeReasoning?: boolean;
+  enabledTools?: string[];
 }
 
 export interface ChatHistory {

package/src/cli.ts

@@ -62,6 +62,7 @@ import { addSkillsCommand } from "./commands/skills";
 import { addAgentsCommand } from "./commands/agents";
 import { addHashCommand } from "./commands/hash";
 import { addSandboxCommand } from "./commands/sandbox";
+import { addProcessesCommand } from "./commands/processes";
 
 // Handle unhandled promise rejections gracefully — particularly from MCP SDK
 // which fires errors via event emitters that can bypass Promise.allSettled.
@@ -128,18 +129,24 @@ async function main() {
   addReplayCommand(program);
   addBehaviorsCommand(program);
   addSkillsCommand(program);
-  addAgentsCommand(program);
+  addAgentsCommand(program, getChatService);
   addHashCommand(program);
   addSandboxCommand(program);
+  addProcessesCommand(program);
 
   // Load global modules early (before parse) so they can register CLI subcommands.
   // We pass only the Program in context — no services are spun up at this stage.
   // Each module's command action is responsible for calling setupServices() as needed.
   try {
     const globalConfig = await getGlobalConfig();
+    const globalModules = [...new Set(globalConfig.modules || [])];
+    const localModules = [...new Set(config.modules || [])];
+    // Local modules take precedence: if a module appears in both global and
+    // local configs, use the local version so it resolves against local
+    // node_modules first. This prevents duplicate command registration errors.
     const allModulePaths = [
-      ...(globalConfig.modules || []),
-      ...(config.modules || []),
+      ...globalModules.filter((m) => !localModules.includes(m)),
+      ...localModules,
     ];
     if (allModulePaths.length) {
       const earlyModulesService = new ModulesService();

package/src/clients/http.ts

@@ -1,4 +1,4 @@
-import http from "../utils/http";
+import http, { HTTP_UNAUTHORIZED_HANDLER, RefreshableHeaders } from "../utils/http";
 import {
   GenericClient,
   CompletionOptions,
@@ -17,16 +17,72 @@ export interface HttpClientOptions {
   extra_body?: Record<string, any>;
 }
 
+/**
+ * Optional callback that, when set, is called whenever a 401 is received
+ * (reactive refresh) or whenever `needsRefresh()` returns true before a
+ * request (proactive refresh).  Override this in a subclass or set it
+ * directly on an instance:
+ *
+ *   client.refreshToken = async () => { const newJwt = await ...; client.setJwt(newJwt); };
+ */
+export type RefreshTokenFn = () => Promise<void>;
+
 export class HttpClient implements GenericClient {
   /** Timeout in milliseconds for HTTP requests. Default: 30000 (30s). Use 0 to disable. */
   private timeout: number;
-  private headers: Record<string, string>;
+  private headers: RefreshableHeaders;
   private extra_body: Record<string, any>;
   /** Optional pricing table: model id → per-million-token prices */
   private pricingMap: Record<string, ModelPricing> = {};
 
+  /**
+   * Override this to provide automatic token refresh.  Called reactively on
+   * 401 responses (via HTTP_UNAUTHORIZED_HANDLER) and proactively before
+   * each request when `needsRefresh()` returns true.
+   *
+   * The implementation should obtain a new token and call `this.setJwt()`
+   * (or `this.setKey()`) before returning.
+   */
+  refreshToken: RefreshTokenFn | undefined = undefined;
+
+  /**
+   * Override this to provide proactive expiry detection.  When it returns
+   * `true`, `refreshToken()` is called before the next outgoing request.
+   * The default implementation decodes the JWT `exp` claim (< 5 min window).
+   */
+  needsRefresh(): boolean {
+    const authHeader = (this.headers as Record<string, string>)["Authorization"];
+    if (!authHeader) return false;
+    const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : authHeader;
+    try {
+      const parts = token.split(".");
+      if (parts.length !== 3) return false;
+      const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+      return typeof payload.exp === "number" && payload.exp * 1000 - Date.now() < 5 * 60 * 1000;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Call before each outgoing request to proactively refresh an expiring
+   * token.  No-ops when no `refreshToken` hook is set.
+   */
+  private async refreshIfNeeded(): Promise<void> {
+    if (this.refreshToken && this.needsRefresh()) {
+      await this.refreshToken();
+    }
+  }
+
   constructor(private baseUrl: string, options: HttpClientOptions = {}) {
     this.headers = options.headers ?? {};
+    // Wire the reactive 401 handler so the low-level http util can retry once
+    // after a token refresh without callers needing to do anything extra.
+    Object.defineProperty(this.headers, HTTP_UNAUTHORIZED_HANDLER, {
+      enumerable: false,
+      configurable: true,
+      get: () => this.refreshToken ? () => this.refreshToken!() : undefined,
+    });
     this.timeout = options.timeout ?? 30000;
     this.extra_body = options.extra_body ?? {};
   }
@@ -69,10 +125,8 @@ export class HttpClient implements GenericClient {
   }
 
   setJwt(jwt: string) {
-    this.headers = {
-      ...this.headers,
-      Authorization: `Bearer ${jwt}`,
-    };
+    // Mutate in-place to preserve the HTTP_UNAUTHORIZED_HANDLER symbol property.
+    this.headers.Authorization = `Bearer ${jwt}`;
   }
 
   setBaseUrl(baseUrl: string) {
@@ -163,7 +217,8 @@ export class HttpClient implements GenericClient {
     if (options.timeout !== undefined) this.timeout = options.timeout;
     if (options.extra_body !== undefined) this.extra_body = options.extra_body;
     if (options.headers) {
-      this.headers = { ...this.headers, ...options.headers };
+      // Mutate in-place to preserve the HTTP_UNAUTHORIZED_HANDLER symbol property.
+      Object.assign(this.headers, options.headers);
     }
   }
 
@@ -183,6 +238,7 @@ export class HttpClient implements GenericClient {
   async createChatCompletion(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
+    await this.refreshIfNeeded();
     return this.withRetry(async () => {
       const body = {
         ...options,
@@ -232,6 +288,7 @@ export class HttpClient implements GenericClient {
   async *createChatCompletionStream(
     options: CompletionOptions
   ): AsyncGenerator<StreamChunk> {
+    await this.refreshIfNeeded();
     const body = {
       ...options,
       model: options.model,
@@ -316,6 +373,7 @@ export class HttpClient implements GenericClient {
     options: CompletionOptions,
     store = false
   ): Promise<CompletionResponse> {
+    await this.refreshIfNeeded();
     return this.withRetry(async () => {
       // Extract system messages as instructions
       const systemMessages = options.messages.filter((m) => m.role === "system");
@@ -484,6 +542,7 @@ export class HttpClient implements GenericClient {
   }
 
   async createEmbedding(options: EmbeddingOptions): Promise<EmbeddingResponse> {
+    await this.refreshIfNeeded();
     return this.withRetry(async () => {
       const response = await http.post(
         `${this.baseUrl}/v1/embeddings`,
@@ -511,6 +570,7 @@ export class HttpClient implements GenericClient {
   }
 
   async getModels(type = "all") {
+    await this.refreshIfNeeded();
     return this.withRetry(async () => {
       const response = await http.get(`${this.baseUrl}/v1/models?type=${type}`, {
         headers: this.headers as Record<string, string>,

package/src/clients/index.ts

@@ -59,6 +59,7 @@ import { GenericLlamaClient } from "./llama";
 import { GenericFireworksClient } from "./fireworks";
 import { GenericMetaClient } from "./meta";
 import { GenericQwenClient } from "./qwen";
+import { TraceAll } from "../util/Trace";
 export {
   OpenAiTextPricing,
   AnthropicTextPricing,
@@ -139,6 +140,7 @@ const DEFAULT_PROVIDERS: ModelProvider[] = [
   { provider: "qwen", envKey: "QWEN_CLOUD_API_KEY" },
 ];
 
+@TraceAll()
 export class AIClient {
   clients: Record<string, GenericClient> = {};
 
@@ -526,12 +528,14 @@ export class AIClient {
   }
 
   providerHasModel(provider: string, model: string): boolean {
+    if (!provider) return false;
     const models = this.clientModels[provider];
     if (!models) return false;
     return models.includes(model);
   }
 
   findModel(modelPrefix: string) {
+    if (!modelPrefix) return undefined;
     for (const provider of Object.keys(this.clientModels)) {
       const models = this.clientModels[provider] as string[];
       const foundModel = models.find((m) => m.startsWith(modelPrefix));

package/src/commands/agent.ts

@@ -55,7 +55,7 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
       "AI provider (openai, anthropic, google, xai)"
     )
     .option("--model <model>", "Specific model for the provider")
-    .option("--agent-name <name>", "Which agent to use", "Patcher")
+    .option("--agent-name <name>", "Which agent to use (default: Patcher)")
     .option(
       "--reasoning-effort <effort>",
       `Reasoning effort: ${REASONING_EFFORTS.join(", ")}. Individual models support different subsets.`
@@ -94,10 +94,6 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
     )
     .option("--prompt-file <path>", "Custom prompt template file with {text}")
     .option("--input <text>", "Task input (fallback to stdin if not provided)")
-    .option(
-      "--resume",
-      "Resume a previously started task using the --task-id (local FS or remote)"
-    )
     .option(
       "--renderer <name>",
       "Renderer to use: basic, compact, fancy, or a path/package (default: from config or basic)"
@@ -124,39 +120,6 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
 
         const agentModule = new AgentModule();
 
-        if (options.resume) {
-          const threads = await agentModule.loadThreadsForTask(
-            options.taskId,
-            options.messageId
-          );
-          // Restore the exact model/provider/reasoning the original run used
-          // (falls back to agent defaults when not persisted / remote-only).
-          const savedSettings = await agentModule.loadTaskSettings(
-            options.taskId,
-            options.messageId
-          );
-          const resumeInput =
-            options.input || "Please continue from where you left off.";
-
-          await agentModule.initialize(chatService);
-          const { taskCompleted: resumed } =
-            await agentModule.resumeFromMessages({
-              agentName:
-                options.agentName || savedSettings.agentName || "Patcher",
-              input: resumeInput,
-              threads,
-              messageId: options.messageId,
-              taskId: options.taskId,
-              // CLI-provided model/provider still win over persisted ones.
-              model: options.model || savedSettings.model,
-              provider: options.provider || savedSettings.provider,
-              reasoningEffort: savedSettings.reasoningEffort,
-              summarizeReasoning: savedSettings.summarizeReasoning,
-            });
-          await resumed;
-          return;
-        }
-
         let input = options.input;
 
         if (!input && !options.promptFile) {