@tyvm/knowhow 0.0.129 → 0.0.130

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.129",
+  "version": "0.0.130",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {
@@ -35,7 +35,6 @@
   "license": "MIT",
   "devDependencies": {
     "@babel/preset-typescript": "^7.23.3",
-    "typescript": "^5.0.0",
     "@types/diff": "^5.2.1",
     "@types/express": "^4.17.13",
     "@types/jest": "^29.5.13",
@@ -47,10 +46,11 @@
     "ts-jest": "^29.1.1",
     "ts-node": "^10.7.0",
     "tslint": "^6.1.3",
-    "tslint-config-prettier": "^1.18.0"
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^5.0.0"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.39.0",
+    "@anthropic-ai/sdk": "^0.111.0",
     "@google/genai": "^0.14.1",
     "@inquirer/editor": "^4.2.18",
     "@modelcontextprotocol/sdk": "^1.13.3",

package/src/agents/base/base.ts

@@ -1,6 +1,7 @@
 import { EventEmitter } from "events"; // kept for reference; agentEvents now uses EventService
 import {
   CompletionResponse,
+  CompletionOptions,
   GenericClient,
   Message,
   MessageContent,
@@ -26,6 +27,8 @@ export { Message, Tool, ToolCall };
 export interface ModelPreference {
   model: string;
   provider: keyof typeof Clients.clients;
+  reasoning_effort?: CompletionOptions["reasoning_effort"];
+  reasoning_summary?: boolean;
 }
 
 export interface AgentContext {
@@ -60,6 +63,8 @@ export abstract class BaseAgent implements IAgent {
   protected turnCount = 0;
   protected totalCostUsd = 0;
   protected currentThread = 0;
+  protected reasoningEffort: CompletionOptions["reasoning_effort"] | undefined = undefined;
+  protected summarizeReasoning: boolean | undefined = undefined;
   protected totalInputTokens = 0;
   protected totalOutputTokens = 0;
   protected totalCacheReadTokens = 0;
@@ -69,7 +74,7 @@ export abstract class BaseAgent implements IAgent {
   protected compressMinMessages = 30;
 
   // Interrupt support: resolves the currently awaited tool call or completion
-  private _interruptResolve: ((value: any) => void) | null = null;
+  private _interruptResolve: (() => void) | null = null;
 
   protected threads = [] as Message[][];
 
@@ -233,6 +238,12 @@ export abstract class BaseAgent implements IAgent {
   updatePreferences(value: ModelPreference) {
     this.setModel(value.model);
     this.setProvider(value.provider);
+    if (value.reasoning_effort !== undefined) {
+      this.reasoningEffort = value.reasoning_effort;
+    }
+    if (value.reasoning_summary !== undefined) {
+      this.summarizeReasoning = value.reasoning_summary;
+    }
   }
 
   nextModel() {
@@ -262,6 +273,22 @@ export abstract class BaseAgent implements IAgent {
     this.client = null; // Reset client to force re-fetch
   }
 
+  setReasoningEffort(effort: CompletionOptions["reasoning_effort"]) {
+    this.reasoningEffort = effort;
+  }
+
+  getReasoningEffort(): CompletionOptions["reasoning_effort"] {
+    return this.reasoningEffort;
+  }
+
+  setSummarizeReasoning(value: boolean) {
+    this.summarizeReasoning = value;
+  }
+
+  getSummarizeReasoning(): boolean | undefined {
+    return this.summarizeReasoning;
+  }
+
   getClient() {
     if (!this.client) {
       if (this.provider) {
@@ -715,10 +742,10 @@ export abstract class BaseAgent implements IAgent {
     return new Promise<T>((resolve, reject) => {
       let interrupted = false;
 
-      this._interruptResolve = (value: any) => {
+      this._interruptResolve = () => {
         interrupted = true;
         this._interruptResolve = null;
-        resolve(value);
+        resolve(interruptValue);
       };
 
       promise
@@ -751,7 +778,7 @@ export abstract class BaseAgent implements IAgent {
   interrupt(message = "User interrupted this action you were waiting on") {
     this.log(`Interrupting current operation: ${message}`);
     if (this._interruptResolve) {
-      this._interruptResolve(message);
+      this._interruptResolve();
     } else {
       this.log("No active interruptible operation to interrupt", "warn");
     }
@@ -848,6 +875,8 @@ export abstract class BaseAgent implements IAgent {
           tools: this.getEnabledTools(),
           tool_choice: "auto",
           long_ttl_cache: this.runTime() > 300_000,
+          ...(this.reasoningEffort !== undefined && { reasoning_effort: this.reasoningEffort }),
+          ...(this.summarizeReasoning !== undefined && { reasoning_summary: this.summarizeReasoning }),
         },
         { interruptValue: interruptResponse }
       );
@@ -1230,7 +1259,13 @@ export abstract class BaseAgent implements IAgent {
     toolCalls: ToolCall[],
     response: CompletionResponse
   ): { role: string; content: string } | null {
-    const outputTokens: number = response?.usage?.completion_tokens || 0;
+    // Subtract thinking/reasoning tokens — they're billed as output tokens but
+    // don't produce visible argument content, so including them inflates the heuristic.
+    const rawOutputTokens: number = response?.usage?.completion_tokens || 0;
+    const thinkingTokens: number =
+      (response?.usage?.output_tokens_details?.thinking_tokens ?? 0) +
+      (response?.usage?.output_tokens_details?.reasoning_tokens ?? 0);
+    const outputTokens = Math.max(0, rawOutputTokens - thinkingTokens);
     const totalArgLength = toolCalls.reduce(
       (sum, tc) => sum + (tc.function?.arguments?.length || 0),
       0

package/src/agents/tools/index.ts

@@ -23,3 +23,4 @@ export * from "./stringReplace";
 export * from "./startAgentTask";
 export * from "./ycmd";
 export * from "./mcp";
+export * from "./skills";

package/src/agents/tools/list.ts

@@ -7,6 +7,7 @@ import * as language from "./language/definitions";
 import * as mcp from "./mcp/definitions";
 import { googleSearchDefinition } from "./googleSearch";
 import { startAgentTaskDefinition } from "./startAgentTask";
+import { skillsToolDefinitions } from "./skills";
 
 function getPluginNames(): string {
   try {
@@ -681,4 +682,5 @@ export const includedTools = [
   ...ycmd.definitions,
   ...language.definitions,
   ...mcp.definitions,
+  ...skillsToolDefinitions,
 ] as Tool[];

package/src/agents/tools/skills.ts

@@ -0,0 +1,79 @@
+import { ToolsService } from "../../services/Tools";
+import { services } from "../../services";
+
+/**
+ * List all skills currently loaded in memory.
+ * Returns a formatted string of name: description lines.
+ */
+export async function listSkills(this: ToolsService): Promise<string> {
+  const toolService =
+    this instanceof ToolsService ? (this as ToolsService) : services().Tools;
+
+  const { Behaviors } = toolService.getContext();
+
+  const skills = Behaviors.listSkills();
+  if (skills.length === 0) {
+    return "No skills available. Run `knowhow behaviors download --skills-only` to fetch skills.";
+  }
+  return skills.map((s) => `- ${s.name}: ${s.description}`).join("\n");
+}
+
+/**
+ * Load full instructions for a named skill from memory.
+ */
+export async function loadSkill(
+  this: ToolsService,
+  name: string
+): Promise<string> {
+  const toolService =
+    this instanceof ToolsService ? (this as ToolsService) : services().Tools;
+
+  const { Behaviors } = toolService.getContext();
+
+  const skill = Behaviors.findSkill(name);
+  if (!skill) {
+    const names = Behaviors.listSkills()
+      .map((s) => s.name)
+      .join(", ");
+    return `Skill "${name}" not found. Available skills: ${names || "none"}`;
+  }
+  return `## Skill: ${skill.name}\n\n${skill.instructions}`;
+}
+
+/** Tool definitions for listSkills + loadSkill */
+export const skillsToolDefinitions = [
+  {
+    type: "function" as const,
+    function: {
+      name: "listSkills",
+      description:
+        "List all available skills by name and description. Call this to discover what skills are available before loading one.",
+      parameters: {
+        type: "object" as const,
+        positional: true,
+        properties: {} as Record<string, never>,
+        required: [] as string[],
+      },
+    },
+  },
+  {
+    type: "function" as const,
+    function: {
+      name: "loadSkill",
+      description:
+        "Load the full instructions for a named skill. Use this when you need to follow a specific skill's guidance.",
+      parameters: {
+        type: "object" as const,
+        positional: true,
+        properties: {
+          name: {
+            type: "string",
+            description:
+              "The skill name to load (must match exactly or approximately)",
+          },
+        },
+        required: ["name"] as string[],
+      },
+    },
+  },
+];

package/src/chat/modules/AgentModule.ts

@@ -18,7 +18,7 @@ import { BaseChatModule } from "./BaseChatModule";
 import { services } from "../../services/index";
 import { BaseAgent } from "../../agents/index";
 import { ChatCommand, ChatMode, ChatContext, ChatService } from "../types";
-import { Message } from "../../clients/types";
+import { Message, CompletionOptions } from "../../clients/types";
 import { ChatInteraction } from "../../types";
 import { Marked } from "../../utils/index";
 import { TokenCompressor } from "../../processors/TokenCompressor";
@@ -52,6 +52,11 @@ export class AgentModule extends BaseChatModule {
   /** 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;
+
   /** Stored wire params for rewireAgentRendering */
   private _wireAgentEvents: EventService | undefined;
   private _wireTaskId: string | undefined;
@@ -138,6 +143,78 @@ export class AgentModule extends BaseChatModule {
           }
         },
       },
+      {
+        name: "reasoning_effort",
+        description:
+          "Set the reasoning effort for the agent (none, low, medium, high). Use 'none' to disable thinking on models that support it.",
+        handler: async (args: string[]): Promise<void> => {
+          const validEfforts: CompletionOptions["reasoning_effort"][] = [
+            "none",
+            "low",
+            "medium",
+            "high",
+          ];
+          const effort = args[0] as CompletionOptions["reasoning_effort"];
+          if (!effort || !validEfforts.includes(effort)) {
+            console.log(
+              `Current reasoning effort: ${this.reasoningEffort ?? "(not set — model default)"}`
+            );
+            console.log(
+              `Usage: /reasoning_effort <${validEfforts.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 validEfforts: CompletionOptions["reasoning_effort"][] = [
+            "none",
+            "low",
+            "medium",
+            "high",
+          ];
+          const effort = args[0] as CompletionOptions["reasoning_effort"];
+          if (!effort || !validEfforts.includes(effort)) {
+            console.log(
+              `Current reasoning effort: ${this.reasoningEffort ?? "(not set — model default)"}`
+            );
+            console.log(
+              `Usage: /effort <${validEfforts.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",
@@ -754,6 +831,12 @@ export class AgentModule extends BaseChatModule {
         ]);
       }
 
+      // Apply module-level reasoning settings to the agent
+      if (this.reasoningEffort !== undefined) {
+        agent.setReasoningEffort(this.reasoningEffort);
+      }
+      agent.setSummarizeReasoning(this.summarizeReasoning);
+
       // Set up message processors like in original startAgent
 
       // Register an override for askHuman to use CLI input method

package/src/cli.ts

@@ -38,6 +38,8 @@ import {
 } from "./commands/misc";
 import { addConvertCommand } from "./commands/convert";
 import { addReplayCommand } from "./commands/replay";
+import { addBehaviorsCommand } from "./commands/behaviors";
+import { addSkillsCommand } from "./commands/skills";
 
 // Handle unhandled promise rejections gracefully — particularly from MCP SDK
 // which fires errors via event emitters that can bypass Promise.allSettled.
@@ -102,6 +104,8 @@ async function main() {
   addMcpCommands(program);
   addConvertCommand(program);
   addReplayCommand(program);
+  addBehaviorsCommand(program);
+  addSkillsCommand(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.

package/src/clients/anthropic.ts

@@ -1,6 +1,6 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { wait } from "../utils";
-import { AnthropicTextPricing } from "./pricing";
+import { AnthropicTextPricing, AnthropicModels } from "./pricing";
 import { ContextLimits } from "./contextLimits";
 import { ModelModality } from "./types";
 import { Models } from "../types";
@@ -24,6 +24,16 @@ import {
 
 type MessageParam = Anthropic.MessageParam;
 type Usage = Anthropic.Usage;
+type ThinkingParam = Anthropic.Messages.ThinkingConfigParam;
+
+const alwaysOnModels: readonly string[] = [
+  AnthropicModels.Sonnet5, AnthropicModels.Fable5,
+  AnthropicModels.Mythos5, AnthropicModels.MythosPreview,
+];
+const optInModels: readonly string[] = [
+  AnthropicModels.Opus4_8, AnthropicModels.Opus4_7,
+  AnthropicModels.Opus4_6, AnthropicModels.Sonnet4_6,
+];
 
 export class GenericAnthropicClient implements GenericClient {
   private client: Anthropic;
@@ -48,6 +58,36 @@ export class GenericAnthropicClient implements GenericClient {
     }
   }
 
+  /**
+   * Determine the Anthropic `thinking` param from CompletionOptions.
+   * Returns undefined if the model does not support thinking.
+   */
+  getThinkingParam(
+    model: string,
+    reasoning_effort?: CompletionOptions["reasoning_effort"],
+    reasoning_summary?: boolean,
+  ): ThinkingParam | undefined {
+    const effortIsNone = reasoning_effort === "none";
+    const withSummary = reasoning_summary ? ({ display: "summarized" } as const) : {};
+
+    if (alwaysOnModels.includes(model)) {
+      return effortIsNone
+        ? { type: "disabled" }
+        : { type: "adaptive", ...withSummary };
+    }
+
+    if (optInModels.includes(model)) {
+      // Only enable when explicitly requested (not "none" and not undefined).
+      if (!effortIsNone && reasoning_effort !== undefined) {
+        return { type: "adaptive", ...withSummary };
+      }
+      return undefined;
+    }
+
+    // Model does not support thinking.
+    return undefined;
+  }
+
   /**
    * Clean JSON Schema for Anthropic API compatibility.
    * Removes unsupported fields like additionalProperties, $ref, $defs, positional.
@@ -360,6 +400,13 @@ export class GenericAnthropicClient implements GenericClient {
     options: CompletionOptions
   ): Promise<CompletionResponse> {
     const longTtl = !!options.long_ttl_cache;
+
+    const thinkingParam = this.getThinkingParam(
+      options.model,
+      options.reasoning_effort,
+      options.reasoning_summary,
+    );
+
     const systemMessage = options.messages
       .filter((msg) => msg.role === "system")
       .map((msg) => msg.content || "")
@@ -382,6 +429,7 @@ export class GenericAnthropicClient implements GenericClient {
             ]
           : undefined,
         max_tokens: options.max_tokens || 8000,
+        ...(thinkingParam && { thinking: thinkingParam }),
         ...(tools.length && {
           tool_choice: { type: "auto" },
           tools,
@@ -431,6 +479,16 @@ export class GenericAnthropicClient implements GenericClient {
           total_tokens: (response.usage.input_tokens ?? 0) + (response.usage.output_tokens ?? 0),
           cache_creation_input_tokens: response.usage.cache_creation_input_tokens ?? 0,
           cache_read_input_tokens: response.usage.cache_read_input_tokens ?? 0,
+          ...((response.usage as any).thinking_input_tokens != null ||
+              (response.usage as any).output_tokens_details?.thinking_tokens != null
+            ? {
+                output_tokens_details: {
+                  thinking_tokens:
+                    (response.usage as any).thinking_input_tokens ??
+                    (response.usage as any).output_tokens_details?.thinking_tokens ?? 0,
+                },
+              }
+            : {}),
         } : undefined,
         usd_cost: this.calculateCost(options.model, response.usage),
       };

package/src/clients/openai.ts

@@ -107,7 +107,11 @@ export class GenericOpenAiClient implements GenericClient {
   }
 
   resolveReasoningEffort(options: CompletionOptions): "low" | "medium" | "high" {
-    return options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
+    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";
+    return effort;
   }
 
   /**
@@ -116,7 +120,8 @@ export class GenericOpenAiClient implements GenericClient {
    * If the requested level is not supported, picks the lowest supported level.
    */
   resolveReasoningEffortForModel(options: CompletionOptions): string {
-    const requested = options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
+    const raw = options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
+    const requested = raw === "none" ? "none" : raw;
     const pricing = OpenAiTextPricing[options.model];
     const supportedLevels = pricing?.reasoningLevels;
     if (!supportedLevels || supportedLevels.length === 0) {
@@ -130,6 +135,11 @@ export class GenericOpenAiClient implements GenericClient {
     return supportedLevels[0];
   }
 
+  /** Returns true when the caller explicitly requested thinking/reasoning to be disabled. */
+  isReasoningDisabled(options: CompletionOptions): boolean {
+    return options.reasoning_effort === "none";
+  }
+
   async createChatCompletion(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
@@ -154,7 +164,7 @@ export class GenericOpenAiClient implements GenericClient {
       model: options.model,
       messages: openaiMessages,
       max_tokens: options.max_tokens,
-      ...(OpenAiReasoningModels.includes(options.model) && {
+      ...(OpenAiReasoningModels.includes(options.model) && !this.isReasoningDisabled(options) && {
         max_tokens: undefined,
         max_completion_tokens: Math.max(options.max_tokens ?? 0, 16_000),
         reasoning_effort: this.resolveReasoningEffort(options),
@@ -186,6 +196,11 @@ export class GenericOpenAiClient implements GenericClient {
         prompt_tokens_details: {
           cached_tokens: response.usage.prompt_tokens_details?.cached_tokens ?? 0,
         },
+        ...(response.usage.completion_tokens_details?.reasoning_tokens != null && {
+          output_tokens_details: {
+            reasoning_tokens: response.usage.completion_tokens_details.reasoning_tokens,
+          },
+        }),
       } : undefined,
       usd_cost: usdCost,
     };
@@ -350,9 +365,12 @@ export class GenericOpenAiClient implements GenericClient {
       input,
       ...(instructions && { instructions }),
       // Don't limit max_output_tokens for Responses API - codex truncates tool call arguments when limited
-      ...(OpenAiReasoningModels.includes(options.model) && {
+      ...(OpenAiReasoningModels.includes(options.model) && !this.isReasoningDisabled(options) && {
         max_output_tokens: Math.max(options.max_tokens || 0, 16000),
-        reasoning: { effort: this.resolveReasoningEffortForModel(options) },
+        reasoning: {
+          effort: this.resolveReasoningEffortForModel(options),
+          ...(options.reasoning_summary && { summary: "auto" }),
+        },
       }),
       ...(tools?.length && {
         tools,
@@ -372,6 +390,11 @@ export class GenericOpenAiClient implements GenericClient {
             cached_tokens:
               response.usage.input_tokens_details?.cached_tokens ?? 0,
           },
+          ...((response.usage as any).output_tokens_details?.reasoning_tokens != null && {
+            output_tokens_details: {
+              reasoning_tokens: (response.usage as any).output_tokens_details.reasoning_tokens,
+            },
+          }),
         }
       : undefined;
 

package/src/clients/pricing/openai.ts

@@ -167,6 +167,9 @@ export const OpenAiResponsesOnlyModels: string[] = [
   OpenAiModels.GPT_55_Pro,
   OpenAiModels.GPT_55,
   OpenAiModels.GPT_5_Pro,
+  OpenAiModels.GPT_56_Sol,
+  OpenAiModels.GPT_56_Terra,
+  OpenAiModels.GPT_56_Luna,
   OpenAiModels.o1,
   OpenAiModels.o1_Pro,
 ];

package/src/clients/types.ts

@@ -86,10 +86,26 @@ export interface CompletionOptions extends RetryOptions {
   tools?: Tool[];
   tool_choice?: "auto" | "none";
   max_tokens?: number;
-  /** Reasoning effort level for models that support it.
-   *  Maps to: OpenAI reasoning_effort, xAI reasoning.effort, Gemini thinkingLevel/thinkingBudget, Anthropic thinking budget.
-   *  "low" = minimal thinking, "medium" = balanced, "high" = maximum reasoning */
-  reasoning_effort?: "low" | "medium" | "high";
+  /**
+   * Reasoning effort level for models that support it.
+   * 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
+   */
+  reasoning_effort?: "none" | "low" | "medium" | "high";
+  /**
+   * When true, request a summarized view of the model's thinking process.
+   * - Anthropic: thinking.display = "summarized"
+   * - OpenAI:    reasoning.summary = "auto"
+   * Defaults to false (no summary displayed).
+   */
+  reasoning_summary?: boolean;
   /**
    * When true, hints to the client that this task is long-running and it should
    * use a long-TTL cache where available.
@@ -115,6 +131,13 @@ export interface TokenUsage {
   output_tokens?: number;
   /** Convenience total (prompt + completion) */
   total_tokens?: number;
+  /** Breakdown of output tokens — thinking/reasoning tokens are billed as output
+   *  but should NOT be counted toward the visible-content heuristics. */
+  output_tokens_details?: {
+    /** Anthropic: thinking_tokens, OpenAI: reasoning_tokens */
+    thinking_tokens?: number;
+    reasoning_tokens?: number;
+  };
   /** Cache details */
   prompt_tokens_details?: {
     /** Tokens served from the prompt cache (reduces cost) */

package/src/clients/xai.ts

@@ -76,9 +76,9 @@ export class GenericXAIClient implements GenericClient {
       model: options.model,
       messages: xaiMessages,
       max_tokens: options.max_tokens,
-      ...(XaiReasoningModels.includes(options.model) && options.reasoning_effort && {
+      ...(XaiReasoningModels.includes(options.model) && options.reasoning_effort && options.reasoning_effort !== "none" && {
         // grok-3-mini models support reasoning_effort: "low" | "medium" | "high"
-        reasoning_effort: options.reasoning_effort,
+        reasoning_effort: options.reasoning_effort as "low" | "medium" | "high",
       }),
       ...(options.tools && {
         tools: options.tools,

package/src/commands/agent.ts

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { readPromptFile } from "../ai";
 import { AgentModule } from "../chat/modules/AgentModule";
+import { BehaviorsService, Behavior } from "../services/BehaviorsService";
 import { AskModule } from "../chat/modules/AskModule";
 import { SearchModule } from "../chat/modules/SearchModule";
 import { SessionsModule } from "../chat/modules/SessionsModule";
@@ -131,11 +132,29 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
         }
 
         await agentModule.initialize(chatService);
+
+        // Match a behavior from local disk (.knowhow/behaviors/)
+        let behaviorSystemPrompt: string | undefined;
+        let behaviorModel: string | undefined;
+        const behaviorsSvc = new BehaviorsService();
+        const matchedBehavior = behaviorsSvc.matchBehaviorLocal(input);
+        if (matchedBehavior) {
+          console.log(`🎯 Matched behavior: ${matchedBehavior.name}`);
+          if (matchedBehavior.instructions) {
+            behaviorSystemPrompt = matchedBehavior.instructions;
+          }
+          if (matchedBehavior.model) {
+            behaviorModel = matchedBehavior.model;
+          }
+        }
+
         const { taskCompleted } = await agentModule.setupAgent({
           ...options,
           input,
           maxTimeLimit: parseInt(options.maxTimeLimit, 10),
           maxSpendLimit: parseFloat(options.maxSpendLimit),
+          ...(behaviorSystemPrompt ? { systemPrompt: behaviorSystemPrompt } : {}),
+          ...(behaviorModel ? { model: behaviorModel } : {}),
           run: true,
         });
         await taskCompleted;