@tyvm/knowhow 0.0.145 → 0.0.147

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:
@@ -214,7 +249,6 @@ export class SessionsModule extends BaseChatModule {
     // ── Case 1: in-memory running task ──────────────────────────────────────
     if (taskRegistry.has(id)) {
       const taskInfo = taskRegistry.get(id)!;
-      const renderer = this.agentModule.getRenderer();
       const context = this.chatService?.getContext();
       const selectedAgent = taskInfo.agent;
 
@@ -222,13 +256,9 @@ export class SessionsModule extends BaseChatModule {
         context.selectedAgent = selectedAgent;
         context.agentMode = true;
         context.currentAgent = taskInfo.agentName;
-        context.activeAgentTaskId = id;
         context.currentModel = selectedAgent.getModel();
         context.currentProvider = selectedAgent.getProvider();
       }
-      this.agentModule.setActiveAgentTaskId(id);
-      renderer.setActiveTaskId(id);
-      if (this.chatService) this.chatService.setMode("agent:attached");
 
       console.log(`🔄 Attached to running task: ${id}`);
       console.log(`   Agent : ${taskInfo.agentName}`);
@@ -237,6 +267,13 @@ export class SessionsModule extends BaseChatModule {
       console.log(
         `   Type /logs to see recent messages, or /detach to detach.`
       );
+
+      // Route through attachedAgentChatLoop so that:
+      // 1. wireAgentRendering is called (new output becomes visible)
+      // 2. attachedAgent is set (so /poke, /kill, /compact work)
+      // 3. a done listener is registered (mode resets when agent finishes)
+      // Do NOT pass initialInput — agent is already running, no need to call it again.
+      await this.agentModule.attachedAgentChatLoop(id, selectedAgent as any);
       return;
     }
 
@@ -303,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) {
@@ -326,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);
   }
 
-  private async resumeById(id: string): Promise<void> {
+  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, rollback = 0, fork = false): Promise<void> {
     const sessionManager = this.agentModule.getSessionManager();
 
-    // Check saved sessions first
     try {
       const session = sessionManager.loadSession(id);
       if (session) {
@@ -347,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}`);
@@ -382,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(
@@ -415,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/types.ts

@@ -3,6 +3,7 @@
  */
 import { ChatInteraction, Config } from "../types";
 import { BaseAgent } from "../agents/base/base";
+import { ReasoningEffort } from "../clients/types";
 import { ToolsService } from "../services";
 import { AgentRenderer } from "./renderer/types";
 
@@ -101,8 +102,9 @@ export interface TaskInfo {
   // restore the exact configuration instead of falling back to agent defaults.
   model?: string;
   provider?: string;
-  reasoningEffort?: "none" | "low" | "medium" | "high";
+  reasoningEffort?: ReasoningEffort;
   summarizeReasoning?: boolean;
+  enabledTools?: string[];
 }
 
 export interface ChatSession {
@@ -123,8 +125,9 @@ export interface ChatSession {
   // Persisted run configuration for exact resume restoration.
   model?: string;
   provider?: string;
-  reasoningEffort?: "none" | "low" | "medium" | "high";
+  reasoningEffort?: ReasoningEffort;
   summarizeReasoning?: boolean;
+  enabledTools?: string[];
 }
 
 export interface ChatHistory {

package/src/cli.ts

@@ -128,7 +128,7 @@ async function main() {
   addReplayCommand(program);
   addBehaviorsCommand(program);
   addSkillsCommand(program);
-  addAgentsCommand(program);
+  addAgentsCommand(program, getChatService);
   addHashCommand(program);
   addSandboxCommand(program);
 

package/src/clients/anthropic.ts

@@ -88,6 +88,25 @@ export class GenericAnthropicClient implements GenericClient {
     return undefined;
   }
 
+  /** Map provider-neutral effort names to Anthropic's output_config.effort. */
+  getEffortOutputConfig(
+    model: string,
+    reasoningEffort?: CompletionOptions["reasoning_effort"]
+  ): Anthropic.OutputConfig | undefined {
+    if (
+      reasoningEffort === undefined ||
+      reasoningEffort === "none" ||
+      (!alwaysOnModels.includes(model) && !optInModels.includes(model))
+    ) {
+      return undefined;
+    }
+
+    return {
+      // Anthropic uses `low` for the provider-neutral `minimal` level.
+      effort: reasoningEffort === "minimal" ? "low" : reasoningEffort,
+    };
+  }
+
   /**
    * Clean JSON Schema for Anthropic API compatibility.
    * Removes unsupported fields like additionalProperties, $ref, $defs, positional.
@@ -423,6 +442,10 @@ export class GenericAnthropicClient implements GenericClient {
       options.reasoning_effort,
       options.reasoning_summary,
     );
+    const effortOutputConfig = this.getEffortOutputConfig(
+      options.model,
+      options.reasoning_effort
+    );
 
     const systemMessage = options.messages
       .filter((msg) => msg.role === "system")
@@ -447,6 +470,7 @@ export class GenericAnthropicClient implements GenericClient {
           : undefined,
         max_tokens: options.max_tokens || 8000,
         ...(thinkingParam && { thinking: thinkingParam }),
+        ...(effortOutputConfig && { output_config: effortOutputConfig }),
         ...(tools.length && {
           tool_choice: { type: "auto" },
           tools,

package/src/clients/fireworks.ts

@@ -51,6 +51,9 @@ export class GenericFireworksClient extends HttpClient {
       ...options,
       // Strip Anthropic-specific field not accepted by Fireworks
       long_ttl_cache: undefined,
+      // This is translated by the OpenAI/Anthropic clients, but is not part of
+      // Fireworks' OpenAI-compatible chat completion schema.
+      reasoning_summary: undefined,
     };
 
     if (sanitized.tools) {

package/src/clients/gemini.ts

@@ -434,9 +434,13 @@ export class GenericGeminiClient implements GenericClient {
     // Gemini 3.x — use thinkingLevel
     if (GoogleThinkingLevelModels.includes(model)) {
       const levelMap: Record<string, string> = {
+        none: "minimal",
+        minimal: "minimal",
         low: "low",
         medium: "medium",
         high: "high",
+        xhigh: "high",
+        max: "high",
       };
       return {
         thinkingLevel: levelMap[effort] ?? "low",
@@ -447,9 +451,13 @@ export class GenericGeminiClient implements GenericClient {
     if (GoogleThinkingBudgetModels.includes(model)) {
       // Map effort to token budget
       const budgetMap: Record<string, number> = {
+        none: 0,
+        minimal: 512,
         low: 1024,
         medium: 8192,
         high: -1, // dynamic
+        xhigh: -1,
+        max: -1,
       };
       return {
         thinkingBudget: budgetMap[effort] ?? 1024,

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> = {};
 

package/src/clients/openai.ts

@@ -112,9 +112,10 @@ export class GenericOpenAiClient implements GenericClient {
 
   resolveReasoningEffort(options: CompletionOptions): "low" | "medium" | "high" {
     const effort = options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
-    // "none" is not a valid SDK ReasoningEffort — callers that need "none" should
-    // check isReasoningDisabled() separately and skip the reasoning params.
-    if (effort === "none") return "low";
+    // Chat Completions only accepts low/medium/high. Preserve newer values on
+    // the Responses API, but map them to the nearest legacy level here.
+    if (effort === "none" || effort === "minimal") return "low";
+    if (effort === "xhigh" || effort === "max") return "high";
     return effort;
   }
 
@@ -125,7 +126,9 @@ export class GenericOpenAiClient implements GenericClient {
    */
   resolveReasoningEffortForModel(options: CompletionOptions): string {
     const raw = options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
-    const requested = raw === "none" ? "none" : raw;
+    // Anthropic calls its highest level `max`; OpenAI calls it `xhigh`.
+    // Accept both provider-neutral CLI spellings.
+    const requested = raw === "max" ? "xhigh" : raw;
     const pricing = OpenAiTextPricing[options.model];
     const supportedLevels = pricing?.reasoningLevels;
     if (!supportedLevels || supportedLevels.length === 0) {

package/src/clients/types.ts

@@ -136,6 +136,26 @@ export interface RetryOptions {
   signal?: AbortSignal;
 }
 
+/**
+ * Every reasoning-effort spelling currently exposed by a supported provider.
+ * Individual models may support only a subset; provider clients are responsible
+ * for translating or clamping values where their APIs require it.
+ */
+export const REASONING_EFFORTS = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+] as const;
+export type ReasoningEffort = (typeof REASONING_EFFORTS)[number];
+
+export function isReasoningEffort(value: unknown): value is ReasoningEffort {
+  return typeof value === "string" && REASONING_EFFORTS.includes(value as ReasoningEffort);
+}
+
 export interface CompletionOptions extends RetryOptions {
   model: string;
   messages: Message[];
@@ -147,14 +167,17 @@ export interface CompletionOptions extends RetryOptions {
    * Maps to: OpenAI reasoning_effort/reasoning.effort, xAI reasoning.effort,
    *          Gemini thinkingLevel/thinkingBudget, Anthropic thinking mode.
    *
-   * "none"   = disable thinking entirely (Anthropic: thinking.type="disabled",
-   *            OpenAI: reasoning.effort="none").  Only supported by models that
-   *            allow disabling thinking (e.g. claude-sonnet-5).
-   * "low"    = minimal thinking
-   * "medium" = balanced (default for most models)
-   * "high"   = maximum reasoning
+   * "none"    = disable thinking where supported
+   * "minimal" = provider-defined minimum (for example Gemini/OpenAI)
+   * "low"     = low reasoning
+   * "medium"  = balanced reasoning
+   * "high"    = high reasoning
+   * "xhigh"   = extra-high reasoning (for example OpenAI/xAI/Anthropic)
+   * "max"     = maximum reasoning (Anthropic)
+   *
+   * A model may support only a subset of these provider-level values.
    */
-  reasoning_effort?: "none" | "low" | "medium" | "high";
+  reasoning_effort?: ReasoningEffort;
   /**
    * When true, request a summarized view of the model's thinking process.
    * - Anthropic: thinking.display = "summarized"

package/src/clients/xai.ts

@@ -52,6 +52,15 @@ export class GenericXAIClient implements GenericClient {
     });
   }
 
+  resolveLegacyReasoningEffort(
+    effort: CompletionOptions["reasoning_effort"]
+  ): "low" | "medium" | "high" | undefined {
+    if (effort === undefined || effort === "none") return undefined;
+    if (effort === "minimal") return "low";
+    if (effort === "xhigh" || effort === "max") return "high";
+    return effort;
+  }
+
   async createChatCompletion(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
@@ -72,13 +81,14 @@ export class GenericXAIClient implements GenericClient {
       return msg as ChatCompletionMessageParam;
     });
 
+    const reasoningEffort = this.resolveLegacyReasoningEffort(options.reasoning_effort);
     const response = await this.client.chat.completions.create({
       model: options.model,
       messages: xaiMessages,
       max_tokens: options.max_tokens,
-      ...(XaiReasoningModels.includes(options.model) && options.reasoning_effort && options.reasoning_effort !== "none" && {
+      ...(XaiReasoningModels.includes(options.model) && reasoningEffort && {
         // grok-3-mini models support reasoning_effort: "low" | "medium" | "high"
-        reasoning_effort: options.reasoning_effort as "low" | "medium" | "high",
+        reasoning_effort: reasoningEffort,
       }),
       ...(options.tools && {
         tools: options.tools,
@@ -206,8 +216,17 @@ export class GenericXAIClient implements GenericClient {
     // Resolve reasoning effort, clamping to supported levels if defined in pricing
     const pricing = XaiTextPricing[options.model];
     const supportedLevels = pricing?.reasoningLevels;
-    let reasoningEffort: string | undefined = options.reasoning_effort;
-    if (supportedLevels?.length) {
+    const requestedEffort = options.reasoning_effort;
+    let reasoningEffort: string | undefined;
+    if (requestedEffort !== "none") {
+      reasoningEffort =
+        requestedEffort === "minimal"
+          ? "low"
+          : requestedEffort === "max"
+            ? "xhigh"
+            : requestedEffort;
+    }
+    if (requestedEffort !== "none" && supportedLevels?.length) {
       if (!reasoningEffort || !supportedLevels.includes(reasoningEffort)) {
         reasoningEffort = supportedLevels[0];
       }

package/src/commands/agent.ts

@@ -8,6 +8,7 @@ import { SessionsModule } from "../chat/modules/SessionsModule";
 import { SetupModule } from "../chat/modules/SetupModule";
 import { PlainRenderer } from "../chat/renderer/PlainRenderer";
 import { loadRenderer } from "../chat/renderer/loadRenderer";
+import { isReasoningEffort, REASONING_EFFORTS } from "../clients/types";
 import { getConfig } from "../config";
 
 async function setupRenderer(chatService: any, rendererSpecifier: string): Promise<void> {
@@ -54,10 +55,10 @@ 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: none, low, medium, or high. Use 'none' to disable thinking on models that support it (e.g. for faster computer-use)."
+      `Reasoning effort: ${REASONING_EFFORTS.join(", ")}. Individual models support different subsets.`
     )
     .option(
       "--max-time-limit <minutes>",
@@ -93,16 +94,20 @@ 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)"
     )
     .action(async (options) => {
       try {
+        if (
+          options.reasoningEffort !== undefined &&
+          !isReasoningEffort(options.reasoningEffort)
+        ) {
+          throw new Error(
+            `Invalid reasoning effort "${options.reasoningEffort}". Expected one of: ${REASONING_EFFORTS.join(", ")}.`
+          );
+        }
         const { setupServices } = await import("./services");
         await setupServices();
         const chatService = getChatService();
@@ -115,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) {