@tyvm/knowhow 0.0.130 → 0.0.132

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.130",
+  "version": "0.0.132",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {

package/src/agents/configurable/ConfigAgent.ts

@@ -1,7 +1,6 @@
 import { AgentContext, BaseAgent } from "../base/base";
 import { Message } from "../../clients/types";
 import { Assistant, Config } from "../../types";
-import { EventService, ToolsService } from "../../services";
 import { MessageProcessor } from "../../services/MessageProcessor";
 
 export class ConfigAgent extends BaseAgent {

package/src/agents/tools/startAgentTask.ts

@@ -3,7 +3,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { spawn } from "child_process";
 
-interface StartAgentTaskParams {
+export interface StartAgentTaskParams {
   messageId?: string;
   syncFs?: boolean;
   taskId?: string;
@@ -14,6 +14,8 @@ interface StartAgentTaskParams {
   agentName?: string;
   maxTimeLimit?: number;
   maxSpendLimit?: number;
+  /** When true, wait for the agent subprocess to exit before resolving (for generate pipelines). */
+  waitForCompletion?: boolean;
 }
 
 const PROCESSES_DIR = path.join(process.cwd(), ".knowhow", "processes");
@@ -63,6 +65,7 @@ export async function startAgentTask(params: StartAgentTaskParams): Promise<stri
     agentName,
     maxTimeLimit,
     maxSpendLimit,
+    waitForCompletion,
   } = params;
   if (!prompt) {
     throw new Error("prompt is required to create a chat task");
@@ -156,24 +159,25 @@ export async function startAgentTask(params: StartAgentTaskParams): Promise<stri
         `To check status, read: ${agentTaskDir}/status.txt\n`
       : "";
 
-    // Give the agent 5 seconds to finish before detaching
-    const detachTime = 5 * 1000;
-    const tid = setTimeout(() => {
-      try { child.unref(); } catch {}
-      done(
-        `Agent started (pid=${pid}), running in background.\n` +
-        `Logs: ${logPath}\n` +
-        syncFsNote
-      );
-    }, detachTime);
-
     child.once("exit", (code) => {
-      clearTimeout(tid);
       done(
         `Agent finished with exit code ${code}.\nLogs: ${logPath}\n` +
         syncFsNote
       );
     });
+
+    if (!waitForCompletion) {
+      // Give the agent 5 seconds to finish before detaching (fire-and-forget mode)
+      const detachTime = 5 * 1000;
+      setTimeout(() => {
+        try { child.unref(); } catch {}
+        done(
+          `Agent started (pid=${pid}), running in background.\n` +
+          `Logs: ${logPath}\n` +
+          syncFsNote
+        );
+      }, detachTime);
+    }
   });
 }
 

package/src/ai.ts

@@ -1,6 +1,13 @@
 import * as fs from "fs";
 import { readFile } from "./utils";
 
+/** Options forwarded to startAgentTask when a generation source has an `agent` field */
+export type AgentOptions = {
+  syncFs?: boolean;
+  taskId?: string;
+  maxTimeLimit?: number;
+  maxSpendLimit?: number;
+};
 import OpenAI from "openai";
 import { Assistant } from "./types";
 import { convertToText } from "./conversion";
@@ -46,17 +53,24 @@ export function readPromptFile(promptFile: string, input: string) {
   return input;
 }
 
-export async function singlePrompt(userPrompt: string, model = "", agent = "") {
-  const { Agents } = services();
+export async function singlePrompt(
+  userPrompt: string,
+  model = "",
+  agent = "",
+  agentOptions?: AgentOptions
+) {
   if (agent) {
-    const agentConfig = await Agents.getAgent(agent);
-    if (!agentConfig) {
-      throw new Error(`Agent ${agent} not found`);
-    }
-    if (model) {
-      agentConfig.setModel(model);
-    }
-    return agentConfig.call(userPrompt);
+    // Route through the full AgentModule pipeline (renderer, sync-fs, limits).
+    // This ensures generate agent runs produce readable output and are observable
+    // via `knowhow agents list/tail/status`, matching `knowhow agent --input` behaviour.
+    const { startAgentTask } = await import("./agents/tools/startAgentTask");
+    return startAgentTask({
+      agentName: agent,
+      prompt: userPrompt,
+      model: model || undefined,
+      waitForCompletion: true,
+      ...(agentOptions ?? {}),
+    });
   }
 
   if (!model) {
@@ -100,6 +114,11 @@ function isContextLengthError(err: any): boolean {
  * Recursively summarize an array of texts using a split-and-summarize approach.
  * When the combined texts exceed the context window (either by estimate or actual API error),
  * split the array in half, summarize each half recursively, then combine.
+ *
+ * NOTE: when an `agent` is provided the recursive split path is skipped — agents
+ * can handle large inputs themselves (they can read files). Splitting would create
+ * multiple isolated agent runs each writing partial output. Instead the combined
+ * content is passed directly to the agent.
  */
 async function summarizeTextsRecursive(
   texts: string[],
@@ -107,7 +126,8 @@ async function summarizeTextsRecursive(
   model: string,
   agent: string,
   contextLimit: number,
-  depth = 0
+  depth = 0,
+  agentOptions?: AgentOptions
 ): Promise<string> {
   const indent = "  ".repeat(depth);
 
@@ -115,7 +135,7 @@ async function summarizeTextsRecursive(
   if (texts.length === 1) {
     const content = template.replaceAll("{text}", texts[0]);
     console.log(`${indent}summarizeTexts[depth=${depth}]: single text, ~${estimateTokens(content)} tokens`);
-    return singlePrompt(content, model, agent);
+    return singlePrompt(content, model, agent, agentOptions);
   }
 
   // Check if combined fits in context window by estimate
@@ -127,7 +147,7 @@ async function summarizeTextsRecursive(
     // Try single combined prompt — if context error, fall through to split
     console.log(`${indent}summarizeTexts[depth=${depth}]: ${texts.length} texts, ~${estimatedTokens} tokens, trying combined`);
     try {
-      return await singlePrompt(combinedContent, model, agent);
+      return await singlePrompt(combinedContent, model, agent, agentOptions);
     } catch (err: any) {
       if (!isContextLengthError(err)) throw err;
       console.log(`${indent}summarizeTexts[depth=${depth}]: API rejected (context too long), splitting in half`);
@@ -136,14 +156,22 @@ async function summarizeTextsRecursive(
     console.log(`${indent}summarizeTexts[depth=${depth}]: ${texts.length} texts, ~${estimatedTokens} tokens exceeds limit, splitting in half`);
   }
 
+  // When an agent is assigned, don't split — agents can handle large inputs and
+  // splitting would create multiple isolated agent runs that each write partial output.
+  // Instead, pass the combined content as-is even if it may exceed context limit.
+  if (agent) {
+    console.log(`${indent}summarizeTexts[depth=${depth}]: agent mode — skipping split, passing combined content to agent`);
+    return singlePrompt(combinedContent, model, agent, agentOptions);
+  }
+
   // Split texts in half and recurse
   const mid = Math.ceil(texts.length / 2);
   const left = texts.slice(0, mid);
   const right = texts.slice(mid);
 
   const [leftSummary, rightSummary] = await Promise.all([
-    summarizeTextsRecursive(left, template, model, agent, contextLimit, depth + 1),
-    summarizeTextsRecursive(right, template, model, agent, contextLimit, depth + 1),
+    summarizeTextsRecursive(left, template, model, agent, contextLimit, depth + 1, agentOptions),
+    summarizeTextsRecursive(right, template, model, agent, contextLimit, depth + 1, agentOptions),
   ]);
 
   // Combine the two halves with a final summary prompt
@@ -153,27 +181,28 @@ async function summarizeTextsRecursive(
   console.log(`${indent}summarizeTexts[depth=${depth}]: combining halves, ~${finalEstimate} tokens`);
 
   if (finalEstimate < contextLimit) {
-    return singlePrompt(finalContent, model, agent);
+    return singlePrompt(finalContent, model, agent, agentOptions);
   }
 
   // If even the combined summaries are too long, recurse one more level
-  return summarizeTextsRecursive([leftSummary, rightSummary], template, model, agent, contextLimit, depth + 1);
+  return summarizeTextsRecursive([leftSummary, rightSummary], template, model, agent, contextLimit, depth + 1, agentOptions);
 }
 
 export async function summarizeTexts(
   texts: string[],
   template: string,
   model = "",
-  agent = ""
+  agent = "",
+  agentOptions?: AgentOptions
 ) {
   const effectiveModel = model || Models.openai.GPT_54_Nano;
   const contextLimit = getModelContextLimit(effectiveModel);
 
   console.log(
-    `summarizeTexts: ${texts.length} text(s), context limit: ${contextLimit}, model: ${effectiveModel}`
+    `summarizeTexts: ${texts.length} text(s), context limit: ${contextLimit}, model: ${effectiveModel}${agent ? `, agent: ${agent}` : ""}`
   );
 
-  return summarizeTextsRecursive(texts, template, model, agent, contextLimit).catch((err) => {
+  return summarizeTextsRecursive(texts, template, model, agent, contextLimit, 0, agentOptions).catch((err) => {
     return `Texts of combined length ${texts.reduce((a, t) => a + t.length, 0)} could not be summarized due to error: ${err.message}`;
   });
 }
@@ -193,23 +222,25 @@ export async function summarizeFiles(
   files: string[],
   template: string,
   model = "",
-  agent = ""
+  agent = "",
+  agentOptions?: AgentOptions
 ) {
   const texts = [];
   for (const file of files) {
     const text = `file: ${file}\n` + (await convertToText(file));
     texts.push(text);
   }
-  return summarizeTexts(texts, template, model, agent);
+  return summarizeTexts(texts, template, model, agent, agentOptions);
 }
 
 export async function summarizeFile(
   file: string,
   template: string,
   model = "",
-  agent = ""
+  agent = "",
+  agentOptions?: AgentOptions
 ) {
-  return await summarizeFiles([file], template, model, agent);
+  return await summarizeFiles([file], template, model, agent, agentOptions);
 }
 
 /*

package/src/chat/CliChatService.ts

@@ -336,12 +336,18 @@ export class CliChatService implements ChatService {
     return fullPrompt;
   }
 
-  async startChatLoop(): Promise<void> {
+  async startChatLoop(initialCommand?: string): Promise<void> {
     // Display available commands like the original
     const availableCommands = this.getCommandsForActiveModes();
     const commandNames = availableCommands.map((cmd) => `/${cmd.name}`);
     console.log("Commands:", commandNames.join(", "));
 
+    // If an initial command was provided (e.g. from CLI), process it before
+    // entering the interactive loop so the user lands in the right state.
+    if (initialCommand) {
+      await this.processInput(initialCommand.trim());
+    }
+
     while (true) {
       // Recompute available commands each iteration so mode changes are reflected in autocomplete
       const currentCommandNames = this.getCommandsForActiveModes().map(

package/src/chat/modules/AgentModule.ts

@@ -733,22 +733,24 @@ export class AgentModule extends BaseChatModule {
     run?: boolean; // whether to run immediately
     taskId?: string; // optional pre-generated taskId
   }) {
-    if (!agentConstructors[options.agentName as AgentName]) {
-      throw new Error(
-        `Agent "${
-          options.agentName
-        }" not found. Available agents: ${Object.keys(agentConstructors).join(
-          ", "
-        )}`
-      );
-    }
-
     const { input, chatHistory = [], agentName } = options;
     const agentContext = services().Agents.getAgentContext();
-    const agent = createAgent(
-      options.agentName as AgentName,
-      agentContext
-    ) as BaseAgent;
+
+    // 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 = services().Agents.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)`
+        );
+      }
+    }
 
     let done = false;
     let output = "Done";
@@ -915,7 +917,63 @@ export class AgentModule extends BaseChatModule {
       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,
+        });
+      };
+      const agentSayHandler = (data: any) => {
+        this.renderer.render({
+          type: "agentMessage",
+          taskId,
+          agentName: agent.name,
+          message: data.message,
+          role: "assistant",
+        });
+      };
+      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) => {
+          // 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;
         agent.agentEvents.once(agent.eventTypes.done, async (doneMsg) => {
           console.log("🎯 [AgentModule] Task Completed");
           done = true;

package/src/chat/renderer/PlainRenderer.ts

@@ -0,0 +1,218 @@
+/**
+ * PlainRenderer - A plain-text, append-only renderer for non-TTY environments.
+ *
+ * Used automatically when stdout is not a TTY (e.g. redirected to a file,
+ * piped, or run in background). Emits simple timestamped log lines with no
+ * ANSI codes, no cursor movement, and no spinner — safe for logfiles.
+ *
+ * Activate explicitly via:
+ *   knowhow agent --renderer plain ...
+ * or it is selected automatically when !process.stdout.isTTY and no renderer
+ * is configured.
+ */
+
+import {
+  AgentRenderer,
+  LogEvent,
+  AgentStatusEvent,
+  ToolCallEvent,
+  ToolResultEvent,
+  AgentMessageEvent,
+  AgentDoneEvent,
+  RenderEvent,
+} from "./types";
+import { EventEmitter } from "events";
+
+function ts(): string {
+  return new Date().toISOString();
+}
+
+function truncate(s: string, n: number): string {
+  return s.length > n ? s.slice(0, n - 1) + "…" : s;
+}
+
+function formatArgs(raw: string): string {
+  try {
+    const obj = JSON.parse(raw || "{}");
+    const entries = Object.entries(obj);
+    if (!entries.length) return "{}";
+    return entries
+      .map(([k, v]) => {
+        const val = typeof v === "string" ? v : JSON.stringify(v);
+        return `${k}=${truncate(val, 80)}`;
+      })
+      .join(", ");
+  } catch {
+    return truncate(raw || "", 120);
+  }
+}
+
+function formatResult(result: any): string {
+  try {
+    const s = typeof result === "string" ? result : JSON.stringify(result);
+    return truncate(s.replace(/\s+/g, " "), 200);
+  } catch {
+    return truncate(String(result), 200);
+  }
+}
+
+export class PlainRenderer implements AgentRenderer {
+  private activeTaskId: string | undefined;
+  private emitter = new EventEmitter();
+  private paused = false;
+  private bufferedEvents: RenderEvent[] = [];
+
+  setActiveTaskId(taskId: string | undefined): void {
+    this.activeTaskId = taskId;
+  }
+
+  getActiveTaskId(): string | undefined {
+    return this.activeTaskId;
+  }
+
+  private isActiveTask(taskId: string): boolean {
+    if (!this.activeTaskId) return true;
+    return taskId === this.activeTaskId;
+  }
+
+  onLog(handler: (event: LogEvent) => void): void {
+    this.emitter.on("log", handler);
+  }
+
+  onAgentStatus(handler: (event: AgentStatusEvent) => void): void {
+    this.emitter.on("agentStatus", handler);
+  }
+
+  onToolCall(handler: (event: ToolCallEvent) => void): void {
+    this.emitter.on("toolCall", handler);
+  }
+
+  onToolResult(handler: (event: ToolResultEvent) => void): void {
+    this.emitter.on("toolResult", handler);
+  }
+
+  onAgentMessage(handler: (event: AgentMessageEvent) => void): void {
+    this.emitter.on("agentMessage", handler);
+  }
+
+  onAgentDone(handler: (event: AgentDoneEvent) => void): void {
+    this.emitter.on("agentDone", handler);
+  }
+
+  pause(): void {
+    this.paused = true;
+  }
+
+  resume(): void {
+    this.paused = false;
+    const buffered = this.bufferedEvents.splice(0);
+    for (const event of buffered) {
+      this.render(event);
+    }
+  }
+
+  render(event: RenderEvent): void {
+    if (!this.isActiveTask(event.taskId)) return;
+
+    if (this.paused) {
+      this.bufferedEvents.push(event);
+      return;
+    }
+
+    this.emitter.emit(event.type, event);
+
+    switch (event.type) {
+      case "log":
+        this._log(event);
+        break;
+      case "agentStatus":
+        this._status(event);
+        break;
+      case "toolCall":
+        this._toolCall(event);
+        break;
+      case "toolResult":
+        this._toolResult(event);
+        break;
+      case "agentMessage":
+        this._message(event);
+        break;
+      case "agentDone":
+        this._done(event);
+        break;
+    }
+  }
+
+  private _write(line: string): void {
+    process.stdout.write(line + "\n");
+  }
+
+  private _log(e: LogEvent): void {
+    const level = e.level.toUpperCase().padEnd(5);
+    this._write(`${ts()} [${level}] [${e.agentName}] ${e.message}`);
+  }
+
+  private _status(e: AgentStatusEvent): void {
+    const cost = `$${e.details.totalCostUsd.toFixed(3)}`;
+    const elapsed = `${Math.floor(e.details.elapsedMs / 1000)}s`;
+    const parts = [`cost=${cost}`, `elapsed=${elapsed}`];
+    if (e.details.remainingTurns !== undefined) {
+      parts.push(`turns_left=${e.details.remainingTurns}`);
+    }
+    if (e.details.remainingTimeMs !== undefined) {
+      parts.push(`time_left=${Math.floor(e.details.remainingTimeMs / 1000)}s`);
+    }
+    this._write(
+      `${ts()} [STATUS] [${e.agentName}] ${e.statusMessage} | ${parts.join(" | ")}`
+    );
+  }
+
+  private _toolCall(e: ToolCallEvent): void {
+    const args = formatArgs(e.toolCall.function.arguments);
+    this._write(
+      `${ts()} [TOOL->] [${e.agentName}] ${e.toolCall.function.name}(${args})`
+    );
+  }
+
+  private _toolResult(e: ToolResultEvent): void {
+    const result = formatResult(e.result);
+    this._write(
+      `${ts()} [TOOL<-] [${e.agentName}] ${e.toolCall.function.name} => ${result}`
+    );
+  }
+
+  private _message(e: AgentMessageEvent): void {
+    if (e.role !== "assistant") return;
+    // Print the message with line-by-line prefix
+    const lines = e.message.split("\n");
+    for (const line of lines) {
+      if (line.trim()) {
+        this._write(`${ts()} [MSG  ] [${e.agentName}] ${line}`);
+      }
+    }
+  }
+
+  private _done(e: AgentDoneEvent): void {
+    const cost = e.totalCost ? ` | total_cost=$${e.totalCost.toFixed(4)}` : "";
+    this._write(`${ts()} [DONE ] [${e.agentName}] Agent finished${cost}`);
+    // Print final output lines
+    const lines = e.output.split("\n");
+    for (const line of lines) {
+      if (line.trim()) {
+        this._write(`${ts()} [OUT  ] [${e.agentName}] ${line}`);
+      }
+    }
+  }
+
+  logMessages(events: RenderEvent[], count: number = 20): void {
+    const recent = events.slice(-count);
+    this._write(`\n[LOGS ] Last ${recent.length} events:`);
+    this._write("-".repeat(80));
+    for (const event of recent) {
+      this.render(event);
+    }
+    this._write("-".repeat(80));
+  }
+}
+
+export default PlainRenderer;

package/src/chat/renderer/index.ts

@@ -1,5 +1,6 @@
 export * from "./types";
 export { ConsoleRenderer } from "./ConsoleRenderer";
 export { FancyRenderer } from "./FancyRenderer";
+export { PlainRenderer } from "./PlainRenderer";
 export { CompactRenderer } from "./CompactRenderer";
 export { loadRenderer, loadRootModule, loadChatModule } from "./loadRenderer";

package/src/chat/renderer/loadRenderer.ts

@@ -12,6 +12,7 @@ import path from "path";
 import fs from "fs";
 import { AgentRenderer } from "./types";
 import { ConsoleRenderer } from "./ConsoleRenderer";
+import { PlainRenderer } from "./PlainRenderer";
 import { FancyRenderer } from "./FancyRenderer";
 import { CompactRenderer } from "./CompactRenderer";
 
@@ -19,6 +20,7 @@ import { CompactRenderer } from "./CompactRenderer";
 const BUILTIN_RENDERERS: Record<string, () => AgentRenderer> = {
   basic: () => new ConsoleRenderer(),
   fancy: () => new FancyRenderer(),
+  plain: () => new PlainRenderer(),
   compact: () => new CompactRenderer(),
 };
 

package/src/chat.ts

@@ -21,7 +21,7 @@ import { getConfig } from "./config.js";
 import { loadRenderer, loadRootModule, loadChatModule } from "./chat/renderer/loadRenderer.js";
 import { AgentModule } from "./chat/modules/AgentModule.js";
 
-async function main() {
+async function main(initialCommand?: string) {
   try {
     // Load configuration and plugins
     let config;
@@ -108,7 +108,7 @@ async function main() {
     }
 
     // Start the chat loop
-    await chatService.startChatLoop();
+    await chatService.startChatLoop(initialCommand);
   } catch (error) {
     console.error("Error starting chat:", error);
     process.exit(1);

package/src/cli.ts

@@ -1,4 +1,23 @@
 #!/usr/bin/env node --no-node-snapshot
+// Mark this process as running the Knowhow CLI (not just the SDK)
+process.env.KNOWHOW_CLI = "1";
+
+// Determine which warnings to show based on the command being run.
+// Commands that don't need AI models or a config file should not spam warnings.
+// Individual commands can override by setting KNOWHOW_WARN_NEEDS before parsing.
+// Format: comma-separated list of "models" | "config" (or empty string to suppress all).
+const _rawArgs = process.argv.slice(2);
+const _firstArg = _rawArgs.find((a) => !a.startsWith("-"));
+const COMMANDS_NEEDING_MODELS = new Set(["chat", "agent", "ask", "generate", "embed", "replay"]);
+const COMMANDS_NEEDING_CONFIG = new Set([
+  "chat", "agent", "ask", "generate", "embed", "upload", "download",
+  "worker", "workers", "replay", "behaviors", "skills",
+]);
+const _needsModels = _firstArg && COMMANDS_NEEDING_MODELS.has(_firstArg) ? "models" : "";
+const _needsConfig = _firstArg && COMMANDS_NEEDING_CONFIG.has(_firstArg) ? "config" : "";
+const _needs = [_needsModels, _needsConfig].filter(Boolean).join(",");
+process.env.KNOWHOW_WARN_NEEDS = process.env.KNOWHOW_WARN_NEEDS ?? _needs;
+
 import { Command } from "commander";
 import { version } from "../package.json";
 import { logger } from "./logger";
@@ -40,6 +59,8 @@ import { addConvertCommand } from "./commands/convert";
 import { addReplayCommand } from "./commands/replay";
 import { addBehaviorsCommand } from "./commands/behaviors";
 import { addSkillsCommand } from "./commands/skills";
+import { addAgentsCommand } from "./commands/agents";
+import { addHashCommand } from "./commands/hash";
 
 // Handle unhandled promise rejections gracefully — particularly from MCP SDK
 // which fires errors via event emitters that can bypass Promise.allSettled.
@@ -106,6 +127,8 @@ async function main() {
   addReplayCommand(program);
   addBehaviorsCommand(program);
   addSkillsCommand(program);
+  addAgentsCommand(program);
+  addHashCommand(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.