@pageai/ralph-loop 1.18.0 → 1.21.0

package/.agent/PROMPT.md

@@ -1,3 +1,5 @@
+> ⛔ **ONE TASK PER INVOCATION** — Complete one task from @.agent/tasks.json, commit, output `<promise>TASK-{ID}:DONE</promise>`, and STOP. Do NOT start the next task. Do NOT use parallel agents for multiple tasks.
+
 ## Overview
 
 You are implementing the project described in @.agent/prd/SUMMARY.md
@@ -28,7 +30,7 @@ Tasks are listed in @.agent/tasks.json
 7. Run `tsc` and unit tests project-wide
 8. All tests must pass. Broke unrelated test? Fix it before proceeding.
 9. When tests pass, set `passes: true` in `tasks.json` for the task you completed.
-10. Log entry → `.agent/logs/LOG.md` (date, brief summary, screenshot path)
+10. Log entry → `.agent/logs/LOG.md` (date, brief summary, screenshot path, newest at the top)
 11. Update `.agent/STRUCTURE.md` if dirs changed. Exclude dotfiles, tests and config.
 12. Commit changes, using the Conventional Commit format.
 
@@ -51,6 +53,15 @@ When stuck after all possible solutions exhausted, output one of the following t
 <promise>BLOCKED:brief description</promise>
 ```
 
+**Exit immediately (no workarounds) for environment constraints you cannot fix from inside the sandbox:**
+
+- `Blocked by network policy` → firewall, only user can change from host
+- Missing/invalid credentials or API keys
+- Required system service unavailable
+- Hardware/arch incompatibility with no known fix
+
+These are not bugs. No amount of retries, alternative downloads, or package managers will help. Output BLOCKED on first failure.
+
 2. **DECIDE** — need human input: lib choices, architecture, unclear requirements, breaking changes. Output:
 
 ```

package/.claude/hooks/one-task-guard.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+/**
+ * PostToolUse hook that enforces the one-task-per-invocation rule.
+ *
+ * Reads .agent/tasks.json, counts tasks with passes: true,
+ * and warns if more than one task was completed since the session started.
+ * The baseline is stored in .agent/.task-count (ephemeral per session).
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Find project root by looking for .agent directory
+function findProjectRoot() {
+  let dir = __dirname;
+  // Walk up from .claude/hooks
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, '.agent', 'tasks.json'))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+// Read tool input from stdin to check if this was a git commit
+function readStdin() {
+  try {
+    return fs.readFileSync('/dev/stdin', 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+try {
+  const input = readStdin();
+
+  // Only check after git commit commands
+  let parsed = {};
+  try {
+    parsed = JSON.parse(input);
+  } catch {
+    // Not JSON input, skip
+    process.exit(0);
+  }
+
+  const toolInput = parsed.tool_input || {};
+  const command = toolInput.command || '';
+
+  // Only trigger on git commit commands
+  if (!command.includes('git commit')) {
+    process.exit(0);
+  }
+
+  const root = findProjectRoot();
+  if (!root) {
+    process.exit(0);
+  }
+
+  const agentDir = path.join(root, '.agent');
+  const tasksFile = path.join(agentDir, 'tasks.json');
+  const countFile = path.join(agentDir, '.task-count');
+
+  if (!fs.existsSync(tasksFile)) {
+    process.exit(0);
+  }
+
+  const tasks = JSON.parse(fs.readFileSync(tasksFile, 'utf8'));
+  const passCount = tasks.filter((t) => t.passes === true).length;
+
+  if (!fs.existsSync(countFile)) {
+    // First commit this session — store baseline
+    fs.writeFileSync(countFile, String(passCount));
+  } else {
+    const baseline = parseInt(fs.readFileSync(countFile, 'utf8'), 10);
+    const completed = passCount - baseline;
+
+    if (completed > 1) {
+      console.log(
+        `⚠️ VIOLATION: ${completed} tasks completed in this invocation. ` +
+          'PROMPT.md requires ONE task per invocation. ' +
+          'Stop now and output <promise>TASK-{ID}:DONE</promise>.'
+      );
+    }
+  }
+} catch (error) {
+  // Fail silently — don't block work if the guard has a bug
+  if (process.env.DEBUG) {
+    console.error(`one-task-guard error: ${error.message}`);
+  }
+}

package/.claude/hooks/{pre-tool-use.js → post-tool-use.js}

@@ -26,7 +26,7 @@ function findClaudeDir() {
 
 try {
   const claudeDir = findClaudeDir();
-  const awFilePath = path.join(claudeDir, 'commands', 'aw.md');
+  const awFilePath = path.join(claudeDir, 'hooks', 'aw.md');
   
   if (fs.existsSync(awFilePath)) {
     const content = fs.readFileSync(awFilePath, 'utf8');

package/.claude/settings.json

@@ -7,23 +7,22 @@
   "enableAllProjectMcpServers": true,
   "enabledMcpjsonServers": ["playwright", "context7", "sequential-thinking"],
   "hooks": {
-    "UserPromptSubmit": [
+    "PostToolUse": [
       {
+        "matcher": "Edit|Write|Bash",
         "hooks": [
           {
             "type": "command",
-            "command": "node $CLAUDE_PROJECT_DIR/.claude/hooks/pre-tool-use.js"
+            "command": "node $CLAUDE_PROJECT_DIR/.claude/hooks/post-tool-use.js"
           }
         ]
-      }
-    ],
-    "PreToolUse": [
+      },
       {
-        "matcher": "Edit|Write|Bash",
+        "matcher": "Bash",
         "hooks": [
           {
             "type": "command",
-            "command": "node $CLAUDE_PROJECT_DIR/.claude/hooks/pre-tool-use.js"
+            "command": "node $CLAUDE_PROJECT_DIR/.claude/hooks/one-task-guard.js"
           }
         ]
       }

package/AGENTS.md

@@ -25,6 +25,10 @@ Signs a file needs splitting:
 - "Utils" file becoming a junk drawer
 - Component doing data fetching + transformation + rendering
 
+## Task Execution
+
+- **One task per invocation.** When working from `.agent/tasks.json`, complete exactly one task, commit, and stop. Never batch multiple tasks.
+
 ## Code Style
 
 1. Prefer writing clear code and use inline comments sparingly

package/README.md

@@ -1,6 +1,6 @@
 # A Ralph Wiggum Loop implementation that works™
 
-[![@pageai/ralph-loop version](https://img.shields.io/npm/v/@pageai/ralph-loop?label=npm&style=flat)](https://github.com/pageai-pro/ralph-loop)
+[![@pageai/ralph-loop version](https://img.shields.io/npm/v/@pageai/ralph-loop?label=npm&style=flat)](https://www.npmjs.com/package/@pageai/ralph-loop)
 
 Ralph is a long-running AI agent loop. Ralph automates software development tasks by iteratively working through a task list until completion. This allows for long running agent loops, effectively enabling AI to code for days at a time.
 
@@ -34,6 +34,8 @@ This is an implementation that actually works, containing a hackable script so y
   - [Vitest configuration](#vitest-configuration)
   - [Running with a different agentic CLI](#running-with-a-different-agentic-cli)
   - [Starting from scratch](#starting-from-scratch)
+  - [Debugging](#debugging)
+- [How to inspect the sandbox and debug](#how-to-inspect-the-sandbox-and-debug)
 - [License](#license)
 
 ---------------------------------
@@ -266,7 +268,7 @@ To do so, you need to continue using the `prd-creator` skill to update the PRD a
 For example:
 
 ```
-I would like to expand the PRD / tasks with these tasks:
+I would like to expand the PRD. Use the prd-creator skill to create these tasks:
 
 - there is a bug in X that should be fixed by doing Y
 - create a new feature that implement Z
@@ -438,6 +440,38 @@ npm i @vitejs/plugin-react @testing-library/dom @testing-library/jest-dom @testi
 
 It is recommended that you add skills for your specific language and framework. See [skills.sh](https://skills.sh) to discover existing skills.
 
+### Debugging
+
+## How to inspect the sandbox and debug
+
+You might be wondering... if this is not a Docker container, how can you see what's going on inside Docker!?
+How to debug/install things?
+
+That's quite straightforward.
+
+You first need to run:
+
+```bash
+docker sandbox list
+```
+
+Note down the name of the sandbox, e.g. `claude-ralph-loop`.
+
+And then you can run bash into any of the sandboxes like so:
+```bash
+docker sandbox exec -it <sandbox-name> bash # e.g. docker sandbox exec -it claude-ralph-loop bash
+```
+
+And you have full control over the sandbox, just like a regular container. You can install packages, run commands, etc.
+
+You can also also run Claude Code inside the sandbox (make sure to navigate to the project directory first).
+
+```bash
+docker sandbox exec -it <sandbox-name> bash
+cd /path/to/your/project # this is the same path as the path in the root machine, e.g. /Users/your-username/Documents/your-project
+claude
+```
+
 ## License
 
 MIT

package/bin/cli.js

@@ -10,6 +10,7 @@ const fs = require('fs');
 const path = require('path');
 const display = require('./lib/display');
 const { copyFile, copyDir, mergeDir, exists, ensureDir } = require('./lib/copy');
+const { mergeSettings } = require('./lib/settings');
 const { isGitRepo, initGitRepo } = require('./lib/git');
 const { isShadcnProject, installAllComponents } = require('./lib/shadcn');
 const { setupPlaywright } = require('./lib/playwright');
@@ -124,7 +125,7 @@ const DIRS_TO_MERGE = [
 
 // Other files in these directories to copy (with exclusions)
 const EXTRA_DIR_FILES = [
-  { dir: '.claude', exclude: ['settings.local.json', 'skills', 'agents', 'commands', 'hooks'] },
+  { dir: '.claude', exclude: ['settings.local.json', 'settings.json', 'skills', 'agents', 'commands', 'hooks'] },
 ];
 
 async function main() {
@@ -319,6 +320,21 @@ async function main() {
     }
   }
 
+  // Merge .claude/settings.json (preserve user settings, add hooks)
+  console.log();
+  display.printStep('🔧', 'Settings');
+  const settingsResult = mergeSettings(
+    path.join(PACKAGE_ROOT, '.claude/settings.json'),
+    path.join(TARGET_DIR, '.claude/settings.json')
+  );
+  if (settingsResult.created) {
+    display.printSuccess('.claude/settings.json (created)');
+  } else if (settingsResult.merged) {
+    display.printSuccess('.claude/settings.json (merged hooks)');
+  } else if (settingsResult.backedUp) {
+    display.printWarning('.claude/settings.json (backed up malformed, replaced)');
+  }
+
   // Replace dev server URL in copied files if different from default
   if (devServerUrl !== 'http://localhost:3000') {
     const filesToPatch = [

package/bin/lib/settings.js

@@ -0,0 +1,98 @@
+/**
+ * Settings merge module for Ralph Loop CLI
+ * Merges hook configurations into existing .claude/settings.json
+ * without overwriting user preferences
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { ensureDir, exists } = require('./copy');
+
+/**
+ * Merges hook entries by event type, deduplicating by command string.
+ * Source hooks are only added if their commands aren't already present.
+ * @param {Object} existing - Existing hooks object (e.g. { PostToolUse: [...], Notification: [...] })
+ * @param {Object} source - Source hooks to merge in
+ * @returns {Object} Merged hooks
+ */
+function mergeHooks(existing = {}, source = {}) {
+  const result = JSON.parse(JSON.stringify(existing));
+
+  for (const [eventType, sourceEntries] of Object.entries(source)) {
+    if (!Array.isArray(sourceEntries)) continue;
+
+    if (!result[eventType]) {
+      result[eventType] = sourceEntries;
+      continue;
+    }
+
+    const existingCommands = new Set();
+    for (const entry of result[eventType]) {
+      for (const hook of (entry.hooks || [])) {
+        if (hook.command) existingCommands.add(hook.command);
+      }
+    }
+
+    for (const entry of sourceEntries) {
+      const commands = (entry.hooks || []).map(h => h.command).filter(Boolean);
+      const alreadyExists = commands.some(cmd => existingCommands.has(cmd));
+      if (!alreadyExists) {
+        result[eventType].push(entry);
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Merges ralph-loop's settings.json into an existing one.
+ * - If dest doesn't exist: copies source as-is
+ * - If dest has malformed JSON: backs up and replaces
+ * - If dest is valid: merges hooks additively, sets missing non-hooks keys
+ * @param {string} srcPath - Path to ralph-loop's settings.json
+ * @param {string} destPath - Path to target project's settings.json
+ * @returns {{ created: boolean, merged: boolean, backedUp: boolean }}
+ */
+function mergeSettings(srcPath, destPath) {
+  if (!exists(srcPath)) {
+    return { created: false, merged: false, backedUp: false };
+  }
+
+  const sourceSettings = JSON.parse(fs.readFileSync(srcPath, 'utf8'));
+  ensureDir(path.dirname(destPath));
+
+  if (!exists(destPath)) {
+    fs.writeFileSync(destPath, JSON.stringify(sourceSettings, null, 2) + '\n', 'utf8');
+    return { created: true, merged: false, backedUp: false };
+  }
+
+  const raw = fs.readFileSync(destPath, 'utf8');
+  let existingSettings;
+
+  try {
+    existingSettings = JSON.parse(raw);
+  } catch {
+    fs.copyFileSync(destPath, destPath + '.bak');
+    fs.writeFileSync(destPath, JSON.stringify(sourceSettings, null, 2) + '\n', 'utf8');
+    return { created: false, merged: false, backedUp: true };
+  }
+
+  const merged = { ...existingSettings };
+  for (const [key, value] of Object.entries(sourceSettings)) {
+    if (key === 'hooks') continue;
+    if (!(key in merged)) {
+      merged[key] = value;
+    }
+  }
+
+  merged.hooks = mergeHooks(existingSettings.hooks, sourceSettings.hooks);
+
+  fs.writeFileSync(destPath, JSON.stringify(merged, null, 2) + '\n', 'utf8');
+  return { created: false, merged: true, backedUp: false };
+}
+
+module.exports = {
+  mergeHooks,
+  mergeSettings,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pageai/ralph-loop",
-  "version": "1.18.0",
+  "version": "1.21.0",
   "publishConfig": {
     "access": "public"
   },

package/ralph.sh

@@ -98,7 +98,7 @@ $(cat $SCRIPT_DIR/.agent/PROMPT.md)"
   export PROMPT_CONTENT
   export DOCKER_DEFAULT_PLATFORM=linux/amd64 # Needed for Playwright.
 
-  script -q "$OUTPUT_FILE" bash -c 'docker sandbox run claude . -- --model opus --output-format stream-json --verbose -p "$PROMPT_CONTENT"' >/dev/null 2>&1 &
+  script -q "$OUTPUT_FILE" bash -c 'docker sandbox run claude . -- --effort max --model opus --output-format stream-json --verbose -p "$PROMPT_CONTENT"' >/dev/null 2>&1 &
   AGENT_PID=$!
 
   # Track position in output file for incremental reading
@@ -113,7 +113,7 @@ $(cat $SCRIPT_DIR/.agent/PROMPT.md)"
       # Read new content if file has grown
       if [ "$CURRENT_SIZE" -gt "$LAST_POS" ]; then
         # Read new lines
-        tail -c +$((LAST_POS + 1)) "$OUTPUT_FILE" 2>/dev/null | while IFS= read -r line; do
+        while IFS= read -r line; do
           if [ -n "$line" ]; then
             # Parse JSON and extract text content
             parsed=$(parse_json_content "$line")
@@ -126,11 +126,11 @@ $(cat $SCRIPT_DIR/.agent/PROMPT.md)"
               update_preview_line "$parsed"
             fi
           fi
-        done
+        done < <(tail -c +$((LAST_POS + 1)) "$OUTPUT_FILE" 2>/dev/null)
         LAST_POS=$CURRENT_SIZE
       fi
     fi
-    sleep 0.2
+    sleep 0.2 || true
   done
 
   wait "$AGENT_PID" || true
@@ -140,14 +140,14 @@ $(cat $SCRIPT_DIR/.agent/PROMPT.md)"
   if [ -f "$OUTPUT_FILE" ]; then
     CURRENT_SIZE=$(stat -f%z "$OUTPUT_FILE" 2>/dev/null || stat -c%s "$OUTPUT_FILE" 2>/dev/null || echo "0")
     if [ "$CURRENT_SIZE" -gt "$LAST_POS" ]; then
-      tail -c +$((LAST_POS + 1)) "$OUTPUT_FILE" 2>/dev/null | while IFS= read -r line; do
+      while IFS= read -r line; do
         if [ -n "$line" ]; then
           parsed=$(parse_json_content "$line")
           if [ -n "$parsed" ]; then
             echo "$parsed" >> "$FULL_OUTPUT_FILE"
           fi
         fi
-      done
+      done < <(tail -c +$((LAST_POS + 1)) "$OUTPUT_FILE" 2>/dev/null)
     fi
   fi
 
@@ -307,7 +307,7 @@ $(cat $SCRIPT_DIR/.agent/PROMPT.md)"
   if [ -n "$STEP_TIMES_OUTPUT" ]; then
     echo -e "${G}      └──${R} $STEP_TIMES_OUTPUT"
   fi
-  sleep 2
+  sleep 2 || true
 done
 
 # Calculate final elapsed time

package/scripts/lib/cleanup.sh

@@ -16,13 +16,39 @@ cleanup() {
   fi
   SPINNER_PID=""
 
-  # Kill Agent process if still running
+  # Kill Agent process tree if still running
+  # The process tree is: script -> bash -> docker sandbox run
+  # Killing just the script PID leaves the docker sandbox running
   if [ -n "$AGENT_PID" ] && kill -0 "$AGENT_PID" 2>/dev/null; then
+    # Kill child processes first (bash -> docker), then the script process
+    pkill -TERM -P "$AGENT_PID" 2>/dev/null || true
     kill "$AGENT_PID" 2>/dev/null || true
     wait "$AGENT_PID" 2>/dev/null || true
   fi
   AGENT_PID=""
 
+  # Stop all running Docker sandboxes for this workspace
+  # Finds sandboxes by matching the workspace path, regardless of agent prefix
+  if command -v docker &>/dev/null && command -v jq &>/dev/null; then
+    local sandboxes
+    sandboxes=$(docker sandbox ls --json 2>/dev/null \
+      | jq -r --arg ws "$SCRIPT_DIR" '(.vms // .sandboxes // [])[] | select(.status == "running" and (.workspaces[] == $ws)) | .name' 2>/dev/null)
+
+    if [ -n "$sandboxes" ]; then
+      echo -e "  ${Y}📦 Stopping sandbox...${R}"
+      # Stop all matching sandboxes (pass all names at once)
+      docker sandbox stop $sandboxes 2>/dev/null &
+      local stop_pid=$!
+      # Timeout after 5 seconds to avoid hanging on exit
+      ( sleep 5 && kill "$stop_pid" 2>/dev/null ) &>/dev/null &
+      local timeout_pid=$!
+      if wait "$stop_pid" 2>/dev/null; then
+        echo -e "  ${GR}✅ Sandbox stopped${R}"
+      fi
+      kill "$timeout_pid" 2>/dev/null || true
+    fi
+  fi
+
   # Remove temporary files
   [[ -n "$STEP_FILE" ]] && rm -f "$STEP_FILE" 2>/dev/null || true
   [[ -n "$PREVIEW_LINE_FILE" ]] && rm -f "$PREVIEW_LINE_FILE" 2>/dev/null || true

package/scripts/lib/output.sh

@@ -11,16 +11,42 @@ parse_json_content() {
   # For example, Claude stream-json outputs {"type":"content_block_delta","delta":{"text":"..."}}
   # or {"type":"text","text":"..."} etc.
 
-  # Extract text from delta
-  local text=$(echo "$json_line" | grep -o '"text":"[^"]*"' | head -1 | sed 's/"text":"//;s/"$//')
+  # Extract text from delta (use jq if available for proper escaped quote handling)
+  local text=""
+  if command -v jq &>/dev/null; then
+    text=$(echo "$json_line" | jq -r '.delta.text // .text // empty' 2>/dev/null)
+  else
+    text=$(echo "$json_line" | grep -o '"text":"[^"]*"' | head -1 | LC_ALL=C sed 's/"text":"//;s/"$//' 2>/dev/null)
+  fi
   if [ -n "$text" ]; then
-    # Unescape common JSON escapes
-    # JSON \n -> actual newline, \t -> actual tab, etc.
-    text=$(echo "$text" | sed 's/\\n/\'$'\n''/g; s/\\t/\'$'\t''/g; s/\\"/"/g; s/\\\\/\\/g')
+    # Unescape common JSON escapes (only needed for grep fallback, jq handles this)
+    if ! command -v jq &>/dev/null; then
+      text=$(echo "$text" | LC_ALL=C sed 's/\\n/\'$'\n''/g; s/\\t/\'$'\t''/g; s/\\"/"/g; s/\\\\/\\/g' 2>/dev/null)
+    fi
     echo "$text"
     return
   fi
 
+  # Extract tool_use events (have "name" but no "text")
+  # Produces strings like "Read file_path=/src/main.ts" or "Bash command=npm test"
+  # that detect_step() patterns can match
+  local tool_name=$(echo "$json_line" | grep -o '"name":"[^"]*"' | head -1 | LC_ALL=C sed 's/"name":"//;s/"$//' 2>/dev/null)
+  if [ -n "$tool_name" ]; then
+    local file_path=$(echo "$json_line" | grep -o '"file_path":"[^"]*"' | head -1 | LC_ALL=C sed 's/"file_path":"//;s/"$//' 2>/dev/null)
+    local pattern=$(echo "$json_line" | grep -o '"pattern":"[^"]*"' | head -1 | LC_ALL=C sed 's/"pattern":"//;s/"$//' 2>/dev/null)
+    local cmd=$(echo "$json_line" | grep -o '"command":"[^"]*"' | head -1 | LC_ALL=C sed 's/"command":"//;s/"$//' 2>/dev/null)
+    if [ -n "$file_path" ]; then
+      echo "$tool_name file_path=$file_path"
+    elif [ -n "$pattern" ]; then
+      echo "$tool_name pattern=$pattern"
+    elif [ -n "$cmd" ]; then
+      echo "$tool_name command=$cmd"
+    else
+      echo "$tool_name"
+    fi
+    return
+  fi
+
   # If it doesn't look like JSON, return as-is
   if ! echo "$json_line" | grep -q '^{'; then
     echo "$json_line"
@@ -44,7 +70,7 @@ strip_ansi() {
   #             0x1C-0x1F (FS through US) - excludes ESC (0x1B) for sed to process
   # sed handles: ESC sequences, OSC-like patterns, caret notation
   # Note: OSC pattern uses ^ anchor but also handles after caret removal via second pass
-  echo "$input" | sed \
+  echo "$input" | LC_ALL=C sed \
     -e 's/\x1b\[[0-9;?]*[A-Za-z]//g' \
     -e 's/\x1b\][^\x07]*\x07//g' \
     -e 's/\x1b\][^\x1b]*\x1b\\//g' \
@@ -53,9 +79,9 @@ strip_ansi() {
     -e 's/\x1b.//g' \
     -e 's/\^[][A-Z@\\^_]//g' \
     -e 's/^0;[^]]*]//g' \
-    -e 's/<u0;//g' \
-    | tr -d '\000-\010\013\014\016-\032\034-\037' \
-    | sed -e 's/^0;[^]]*]//g'
+    -e 's/<u0;//g' 2>/dev/null \
+    | LC_ALL=C tr -d '\000-\010\013\014\016-\032\034-\037' 2>/dev/null \
+    | LC_ALL=C sed -e 's/^0;[^]]*]//g' 2>/dev/null
 }
 
 # Strip ANSI from a file and write to output file
@@ -68,7 +94,7 @@ strip_ansi_file() {
   # Then tr removes remaining control characters (excluding newline 0x0A, CR 0x0D)
   # tr range excludes ESC (0x1B = octal 033) which sed already handled
   # Final sed pass cleans up OSC patterns that were hidden by control chars
-  sed \
+  LC_ALL=C sed \
     -e 's/\x1b\[[0-9;?]*[A-Za-z]//g' \
     -e 's/\x1b\][^\x07]*\x07//g' \
     -e 's/\x1b\][^\x1b]*\x1b\\//g' \
@@ -78,8 +104,8 @@ strip_ansi_file() {
     -e 's/\^[][A-Z@\\^_]//g' \
     -e 's/^0;[^]]*]//g' \
     -e 's/<u0;//g' \
-    "$input_file" | tr -d '\000-\010\013\014\016-\032\034-\037' \
-    | sed -e 's/^0;[^]]*]//g' \
+    "$input_file" 2>/dev/null | LC_ALL=C tr -d '\000-\010\013\014\016-\032\034-\037' 2>/dev/null \
+    | LC_ALL=C sed -e 's/^0;[^]]*]//g' 2>/dev/null \
     > "$output_file"
 }
 

package/scripts/lib/spinner.sh

@@ -60,7 +60,7 @@ update_spinner_step() {
     echo "$detected" > "$STEP_FILE"
 
     # Clean step name (remove trailing spaces) for timing tracking
-    local clean_step=$(echo "$detected" | sed 's/ *$//')
+    local clean_step=$(echo "$detected" | LC_ALL=C sed 's/ *$//' 2>/dev/null)
 
     # Record timing if step changed
     if [ "$clean_step" != "$CURRENT_STEP_NAME" ]; then
@@ -77,7 +77,7 @@ update_preview_line() {
   [[ "$line" =~ ^[[:space:]]*$ ]] && return
   # Sanitize: replace newlines/tabs with spaces, collapse multiple spaces
   # This prevents multi-line content from breaking cursor positioning
-  line=$(echo "$line" | tr '\n\t\r' ' ' | sed 's/  */ /g; s/^ *//; s/ *$//')
+  line=$(echo "$line" | LC_ALL=C tr '\n\t\r' ' ' 2>/dev/null | LC_ALL=C sed 's/  */ /g; s/^ *//; s/ *$//' 2>/dev/null | head -1)
   # Skip if sanitization resulted in empty string
   [ -z "$line" ] && return
   # Write to preview file (spinner reads this)

package/scripts/lib/timing.sh

@@ -224,6 +224,8 @@ detect_step() {
     echo "Implementing"
   elif echo "$line" | grep -qiE "(compiling|bundling|transpiling)"; then
     echo "Implementing"
+  elif echo "$line" | grep -qiE "Bash.*command=.*(build|compile|bundle)"; then
+    echo "Implementing"
 
   # COMMITTING - git operations
   elif echo "$line" | grep -qiE "(git commit|git add|committing|staged for commit)"; then
@@ -238,6 +240,8 @@ detect_step() {
     echo "Testing"
   elif echo "$line" | grep -qiE "(running|executing) (tests|test suite)"; then
     echo "Testing"
+  elif echo "$line" | grep -qiE "Bash.*command=.*(test|e2e|spec|jest|vitest|playwright|pytest)"; then
+    echo "Testing"
 
   # DEBUGGING - investigating errors, fixing issues
   elif echo "$line" | grep -qiE "(the|this) (error|issue|problem|bug) (is|seems|appears|was)"; then
@@ -254,10 +258,14 @@ detect_step() {
   # LINTING - code style and formatting
   elif echo "$line" | grep -qiE "(eslint|biome|lint|prettier|formatting|stylelint)"; then
     echo "Linting"
+  elif echo "$line" | grep -qiE "Bash.*command=.*(lint|eslint|biome|prettier|stylelint)"; then
+    echo "Linting"
 
   # TYPECHECKING - type validation
   elif echo "$line" | grep -qiE "(npm run typecheck|tsc|typescript|type.?check|mypy|pyright)"; then
     echo "Typechecking"
+  elif echo "$line" | grep -qiE "Bash.*command=.*(typecheck|tsc|mypy|pyright)"; then
+    echo "Typechecking"
 
   # WRITING TESTS - creating test files
   elif echo "$line" | grep -qiE "(\.test\.|\.spec\.|test file|writing test|adding test)"; then
@@ -272,6 +280,8 @@ detect_step() {
     echo "Installing"
   elif echo "$line" | grep -qiE "(installing|adding|updating) (dependency|dependencies|package)"; then
     echo "Installing"
+  elif echo "$line" | grep -qiE "Bash.*command=.*(npm install|yarn add|pnpm add|pip install|brew install)"; then
+    echo "Installing"
 
   # WEB RESEARCH - fetching docs, searching web
   elif echo "$line" | grep -qiE "(WebFetch|WebSearch)"; then