@tyvm/knowhow 0.0.146 → 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:
@@ -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/types.ts

@@ -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

@@ -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/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/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) {