@covibes/zeroshot 1.4.0 → 1.5.0

package/src/status-footer.js

@@ -96,6 +96,11 @@ class StatusFooter {
     this.minRows = 8; // Minimum rows for footer display (graceful degradation)
     this.hidden = false; // True when terminal too small for footer
 
+    // Output queue - serializes all stdout to prevent cursor corruption
+    // When scroll region is active, console.log() can corrupt cursor position
+    // All output must go through print() to coordinate with render cycles
+    this.printQueue = [];
+
     // Debounced resize handler (100ms) - prevents rapid-fire redraws
     this._debouncedResize = debounce(() => this._handleResize(), 100);
   }
@@ -108,6 +113,38 @@ class StatusFooter {
     return process.stdout.isTTY === true;
   }
 
+  /**
+   * Print text to stdout, coordinating with the render cycle.
+   * When a render is in progress, queues output to prevent cursor corruption.
+   * When no render is active, writes immediately.
+   *
+   * MUST be used instead of console.log() when status footer is active.
+   * @param {string} text - Text to print (newline will be added)
+   */
+  print(text) {
+    if (this.isRendering) {
+      // Queue for later - render() will flush after restoring cursor
+      this.printQueue.push(text);
+    } else {
+      // Write immediately - no render in progress
+      process.stdout.write(text + '\n');
+    }
+  }
+
+  /**
+   * Flush queued output to stdout.
+   * Called after render() restores cursor to ensure proper positioning.
+   * @private
+   */
+  _flushPrintQueue() {
+    if (this.printQueue.length === 0) return;
+
+    // Write all queued output
+    const output = this.printQueue.map(text => text + '\n').join('');
+    this.printQueue = [];
+    process.stdout.write(output);
+  }
+
   /**
    * Get terminal dimensions
    * @returns {{ rows: number, cols: number }}
@@ -495,6 +532,19 @@ class StatusFooter {
     } finally {
       this.isRendering = false;
 
+      // CRITICAL: Position cursor at bottom of scroll region before flushing
+      // Without this, output goes below footer if cursor was restored outside scroll region
+      // (RESTORE_CURSOR at line 527 may restore to row outside the scrollable area)
+      if (this.scrollRegionSet) {
+        const { rows } = this.getTerminalSize();
+        const scrollEnd = rows - this.footerHeight;
+        process.stdout.write(this._moveToStr(scrollEnd, 1));
+      }
+
+      // Flush any output that was queued during render
+      // Must happen BEFORE pending resize to preserve output order
+      this._flushPrintQueue();
+
       // Process pending resize if one was queued during render
       if (this.pendingResize) {
         this.pendingResize = false;
@@ -728,13 +778,15 @@ class StatusFooter {
       // Prevents interleaving with agent output during cleanup
       let buffer = '';
 
-      // Reset scroll region
+      // CRITICAL: Clear footer area BEFORE resetting scroll region
+      // While scroll region is active, footer area contains only status bar content
+      // After reset, those lines may contain scrolled output (which we DON'T want to clear)
+      buffer += this._clearFooterAreaStr();
+
+      // Now reset scroll region (full terminal is scrollable again)
       buffer += this._resetScrollRegionStr();
       this.scrollRegionSet = false;
 
-      // Clear all footer lines
-      buffer += this._clearFooterAreaStr();
-
       // Move cursor to safe position and show cursor
       const { rows } = this.getTerminalSize();
       const startRow = rows - this.footerHeight + 1;
@@ -753,9 +805,10 @@ class StatusFooter {
     if (!this.isTTY()) return;
 
     // Single atomic write for hide operation
-    let buffer = this._resetScrollRegionStr();
+    // CRITICAL: Clear footer BEFORE resetting scroll region (same reason as stop())
+    let buffer = this._clearFooterAreaStr();
+    buffer += this._resetScrollRegionStr();
     this.scrollRegionSet = false;
-    buffer += this._clearFooterAreaStr();
     process.stdout.write(buffer);
   }
 

package/src/template-resolver.js

@@ -43,8 +43,11 @@ class TemplateResolver {
     // Validate required params
     this._validateParams(template, params);
 
+    // Apply defaults for missing params (e.g., timeout: 0)
+    const paramsWithDefaults = this._applyDefaults(template, params);
+
     // Deep clone and resolve
-    const resolved = this._resolveObject(JSON.parse(JSON.stringify(template)), params);
+    const resolved = this._resolveObject(JSON.parse(JSON.stringify(template)), paramsWithDefaults);
 
     // Filter out conditional agents that don't meet their condition
     if (resolved.agents) {
@@ -86,6 +89,25 @@ class TemplateResolver {
     }
   }
 
+  /**
+   * Apply template defaults for any missing params
+   * @private
+   * @param {any} template
+   * @param {any} params
+   * @returns {any} params with defaults applied
+   */
+  _applyDefaults(template, params) {
+    if (!template.params) return params;
+
+    const result = { ...params };
+    for (const [name, schema] of Object.entries(template.params)) {
+      if (result[name] === undefined && schema.default !== undefined) {
+        result[name] = schema.default;
+      }
+    }
+    return result;
+  }
+
   /**
    * Recursively resolve placeholders in an object
    * @private