feat: v0.4.0 — exec, daemon, mission, agents, snapshots, Waza workflows

New CLI commands: exec (non-interactive with JSON/worktree/agent support),
daemon (background HTTP server with SSE), mission (multi-agent parallel
orchestration), search (full-text session search), agent (persona management),
snapshot (granular file undo).

New slash commands: /think (planning), /hunt (debugging), /check (pre-ship
review), /design (UI iteration), /snapshot (list/restore/diff).

Engine enhancements: structured compaction template, doom loop escalation
(threshold 3), auto-snapshot on file writes, session persistence for exec.

New packages: mission/, daemon/, agents/, snapshot/.

Inspired by Factory Droid, OpenCode, and Waza.

Author: Patel230

CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## [0.4.0] — 2026-05-05
+
+### Added
+- **Exec Subcommand**: `hawk exec "prompt"` — full engine non-interactive mode with `--output-format json`, `--auto` autonomy levels, `--worktree` isolation, `--agent` personas, `--session-id` resume, stdin piping
+- **Daemon Server**: `hawk daemon start/stop/status` — background HTTP server with JSON + SSE streaming on `/v1/chat`, `/v1/health`, `/v1/sessions`
+- **Mission Mode**: `hawk mission "prompt"` — multi-agent orchestration decomposing work into parallel features executed in isolated git worktrees. `--dry-run` for planning only
+- **Session Search**: `hawk search "query"` — full-text search across all saved sessions with `--json` output
+- **Custom Agents**: `hawk agent list/create/show/remove` — markdown persona definitions in `~/.hawk/agents/` with YAML frontmatter (name, description, model)
+- **Snapshot System**: Shadow git tracking of every file change. `hawk snapshot list/restore/diff` + `/snapshot` slash command. Auto-snapshots on every Write/Edit tool call
+- **Waza Workflows**: `/think` (plan before code), `/hunt` (root-cause diagnosis), `/check` (pre-ship review with auto-fix), `/design` (screenshot-driven UI iteration)
+- **Structured Compaction**: Summary template with Goal/Constraints/Progress/Files/Decisions/Errors/Instructions/Next sections for better intent preservation
+- **Doom Loop Detection**: Lowered threshold to 3 (from 4). Two-tier escalation: first detection injects redirect prompt, doom loop hard-stops with "ask user for help"
+- **Session Persistence for exec**: All exec runs saved to `~/.hawk/sessions/` and searchable via `hawk search`
+
+### Packages Added
+- `mission/` — Multi-agent orchestration with worktree-based parallel workers
+- `daemon/` — HTTP server with session factory, SSE streaming, PID file management
+- `agents/` — Markdown persona loader with frontmatter parsing
+- `snapshot/` — Shadow git repository for granular file-level undo
+
+### Inspired By
+- Factory Droid v0.117.0 (exec mode, daemon, mission orchestration, custom agents)
+- OpenCode (structured compaction, snapshot system, doom loop escalation)
+- Waza by tw93 (engineering-habit workflows: think, hunt, check, design)
+
 ## [0.3.0] — 2026-05-03
 
 ### Added

README.md

@@ -59,6 +59,17 @@ hawk --fork-session -r abc123 # Resume as new session
 hawk --mcp "npx @mcp/server"  # Connect MCP server
 hawk -p "fix tests" --allowed-tools "Bash(go test:*) Edit Read"
 hawk -p "plan only" --permission-mode plan --tools "Read,Grep,Glob"
+hawk exec "fix all tests"     # Non-interactive with full engine
+hawk exec --auto full -o json "add error handling"
+hawk exec --worktree "refactor auth module"
+hawk exec --agent reviewer "review last commit"
+hawk daemon start             # Background HTTP server
+hawk daemon status            # Check if daemon running
+hawk mission "add auth, rate limiting, and tests"
+hawk mission --dry-run "decompose this into features"
+hawk search "authentication"  # Search across all sessions
+hawk agent list               # List custom personas
+hawk agent create debugger    # Create new persona
 hawk doctor                   # Run diagnostics
 hawk config                   # Show effective settings
 hawk sessions                 # List saved sessions
@@ -164,6 +175,10 @@ Core commands:
 | `/review` | Ask hawk to review changes |
 | `/test` | Run project tests |
 | `/lint` | Run linter |
+| `/think <topic>` | Plan before coding (Waza method) |
+| `/hunt <symptom>` | Root-cause diagnosis before fixing (Waza method) |
+| `/check` | Pre-ship review with auto-fix (Waza method) |
+| `/design <goal>` | Screenshot-driven UI iteration (Waza method) |
 | `/bughunter` | Hunt for bugs |
 | `/security-review` | Review security risks |
 | `/power <level>` | Set power level (1-10) |
@@ -237,13 +252,83 @@ hooks/        Event hook system with decision hooks
 analytics/    Session traces, activity tracking, cost optimization, model cascade
 trace/        Built-in tracer + optional OTel SDK (build tag)
 sandbox/      Command isolation (namespace, docker, chroot, seatbelt, landlock, seccomp)
+mission/      Multi-agent orchestration (parallel feature execution in worktrees)
+daemon/       Background HTTP server (JSON + SSE streaming)
+agents/       Custom agent persona loader (markdown + frontmatter)
+parallel/     Worktree-based parallel task execution
 retry/        Exponential backoff with jitter
 circuit/      Circuit breaker (closed/open/half-open)
 ratelimit/    Token bucket rate limiting
 ```
 
 Zero CGO. Single static binary. Cross-compiled for linux/darwin/windows amd64/arm64.
 
+## Exec Mode
+
+Run hawk non-interactively for scripting and CI:
+
+```bash
+hawk exec "fix all failing tests"
+hawk exec --auto full "refactor to use context"
+hawk exec --output-format json "list all TODO comments"
+hawk exec --worktree "add rate limiting"           # isolated branch
+hawk exec --agent reviewer "review the last 3 commits"
+hawk exec -s exec-123456 "continue from last time" # resume session
+echo "explain main.go" | hawk exec -               # stdin
+```
+
+## Mission Mode
+
+Decompose work into parallel features:
+
+```bash
+hawk mission "Add auth, rate limiting, and logging"
+hawk mission --workers 6 --model claude-sonnet-4-6 "Refactor into microservices"
+hawk mission --dry-run "What would this decompose into?"
+```
+
+Each feature runs in its own git worktree with full autonomy. Results are committed on separate branches.
+
+## Daemon
+
+Background HTTP server for programmatic access:
+
+```bash
+hawk daemon start              # Start on port 4590
+hawk daemon start --port 8080  # Custom port
+hawk daemon status             # Check if running
+hawk daemon stop               # Graceful shutdown
+```
+
+Endpoints:
+- `GET /v1/health` — server status
+- `POST /v1/chat` — send prompt, get response (JSON or SSE streaming)
+- `GET /v1/sessions` — list active sessions
+
+SSE streaming: set `Accept: text/event-stream` header.
+
+## Custom Agents
+
+Define reusable personas in `~/.hawk/agents/`:
+
+```bash
+hawk agent create reviewer -d "Security-focused code reviewer"
+hawk agent list
+hawk agent show reviewer
+hawk exec --agent reviewer "check the auth module"
+```
+
+Agent files are markdown with YAML frontmatter:
+
+```markdown
+---
+name: reviewer
+description: Security-focused code reviewer
+model: claude-sonnet-4-6
+---
+You are a security expert. Focus on injection, auth bypass, and secrets.
+```
+
 ## AGENTS.md
 
 Create an `AGENTS.md` in your project root for project-specific instructions (max 10KB). Any AI coding agent can read this — hawk, Claude Code, Cursor, Codex:

agents/agents.go

@@ -0,0 +1,166 @@
+package agents
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// Agent is a user-defined persona with a custom system prompt.
+// Stored as markdown files with YAML frontmatter in ~/.hawk/agents/.
+type Agent struct {
+	Name        string `json:"name"`
+	Description string `json:"description"`
+	Model       string `json:"model,omitempty"`
+	Prompt      string `json:"prompt"`
+	FilePath    string `json:"file_path"`
+}
+
+// Load reads an agent definition from a markdown file.
+// Format:
+//
+//	---
+//	name: reviewer
+//	description: Code review specialist
+//	model: inherit
+//	---
+//	You are a code reviewer...
+func Load(path string) (*Agent, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+	return Parse(string(data), path)
+}
+
+// Parse extracts agent metadata and prompt from markdown content.
+func Parse(content, filePath string) (*Agent, error) {
+	content = strings.TrimSpace(content)
+	if !strings.HasPrefix(content, "---") {
+		return nil, fmt.Errorf("agent file must start with --- frontmatter")
+	}
+
+	// Find closing ---
+	rest := content[3:]
+	endIdx := strings.Index(rest, "\n---")
+	if endIdx < 0 {
+		return nil, fmt.Errorf("agent file missing closing --- for frontmatter")
+	}
+
+	frontmatter := rest[:endIdx]
+	body := strings.TrimSpace(rest[endIdx+4:])
+
+	agent := &Agent{
+		Prompt:   body,
+		FilePath: filePath,
+	}
+
+	for _, line := range strings.Split(frontmatter, "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+		key, val, ok := parseYAMLLine(line)
+		if !ok {
+			continue
+		}
+		switch key {
+		case "name":
+			agent.Name = val
+		case "description":
+			agent.Description = val
+		case "model":
+			if val != "inherit" {
+				agent.Model = val
+			}
+		}
+	}
+
+	if agent.Name == "" {
+		base := filepath.Base(filePath)
+		agent.Name = strings.TrimSuffix(base, filepath.Ext(base))
+	}
+
+	return agent, nil
+}
+
+// ListAll discovers all agent definitions from the standard directories.
+// Search order: ~/.hawk/agents/, .hawk/agents/ (project-local).
+func ListAll() ([]*Agent, error) {
+	var agents []*Agent
+
+	dirs := agentDirs()
+	for _, dir := range dirs {
+		entries, err := os.ReadDir(dir)
+		if err != nil {
+			continue
+		}
+		for _, e := range entries {
+			if e.IsDir() || !strings.HasSuffix(e.Name(), ".md") {
+				continue
+			}
+			a, err := Load(filepath.Join(dir, e.Name()))
+			if err != nil {
+				continue
+			}
+			agents = append(agents, a)
+		}
+	}
+	return agents, nil
+}
+
+// Get finds an agent by name from all known directories.
+func Get(name string) (*Agent, error) {
+	agents, err := ListAll()
+	if err != nil {
+		return nil, err
+	}
+	for _, a := range agents {
+		if a.Name == name {
+			return a, nil
+		}
+	}
+	return nil, fmt.Errorf("agent %q not found", name)
+}
+
+// DefaultDir returns the user's agent directory (~/.hawk/agents/).
+func DefaultDir() string {
+	home, _ := os.UserHomeDir()
+	return filepath.Join(home, ".hawk", "agents")
+}
+
+// agentDirs returns the list of directories to search for agents.
+func agentDirs() []string {
+	dirs := []string{DefaultDir()}
+
+	// Project-local agents
+	if cwd, err := os.Getwd(); err == nil {
+		localDir := filepath.Join(cwd, ".hawk", "agents")
+		if info, err := os.Stat(localDir); err == nil && info.IsDir() {
+			dirs = append(dirs, localDir)
+		}
+	}
+
+	return dirs
+}
+
+func parseYAMLLine(line string) (key, val string, ok bool) {
+	idx := strings.Index(line, ":")
+	if idx < 0 {
+		return "", "", false
+	}
+	key = strings.TrimSpace(line[:idx])
+	val = strings.TrimSpace(line[idx+1:])
+	// Strip surrounding quotes
+	if len(val) >= 2 {
+		if (val[0] == '"' && val[len(val)-1] == '"') ||
+			(val[0] == '\'' && val[len(val)-1] == '\'') {
+			val = val[1 : len(val)-1]
+		}
+	}
+	// Handle multi-line YAML >- by collapsing (simplified)
+	val = strings.TrimPrefix(val, ">-")
+	val = strings.TrimSpace(val)
+	return key, val, true
+}