feat: Windows/PowerShell support, enriched system prompt, better error recovery

Shell execution:
- Detect platform at runtime: PowerShell (pwsh/powershell) on Windows,
  $SHELL on Unix, fallback to /bin/sh
- Shell tool description dynamically matches the platform
- Windows-specific dangerous command patterns (format, del /f, rd /s, etc.)
- Windows commands added to read-only permission whitelist
- Windows write patterns added to subagent safety filter

System prompt:
- Inject OS/arch, shell name, git branch into environment section
- Platform-aware shell guidance (PowerShell syntax on Windows)
- Explicit error recovery instructions for edit_file failures
- "ALWAYS read before editing" and "never repeat failed calls" rules

Permission box:
- Centered and pinned above input (not in scrollable viewport)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: halfaipg

agent.go

@@ -5,7 +5,9 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"sync"
 	"time"
@@ -61,13 +63,13 @@ debug, and modify software projects.
 Available tools:
 - read_file: Read file contents with line numbers. Use offset/limit for large files.
 - write_file: Create or overwrite a file. Parent directories are created automatically.
-- edit_file: Surgical find-and-replace in a file. old_text must match exactly and be unique.
+- edit_file: Surgical find-and-replace in a file. old_text must match exactly and be unique. If old_text is not found, re-read the file and check for exact whitespace and line endings.
 - multi_edit: Batch multiple edits across files. Per-file atomicity with rollback.
 - list_files: List directory contents or glob for files (e.g. "**/*.go").
 - search_files: Regex search across files (powered by ripgrep). Find definitions, usages, etc.
 - web_search: Search the web. Use for current info, docs, versions, error solutions, or anything not in local files.
 - dispatch_agent: Spawn a read-only research subagent to investigate questions in isolated context.
-- shell: Run any shell command. Use for builds, tests, package management.
+- shell: Run a shell command. Use for builds, tests, package management, and any terminal task.
 - git_status: Show working tree status (staged, unstaged, untracked files).
 - git_diff: Show file diffs (staged, unstaged, or between refs).
 - git_log: Show recent commit history.
@@ -79,16 +81,21 @@ Available tools:
 - get_task: Get full details of a specific task.
 
 Guidelines:
+- ALWAYS read a file before editing it — never guess at file contents
+- ALWAYS use search_files or list_files to explore before assuming project structure
 - You can call multiple tools in parallel — read_file, list_files, search_files, web_search, dispatch_agent, list_tasks, and get_task all run concurrently
-- Use list_files and search_files to explore the project before making changes
-- Read files before editing them — understand existing code first
 - Make targeted, minimal changes — don't rewrite entire files unnecessarily
 - For multiple related edits, prefer multi_edit over separate edit_file calls
 - Use git tools instead of shell for git operations — they provide structured output
-- After you edit files, the system may report diagnostics (errors, warnings) from language tools. If diagnostics appear, fix the issues before moving on.
-- If a tool fails, read the error and try a different approach
+- After you edit files, the system may report diagnostics (errors, warnings) from language tools. If diagnostics appear, fix the issues before moving on
 - When finished, briefly summarize what you changed and why
 
+Error recovery:
+- If edit_file fails with "old_text not found", re-read the file to see the actual content, then retry with corrected text
+- If edit_file fails with "found N times", add more surrounding context lines to old_text to make it unique
+- If a shell command fails, read the error output carefully and try a different approach
+- Never repeat a failed tool call with identical arguments
+
 Task management:
 - For multi-step work (3+ steps), create tasks upfront so the user can track progress
 - Set status to "in_progress" BEFORE starting work on a task
@@ -133,8 +140,23 @@ func strPtr(s string) *string { return &s }
 func buildSystemPrompt(workDir string) string {
 	var sb strings.Builder
 	sb.WriteString(systemPrompt)
-	sb.WriteString(fmt.Sprintf("\n\nCurrent date: %s\n", time.Now().Format("2006-01-02")))
-	sb.WriteString(fmt.Sprintf("Working directory: %s\n", workDir))
+
+	// Environment context
+	sb.WriteString("\n\n## Environment\n\n")
+	sb.WriteString(fmt.Sprintf("- Platform: %s/%s\n", runtime.GOOS, runtime.GOARCH))
+	sb.WriteString(fmt.Sprintf("- Shell: %s\n", detectShellName()))
+	sb.WriteString(fmt.Sprintf("- Date: %s\n", time.Now().Format("2006-01-02")))
+	sb.WriteString(fmt.Sprintf("- Working directory: %s\n", workDir))
+
+	// Git context
+	if branch := getGitBranch(workDir); branch != "" {
+		sb.WriteString(fmt.Sprintf("- Git branch: %s\n", branch))
+	}
+
+	// Platform-specific shell guidance
+	if runtime.GOOS == "windows" {
+		sb.WriteString("\nShell commands run in PowerShell. Use PowerShell syntax (e.g. `Get-ChildItem` not `ls`, `Remove-Item` not `rm`, `;` or `&&` to chain commands).\n")
+	}
 
 	// Load project instructions if available
 	projectInstructions := loadProjectInstructions(workDir)
@@ -155,6 +177,35 @@ func buildSystemPrompt(workDir string) string {
 	return sb.String()
 }
 
+// detectShellName returns the name of the shell that will be used for commands.
+func detectShellName() string {
+	if runtime.GOOS == "windows" {
+		if _, err := exec.LookPath("pwsh"); err == nil {
+			return "pwsh (PowerShell Core)"
+		}
+		if _, err := exec.LookPath("powershell"); err == nil {
+			return "powershell (Windows PowerShell)"
+		}
+		return "cmd.exe"
+	}
+	shell := os.Getenv("SHELL")
+	if shell == "" {
+		return "/bin/sh"
+	}
+	return filepath.Base(shell)
+}
+
+// getGitBranch returns the current git branch name, or empty if not in a git repo.
+func getGitBranch(workDir string) string {
+	cmd := exec.Command("git", "rev-parse", "--abbrev-ref", "HEAD")
+	cmd.Dir = workDir
+	out, err := cmd.Output()
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(out))
+}
+
 // loadProjectInstructions looks for project config files (AGENTS.md, CLAUDE.md,
 // CODEX.md, .codebase) in the working directory and parent directories up to git root.
 func loadProjectInstructions(workDir string) string {

permission.go

@@ -61,18 +61,30 @@ func shellNeedsPermission(cmd string) bool {
 	cmdLower := strings.ToLower(strings.TrimSpace(cmd))
 
 	readOnlyPrefixes := []string{
+		// Unix
 		"ls", "cat ", "head ", "tail ", "grep ", "rg ", "find ",
 		"wc ", "file ", "which ", "echo ", "pwd", "env", "printenv",
+		"du ", "df ", "stat ", "date", "uname",
+		"jq ", "sort ", "uniq ", "tr ",
+		// Windows / PowerShell
+		"dir ", "dir", "type ", "where ", "where.exe",
+		"get-content ", "get-childitem ", "get-item ",
+		"get-location", "get-process",
+		"select-string ", "measure-object",
+		"test-path ", "resolve-path",
+		"systeminfo", "hostname", "whoami",
+		"write-host ", "write-output ",
+		// Git (cross-platform)
 		"git status", "git log", "git diff", "git show", "git branch",
 		"git remote", "git tag", "git stash list",
+		// Build/test (cross-platform)
 		"go vet", "go build", "go test", "go run",
-		"tsc ", "npx tsc", "npm test", "npm run", "npm ls",
-		"pytest", "python -c", "python3 -c",
+		"tsc ", "npx tsc", "npx ", "npm test", "npm run", "npm ls",
+		"pytest", "python -c", "python3 -c", "python -m pytest",
 		"cargo check", "cargo test", "cargo build",
 		"make ", "make -n", "make check",
-		"du ", "df ", "stat ", "date", "uname",
 		"node -e", "node --eval",
-		"jq ", "sort ", "uniq ", "tr ",
+		"dotnet build", "dotnet test",
 	}
 
 	for _, prefix := range readOnlyPrefixes {

subagent.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"runtime"
 	"strings"
 )
 
@@ -18,7 +19,7 @@ import (
 
 const subagentMaxTurns = 25
 
-const subagentSystemPrompt = `You are a focused research assistant. You help gather information by reading files, searching code, and listing directories.
+const subagentSystemPromptBase = `You are a focused research assistant. You help gather information by reading files, searching code, and listing directories.
 
 You have read-only access to the project. You CANNOT modify any files.
 
@@ -29,7 +30,7 @@ Guidelines:
 - Use search_files to find relevant code quickly
 - Use list_files to explore project structure
 - Use web_search when you need external documentation, API references, or current information
-- Use shell for read-only commands only (ls, cat, grep, git log, etc.)
+- Use shell for read-only commands only (e.g. git log, git status, directory listings)
 - When done, provide a clear, concise summary of your findings`
 
 // subagentToolDefs contains only read-only tools.
@@ -47,7 +48,7 @@ func init() {
 
 // RunSubagent executes a read-only research subagent and returns its final text.
 func RunSubagent(client *LLMClient, workDir, task string) (string, error) {
-	sysContent := subagentSystemPrompt + fmt.Sprintf("\n\nWorking directory: %s", workDir)
+	sysContent := subagentSystemPromptBase + fmt.Sprintf("\n\nPlatform: %s\nWorking directory: %s", runtime.GOOS, workDir)
 
 	history := []ChatMessage{
 		{Role: "system", Content: strPtr(sysContent)},
@@ -145,14 +146,24 @@ func RunSubagent(client *LLMClient, workDir, task string) (string, error) {
 
 // shellWritePatterns detects commands that modify the filesystem.
 var shellWritePatterns = []string{
+	// Unix
 	"rm ", "rm\t", "rmdir", "mv ", "mv\t", "cp ", "cp\t",
 	"mkdir", "touch ", "chmod", "chown",
 	"tee ", "tee\t", "truncate",
+	"sed -i", "patch ",
+	// Windows / PowerShell
+	"del ", "del\t", "erase ", "rd ", "rd\t",
+	"move ", "move\t", "copy ", "copy\t", "xcopy",
+	"ren ", "rename ", "md ", "md\t",
+	"remove-item", "move-item", "copy-item",
+	"new-item", "set-content", "add-content",
+	"out-file", "invoke-webrequest",
+	// Git (cross-platform)
 	"git checkout", "git reset", "git clean", "git stash",
 	"git merge", "git rebase", "git commit", "git push",
+	// Package managers (cross-platform)
 	"npm install", "yarn add", "pip install",
 	"go install", "go get",
-	"sed -i", "patch ",
 }
 
 // executeReadOnlyShell runs a shell command but blocks write-like commands.

tools.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"runtime"
 	"sort"
 	"strings"
 	"time"
@@ -338,17 +339,14 @@ var toolDefs = []ToolDef{
 	{
 		Type: "function",
 		Function: ToolDefFunction{
-			Name: "shell",
-			Description: "Execute a shell command in the project directory. " +
-				"Use for: running builds, tests, installing packages, git commands, and any terminal task. " +
-				"Commands run in a bash shell. The full stdout + stderr is returned. " +
-				"Long-running commands are killed after the timeout.",
+			Name:        "shell",
+			Description: shellToolDescription(),
 			Parameters: map[string]interface{}{
 				"type": "object",
 				"properties": map[string]interface{}{
 					"command": map[string]interface{}{
 						"type":        "string",
-						"description": "The shell command to execute. Use && to chain commands.",
+						"description": shellCommandDescription(),
 					},
 				},
 				"required": []string{"command"},
@@ -1139,17 +1137,79 @@ func toolWebSearch(args map[string]interface{}) (string, bool) {
 
 // ── shell ────────────────────────────────────────────────────
 
+// shellToolDescription returns a platform-aware description for the shell tool.
+func shellToolDescription() string {
+	if runtime.GOOS == "windows" {
+		return "Execute a shell command in the project directory. " +
+			"Use for: running builds, tests, installing packages, git commands, and any terminal task. " +
+			"Commands run in PowerShell on Windows. The full stdout + stderr is returned. " +
+			"Long-running commands are killed after the timeout."
+	}
+	return "Execute a shell command in the project directory. " +
+		"Use for: running builds, tests, installing packages, git commands, and any terminal task. " +
+		"Commands run in a bash shell. The full stdout + stderr is returned. " +
+		"Long-running commands are killed after the timeout."
+}
+
+// shellCommandDescription returns platform-aware help for the command parameter.
+func shellCommandDescription() string {
+	if runtime.GOOS == "windows" {
+		return "The shell command to execute. Use ; or && to chain commands. Use PowerShell syntax."
+	}
+	return "The shell command to execute. Use && to chain commands."
+}
+
 // dangerousPatterns detects potentially destructive shell commands.
-var dangerousPatterns = []string{
-	"rm -rf /",
-	"rm -rf ~",
-	"rm -rf $HOME",
-	":(){:|:&};:",    // fork bomb
-	"mkfs.",
-	"dd if=",
-	"> /dev/sd",
-	"chmod -R 777 /",
-	":(){ :|:& };:", // fork bomb variant
+var dangerousPatterns = func() []string {
+	base := []string{
+		"rm -rf /",
+		"rm -rf ~",
+		"rm -rf $HOME",
+		":(){:|:&};:",    // fork bomb
+		"mkfs.",
+		"dd if=",
+		"> /dev/sd",
+		"chmod -R 777 /",
+		":(){ :|:& };:", // fork bomb variant
+	}
+	if runtime.GOOS == "windows" {
+		base = append(base,
+			"format c:",
+			"format d:",
+			"del /f /s /q c:\\",
+			"rd /s /q c:\\",
+			"rmdir /s /q c:\\",
+			"remove-item -recurse -force c:\\",
+			"remove-item -recurse -force $env:",
+		)
+	}
+	return base
+}()
+
+// getShellCommand returns the appropriate shell binary and args for the platform.
+func getShellCommand(command string) *exec.Cmd {
+	if runtime.GOOS == "windows" {
+		// Try PowerShell first (pwsh = PowerShell Core, powershell = Windows PowerShell)
+		if _, err := exec.LookPath("pwsh"); err == nil {
+			return exec.Command("pwsh", "-NoProfile", "-NonInteractive", "-Command", command)
+		}
+		if _, err := exec.LookPath("powershell"); err == nil {
+			return exec.Command("powershell", "-NoProfile", "-NonInteractive", "-Command", command)
+		}
+		// Fallback to cmd.exe
+		shell := os.Getenv("COMSPEC")
+		if shell == "" {
+			shell = "cmd.exe"
+		}
+		return exec.Command(shell, "/C", command)
+	}
+
+	// Unix: use SHELL env var, fallback to /bin/sh
+	shell := os.Getenv("SHELL")
+	if shell == "" {
+		shell = "/bin/sh"
+	}
+	return exec.Command(shell, "-c", command)
 }
 
 func toolShell(args map[string]interface{}, workDir string) (string, bool) {
@@ -1166,7 +1226,7 @@ func toolShell(args map[string]interface{}, workDir string) (string, bool) {
 		}
 	}
 
-	cmd := exec.Command("bash", "-c", command)
+	cmd := getShellCommand(command)
 	cmd.Dir = workDir
 	cmd.Env = append(os.Environ(),
 		"TERM=dumb",