@tyvm/knowhow 0.0.132 → 0.0.135

package/package.json

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

package/src/agents/base/base.ts

@@ -75,6 +75,13 @@ export abstract class BaseAgent implements IAgent {
 
   // Interrupt support: resolves the currently awaited tool call or completion
   private _interruptResolve: (() => void) | null = null;
+  // A monotonically-increasing token identifying the active interruptible window.
+  // Used to ensure a stale (slow) operation completing in the background cannot
+  // clobber a newer interruptible window's resolver.
+  private _interruptToken = 0;
+  // Set when interrupt() is called with no active window, so the next
+  // makeInterruptible fires immediately instead of dropping the interrupt.
+  private _pendingInterrupt = false;
 
   protected threads = [] as Message[][];
 
@@ -217,6 +224,11 @@ export abstract class BaseAgent implements IAgent {
     this.startTimeMs = Date.now();
     this.currentTaskId = taskId || this.startTimeMs.toString();
 
+    // Reset interrupt state so a queued/stale interrupt from a prior task
+    // can't fire against the new task.
+    this._interruptResolve = null;
+    this._pendingInterrupt = false;
+
     // Emit event for plugin integration
     const id = taskId || this.startTimeMs.toString();
     this.events.emit(this.eventTypes.agentNewTask, {
@@ -740,32 +752,43 @@ export abstract class BaseAgent implements IAgent {
     interruptValue: T
   ): Promise<T> {
     return new Promise<T>((resolve, reject) => {
-      let interrupted = false;
-
-      this._interruptResolve = () => {
-        interrupted = true;
-        this._interruptResolve = null;
-        resolve(interruptValue);
+      // Each interruptible window gets a unique token. `settled` guards this
+      // specific window so it can only ever resolve/reject once, and the token
+      // ensures a stale (slow) background operation that finishes AFTER this
+      // window was interrupted cannot clobber a NEWER window's resolver.
+      const myToken = ++this._interruptToken;
+      let settled = false;
+
+      const finish = (fn: () => void) => {
+        if (settled) return;
+        settled = true;
+        // Only clear the shared resolver if it still belongs to this window.
+        if (this._interruptToken === myToken) {
+          this._interruptResolve = null;
+        }
+        fn();
       };
 
+      this._interruptResolve = () => finish(() => resolve(interruptValue));
+
+      // If an interrupt arrived while there was no active window, honor it now.
+      if (this._pendingInterrupt) {
+        this._pendingInterrupt = false;
+        finish(() => resolve(interruptValue));
+        return;
+      }
+
       promise
         .then((result) => {
-          if (this._interruptResolve) {
-            this._interruptResolve = null;
-            resolve(result);
-          }
+          // If this window was already interrupted/settled, drop the stale
+          // result — do NOT touch _interruptResolve (it may belong to a newer
+          // window now).
+          finish(() => resolve(result));
         })
         .catch((err) => {
-          if (this._interruptResolve) {
-            this._interruptResolve = null;
-          }
-          // Only swallow the error if interrupt() was explicitly called.
-          // Otherwise re-throw so callers see the real error.
-          if (interrupted) {
-            resolve(interruptValue);
-          } else {
-            reject(err);
-          }
+          // If the window was already interrupted, swallow the late error.
+          if (settled) return;
+          finish(() => reject(err));
         });
     });
   }
@@ -777,10 +800,29 @@ export abstract class BaseAgent implements IAgent {
    */
   interrupt(message = "User interrupted this action you were waiting on") {
     this.log(`Interrupting current operation: ${message}`);
+
+    // If the user supplied a real message with the poke (not the default
+    // interrupt reason), queue it as a pending user message so the agent
+    // actually sees what they said on its next step.
+    if (
+      message &&
+      message !== "User interrupted this action you were waiting on"
+    ) {
+      this.addPendingUserMessage({ role: "user", content: message });
+    }
+
     if (this._interruptResolve) {
       this._interruptResolve();
     } else {
-      this.log("No active interruptible operation to interrupt", "warn");
+      // No active interruptible window right now (we're between the AI
+      // completion and the tool call, or in message processing). Queue the
+      // interrupt so the next makeInterruptible window fires immediately
+      // instead of silently dropping it.
+      this._pendingInterrupt = true;
+      this.log(
+        "No active interruptible operation — queued interrupt for next step",
+        "warn"
+      );
     }
   }
 

package/src/cli.ts

@@ -61,6 +61,7 @@ import { addBehaviorsCommand } from "./commands/behaviors";
 import { addSkillsCommand } from "./commands/skills";
 import { addAgentsCommand } from "./commands/agents";
 import { addHashCommand } from "./commands/hash";
+import { addSandboxCommand } from "./commands/sandbox";
 
 // Handle unhandled promise rejections gracefully — particularly from MCP SDK
 // which fires errors via event emitters that can bypass Promise.allSettled.
@@ -129,6 +130,7 @@ async function main() {
   addSkillsCommand(program);
   addAgentsCommand(program);
   addHashCommand(program);
+  addSandboxCommand(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/commands/hash.ts

@@ -43,7 +43,10 @@ export function addHashCommand(program: Command): void {
     )
     .option(
       "--save",
-      "Save the current hash after a successful build step."
+      "Save the current hash. In standalone mode, records the hash immediately (no command run). " +
+        "In --run mode, records the hash only if the command succeeds. " +
+        "Without --save in --run mode, the hash is never recorded — useful when --run is a " +
+        "side-effect trigger rather than the step that produces the tracked artifacts."
     )
     .option(
       "--run <command>",
@@ -143,12 +146,17 @@ export function addHashCommand(program: Command): void {
             process.exit(typeof err?.status === "number" ? err.status : 1);
           }
 
-          // Command succeeded — record the hash of the inputs that produced it.
-          if (!hashes[opts.name]) hashes[opts.name] = {};
-          hashes[opts.name][opts.input] = currentHash;
-          await saveHashes(hashes);
-          if (opts.verbose) {
-            console.error(`[knowhow hash] saved hash ${currentHash} for "${opts.name}"`);
+          // Command succeeded — only save the hash if --save was also passed.
+          // Without --save, the hash is NOT recorded so the command will re-run next time.
+          // Use --save when --run produces the artifacts that the hash tracks.
+          // Omit --save when --run is a side-effect trigger (e.g. snapshot regeneration).
+          if (opts.save) {
+            if (!hashes[opts.name]) hashes[opts.name] = {};
+            hashes[opts.name][opts.input] = currentHash;
+            await saveHashes(hashes);
+            if (opts.verbose) {
+              console.error(`[knowhow hash] saved hash ${currentHash} for "${opts.name}"`);
+            }
           }
           process.exit(0);
         }