@tyvm/knowhow 0.0.107 → 0.0.108-dev.879609c

package/README.md

@@ -362,3 +362,48 @@ For command usage and behavior details, see:
 - Website: https://knowhow.tyvm.ai
 - Twitter/X: https://x.com/micahriggan
 - npm: https://www.npmjs.com/package/@tyvm/knowhow
+
+---
+
+## 🚧 Dev & Nightly Releases
+
+Knowhow publishes unstable/preview builds under separate npm dist-tags so that regular users on `latest` are never affected.
+
+### Installing a pre-release build
+
+```bash
+# Latest nightly (date-stamped)
+npm install -g @tyvm/knowhow@nightly
+
+# Latest dev snapshot (git-hash-stamped)
+npm install -g @tyvm/knowhow@dev
+
+# Pin a specific pre-release version
+npm install -g @tyvm/knowhow@0.0.108-nightly.20250428
+```
+
+### How dist-tags work
+
+| Tag | Installed by default? | Audience |
+|-----|-----------------------|---------|
+| `latest` | ✅ Yes (`npm install @tyvm/knowhow`) | All stable users |
+| `nightly` | ❌ No (must opt-in) | Testers / early adopters |
+| `dev` | ❌ No (must opt-in) | Developers / contributors |
+
+Publishing a `nightly` or `dev` release **never moves the `latest` tag**, so existing users won't receive unstable code through normal updates.
+
+### Publishing scripts (for maintainers)
+
+```bash
+# Publish a date-stamped nightly (e.g. 0.0.108-nightly.20250428)
+npm run publish:nightly
+
+# Publish a git-hash-stamped dev snapshot (e.g. 0.0.108-dev.abc1234)
+npm run publish:dev
+
+# Publish a stable release to `latest`
+npm version patch   # or minor / major
+npm run publish:stable
+```
+
+> **Note:** `publish:nightly` and `publish:dev` automatically version-bump the `package.json` with a pre-release suffix before publishing and do **not** create a git tag, keeping your git history clean.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.107",
+  "version": "0.0.108-dev.879609c",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {
@@ -21,7 +21,13 @@
     "lint": "tslint ./src/**/*.ts",
     "lint:deps": "depcheck --config=.depcheckrc",
     "lint:all": "npm run lint && npm run lint:deps",
-    "check:model-pricing": "ts-node scripts/check-model-pricing.ts"
+    "check:model-pricing": "ts-node scripts/check-model-pricing.ts",
+    "version:nightly": "bash scripts/publish.sh version:nightly",
+    "version:dev": "bash scripts/publish.sh version:dev",
+    "publish:nightly": "bash scripts/publish.sh nightly",
+    "publish:dev": "bash scripts/publish.sh dev",
+    "publish:latest": "bash scripts/publish.sh stable",
+    "publish:stable": "bash scripts/publish.sh stable"
   },
   "keywords": [],
   "author": "Micah Riggan",

package/scripts/publish.sh

@@ -0,0 +1,86 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+COMMAND="${1:-}"
+
+get_current_version() {
+  node -e "process.stdout.write(require('./package.json').version)"
+}
+
+version_nightly() {
+  local version
+  version=$(get_current_version)
+  # Strip any existing pre-release suffix (e.g. -dev.xxx or -nightly.xxx)
+  version=$(echo "$version" | sed 's/-.*$//')
+  local stamp
+  stamp=$(date -u +%Y%m%d)
+  local pre="${version}-nightly.${stamp}"
+  local current
+  current=$(get_current_version)
+  if [ "$current" = "$pre" ]; then
+    echo "Version already set to: $pre (no change needed)"
+  else
+    echo "Bumping version to: $pre"
+    npm version "$pre" --no-git-tag-version
+  fi
+}
+
+version_dev() {
+  local version
+  version=$(get_current_version)
+  # Strip any existing pre-release suffix (e.g. -dev.xxx or -nightly.xxx)
+  version=$(echo "$version" | sed 's/-.*$//')
+  local hash
+  hash=$(git rev-parse --short HEAD)
+  local pre="${version}-dev.${hash}"
+  local current
+  current=$(get_current_version)
+  if [ "$current" = "$pre" ]; then
+    echo "Version already set to: $pre (no change needed)"
+  else
+    echo "Bumping version to: $pre"
+    npm version "$pre" --no-git-tag-version
+  fi
+}
+
+case "$COMMAND" in
+  nightly)
+    echo "🌙 Publishing nightly release..."
+    npm run compile
+    bash scripts/check-isolated-deps.sh
+    version_nightly
+    npm publish --tag nightly
+    echo "✅ Nightly published!"
+    ;;
+  dev)
+    echo "🔧 Publishing dev release..."
+    npm run compile
+    bash scripts/check-isolated-deps.sh
+    version_dev
+    npm publish --tag dev
+    echo "✅ Dev release published!"
+    ;;
+  stable|latest)
+    echo "🚀 Publishing stable release..."
+    npm run compile
+    bash scripts/check-isolated-deps.sh
+    npm publish --tag latest
+    echo "✅ Stable release published!"
+    ;;
+  version:nightly)
+    version_nightly
+    ;;
+  version:dev)
+    version_dev
+    ;;
+  *)
+    echo "Usage: $0 <nightly|dev|stable|version:nightly|version:dev>"
+    echo ""
+    echo "  nightly        - Compile, check deps, bump version with nightly stamp, publish to 'nightly' tag"
+    echo "  dev            - Compile, check deps, bump version with git hash, publish to 'dev' tag"
+    echo "  stable         - Compile, check deps, publish to 'latest' tag"
+    echo "  version:nightly - Only bump version with nightly stamp (no publish)"
+    echo "  version:dev     - Only bump version with git hash (no publish)"
+    exit 1
+    ;;
+esac

package/src/agents/base/base.ts

@@ -317,6 +317,15 @@ export abstract class BaseAgent implements IAgent {
       if (trimmed.startsWith("✅") || /^[\d\.\-\*]/.test(trimmed)) return true;
     }
 
+    // Detect JSON-wrapped finalAnswer output, e.g. {"answer":"..."} or {"finalAnswer":"..."}
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object") {
+        if (typeof parsed.answer === "string") return true;
+        if (typeof parsed.finalAnswer === "string") return true;
+      }
+    } catch (_) {}
+
     return false;
   }
 
@@ -713,6 +722,7 @@ export abstract class BaseAgent implements IAgent {
         messages,
         tools: this.getEnabledTools(),
         tool_choice: "auto",
+        long_ttl_cache: this.runTime() > 300_000,
       });
 
       // If the agent was paused while the completion was in-flight, wait here

package/src/agents/tools/execCommand.ts

@@ -3,6 +3,7 @@ import { promisify } from "util";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import { services, ToolsService } from "../../services";
 
 export const execAsync = promisify(exec);
 
@@ -256,16 +257,32 @@ const execWithTimeout = async (
 };
 
 // Public tool
-export const execCommand = async (
+export async function execCommand(
   command: string,
   timeout?: number,
   continueInBackground?: boolean,
   logFileName?: string
-): Promise<string> => {
-  if(!command || typeof command !== "string") {
+): Promise<string> {
+  if (!command || typeof command !== "string") {
     throw new Error("Invalid command. We received a non-string value. Please ensure you are sending strings of 4k tokens or less.");
   }
 
+  // Get context from bound ToolsService (same pattern as writeFile)
+  const toolService = (
+    this instanceof ToolsService ? this : services().Tools
+  ) as ToolsService;
+  const context = toolService.getContext();
+
+  // Emit pre-run blocking event — handlers can throw to block the command
+  if (context.Events) {
+    await context.Events.emitBlocking("exec:pre-run", {
+      command,
+      timeout,
+      continueInBackground,
+      logFileName,
+    });
+  }
+
   const { stdout, stderr, timedOut, killed, pid, logPath } =
     await execWithTimeout(command, {
       timeout,
@@ -298,6 +315,32 @@ export const execCommand = async (
    *    : "";
    */
 
-  // return `$ ${command}${statusMsg}\n${trimmed}${trimmedMsg}`;
-  return `$ ${command}${statusMsg}\n${output}`;
-};
+  const result = `$ ${command}${statusMsg}\n${output}`;
+
+  // Emit post-run blocking event — handlers can append extra context
+  let eventResults: any[] = [];
+  if (context.Events) {
+    eventResults = await context.Events.emitBlocking("exec:post-run", {
+      command,
+      timeout,
+      continueInBackground,
+      logFileName,
+      stdout,
+      stderr,
+      timedOut,
+      killed,
+      pid,
+      logPath,
+      output,
+    });
+  }
+
+  // Append any additional context returned by post-run handlers
+  let eventResultsText = "";
+  if (eventResults && eventResults.length > 0) {
+    eventResultsText =
+      "\n\nAdditional Information:\n" + JSON.stringify(eventResults, null, 2);
+  }
+
+  return result + eventResultsText;
+};

package/src/chat/CliChatService.ts

@@ -265,7 +265,13 @@ export class CliChatService implements ChatService {
     if (this.context.voiceMode) {
       value = await voiceToText();
     } else if (this.context.multilineMode) {
-      value = await editor({ message: prompt });
+      const renderer = this.context.renderer;
+      if (renderer) renderer.pause();
+      try {
+        value = await editor({ message: prompt });
+      } finally {
+        if (renderer) renderer.resume();
+      }
       this.context.multilineMode = false; // Disable after use like original
     } else {
       // Use saved input history for scrollback (InputQueueManager handles reverse access)

package/src/chat/modules/AgentModule.ts

@@ -30,11 +30,7 @@ import {
   Base64ImageProcessor,
 } from "../../processors/index";
 import { TaskInfo } from "../types";
-import {
-  createAgent,
-  agentConstructors,
-  AgentName,
-} from "../../agents";
+import { createAgent, agentConstructors, AgentName } from "../../agents";
 import { ToolCallEvent } from "../../agents/base/base";
 import { KnowhowSimpleClient } from "../../services/KnowhowClient";
 
@@ -80,7 +76,6 @@ export class AgentModule extends BaseChatModule {
     this.remoteSyncModule = module;
   }
 
-
   getCommands(): ChatCommand[] {
     return [
       {
@@ -260,7 +255,10 @@ export class AgentModule extends BaseChatModule {
         if (context) {
           // Create a temporary agent instance to read its default model/provider
           const agentContext = services().Agents.getAgentContext();
-          const tempAgent = createAgent(agentName as AgentName, agentContext) as BaseAgent;
+          const tempAgent = createAgent(
+            agentName as AgentName,
+            agentContext
+          ) as BaseAgent;
           context.selectedAgent = tempAgent;
           context.agentMode = true;
           context.currentAgent = agentName;
@@ -455,7 +453,6 @@ export class AgentModule extends BaseChatModule {
       const agentNames = Object.keys(agentConstructors);
 
       if (agentNames.length > 0) {
-
         console.log("\nAvailable agents:");
         agentNames.forEach((name) => {
           console.log(`  - ${name}`);
@@ -503,39 +500,52 @@ export class AgentModule extends BaseChatModule {
         console.error(`Session ${sessionId} not found.`);
         return;
       }
-      const lastThread = session.threads[session.threads.length - 1];
       console.log(`\n🔄 Resuming session: ${sessionId}`);
       console.log(`Agent: ${session.agentName}`);
       console.log(`Original task: ${session.initialInput}`);
       console.log(`Status: ${session.status}`);
 
-      const reason = resumeReason
-        ? `Reason for resuming:  ${resumeReason}`
-        : "";
-
-      // Create resume prompt
-      const resumePrompt = `You are resuming a previously started task. Here's the context:
-ORIGINAL REQUEST:
-      ${session.initialInput}
-
-LAST Progress State:
-      ${JSON.stringify(lastThread)}
-
-Please continue from where you left off and complete the original request.
-        ${reason}
-
-`;
+      // Build resume prompt (same pattern as resumeFromMessages)
+      const resumePrompt = [
+        "You are resuming a previously started task.",
+        session.initialInput ? `ORIGINAL REQUEST: ${session.initialInput}` : "",
+        "Please continue from where you left off and complete the original request.",
+        resumeReason ? `Reason for resuming: ${resumeReason}` : "",
+      ]
+        .filter(Boolean)
+        .join("\n");
+
+      // Restore the full message history from the last thread
+      const threads = session.threads || [];
+      const lastThread = threads.length > 0 ? threads[threads.length - 1] : [];
+      const resumeMessages = [...lastThread];
+
+      // Append the resume prompt to the last user message (or add a new one)
+      const reversedIndex = [...lastThread]
+        .reverse()
+        .findIndex((e) => e.role === "user" && typeof e.content === "string");
+
+      if (reversedIndex === -1) {
+        resumeMessages.push({ role: "user", content: resumePrompt });
+      } else {
+        const actualIndex = lastThread.length - 1 - reversedIndex;
+        resumeMessages[actualIndex] = {
+          ...resumeMessages[actualIndex],
+          content: resumeMessages[actualIndex].content + `\n\n<Workflow>[RESUME CONTEXT]: ${resumePrompt}</Workflow>`,
+        };
+      }
 
       console.log("🚀 Session resuming...");
       const context = this.chatService?.getContext();
       const agentName = session.agentName || context.currentAgent;
+      const previousAgentMode = context?.agentMode;
 
       if (!agentName || !agentConstructors[agentName as AgentName]) {
         console.error(`Agent ${agentName} not found.`);
         return;
       }
 
-      // Start agent with Knowhow task context if available
+      // Start agent with Knowhow task context and restored message history
       const { agent, taskId } = await this.setupAgent({
         agentName,
         input: resumePrompt,
@@ -544,7 +554,20 @@ Please continue from where you left off and complete the original request.
         chatHistory: [],
         run: false, // Don't run yet, we need to set up event listeners first
       });
-      await this.attachedAgentChatLoop(taskId, agent, resumePrompt);
+
+      // After resume finishes, revert to normal chat (non-agent mode) so the
+      // user can start a fresh conversation instead of staying locked in agent mode.
+      agent.agentEvents.once(agent.eventTypes.done, () => {
+        const ctx = this.chatService?.getContext();
+        if (ctx && !previousAgentMode) {
+          ctx.agentMode = false;
+          ctx.selectedAgent = undefined;
+          ctx.currentAgent = undefined;
+          this.chatService?.disableMode("agent");
+        }
+      });
+
+      await this.attachedAgentChatLoop(taskId, agent, resumePrompt, resumeMessages);
     } catch (error) {
       console.error(
         `Failed to resume session ${sessionId}:`,
@@ -1033,7 +1056,8 @@ Please continue from where you left off and complete the original request.
   async attachedAgentChatLoop(
     taskId: string,
     agent: AttachableAgent,
-    initialInput?: string
+    initialInput?: string,
+    initialMessages?: any[]
   ): Promise<void> {
     try {
       let agentFinalOutput: string | undefined;
@@ -1075,7 +1099,7 @@ Please continue from where you left off and complete the original request.
 
           if (context.chatHistory) {
             const found = context.chatHistory.find((h) => h.taskId === taskId);
-            found.output = agentFinalOutput;
+            if (found) found.output = agentFinalOutput;
           }
 
           resolve("done");
@@ -1088,7 +1112,8 @@ Please continue from where you left off and complete the original request.
       if (initialInput) {
         const taskInfo = this.taskRegistry.get(taskId);
         (agent as BaseAgent).call(
-          taskInfo?.formattedPrompt || taskInfo?.initialInput || initialInput
+          taskInfo?.formattedPrompt || taskInfo?.initialInput || initialInput,
+          initialMessages
         );
       }
     } catch (error) {

package/src/chat/modules/SessionsModule.ts

@@ -304,15 +304,20 @@ export class SessionsModule extends BaseChatModule {
   async handleResumeCommand(args: string[]): Promise<void> {
     const sessionManager = this.agentModule.getSessionManager();
 
-    if (args.length === 0) {
+    if (args.length === 0 || args[0] === "--all") {
       // Interactive: show saved sessions for selection
-      const savedSessions = sessionManager.listAvailableSessions();
+      const showAll = args[0] === "--all";
+      const allSessions = sessionManager.listAvailableSessions();
+      const savedSessions = showAll ? allSessions : allSessions.slice(0, 10);
       if (savedSessions.length === 0) {
         console.log("No saved sessions found to resume.");
         return;
       }
 
       this.printSavedSessionsTable(savedSessions);
+      if (!showAll && allSessions.length > 10) {
+        console.log(`   ... and ${allSessions.length - 10} more. Use /resume --all to see all sessions.`);
+      }
 
       const allIds = savedSessions.map((s) => s.sessionId);
       const selectedId = await this.selectByNumber(

package/src/chat/renderer/CompactRenderer.ts

@@ -72,6 +72,8 @@ function colorFor(n: string) {
 export class CompactRenderer implements AgentRenderer {
   private activeTaskId: string | undefined;
   private emitter = new EventEmitter();
+  private paused = false;
+  private bufferedEvents: RenderEvent[] = [];
 
   setActiveTaskId(id: string | undefined): void {
     this.activeTaskId = id;
@@ -110,8 +112,26 @@ export class CompactRenderer implements AgentRenderer {
     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":

package/src/chat/renderer/ConsoleRenderer.ts

@@ -17,6 +17,8 @@ import { EventEmitter } from "events";
 export class ConsoleRenderer implements AgentRenderer {
   private activeTaskId: string | undefined;
   private emitter = new EventEmitter();
+  private paused = false;
+  private bufferedEvents: RenderEvent[] = [];
 
   setActiveTaskId(taskId: string | undefined): void {
     this.activeTaskId = taskId;
@@ -56,9 +58,26 @@ export class ConsoleRenderer implements AgentRenderer {
     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;
+    }
+
     switch (event.type) {
       case "log":
         this.emitter.emit("log", event);

package/src/chat/renderer/FancyRenderer.ts

@@ -194,6 +194,8 @@ const toolTimers = new Map<string, number>();
 export class FancyRenderer implements AgentRenderer {
   private activeTaskId: string | undefined;
   private emitter = new EventEmitter();
+  private paused = false;
+  private bufferedEvents: RenderEvent[] = [];
 
   setActiveTaskId(taskId: string | undefined): void {
     this.activeTaskId = taskId;
@@ -227,9 +229,26 @@ export class FancyRenderer implements AgentRenderer {
     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;
+    }
+
     switch (event.type) {
       case "log":
         this.emitter.emit("log", event);

package/src/chat/renderer/types.ts

@@ -80,6 +80,17 @@ export interface AgentRenderer {
   setActiveTaskId(taskId: string | undefined): void;
   getActiveTaskId(): string | undefined;
 
+  /**
+   * Pause rendering - buffer any incoming events instead of printing them.
+   * Useful when an interactive UI (e.g. editor for /multi) takes over the terminal.
+   */
+  pause(): void;
+
+  /**
+   * Resume rendering - flush any buffered events and resume normal output.
+   */
+  resume(): void;
+
   /**
    * Replay the last N render events (used by /logs command).
    * If count is not provided, shows last 10.

package/src/cli.ts

@@ -530,12 +530,17 @@ async function main() {
     .description("Create or sync a cloud worker with your local knowhow config")
     .option("--create", "Create a new cloud worker with synced config and files")
     .option("--push <uid>", "Push/sync local config and files to an existing cloud worker")
+    .option("--pull <id>", "Pull the latest workerConfigJson from a cloud worker and update local config")
     .option("--name <name>", "Name for the cloud worker (used with --create)")
     .option("--dry-run", "Print what would be synced without doing it")
     .action(async (options) => {
       try {
-        const { cloudWorker } = await import("./cloudWorker");
-        await cloudWorker(options);
+        const { cloudWorker, pullCloudWorkerConfig } = await import("./cloudWorker");
+        if (options.pull) {
+          await pullCloudWorkerConfig({ id: options.pull });
+        } else {
+          await cloudWorker(options);
+        }
       } catch (error) {
         console.error("Error running cloudworker:", error);
         process.exit(1);