feat: permission system, git tools, language diagnostics

Add three Claude Code-inspired features:

1. Permission system — prompts user (y/n/a) before executing
   mutating tools (write_file, edit_file, shell mutations, git
   commits). Supports per-tool and session-wide trust levels.

2. Git tools — 5 first-class tools (git_status, git_diff, git_log,
   git_commit, git_branch) with parallel-safe read ops, permission
   gating on mutations, and subagent access to read-only git tools.

3. Diagnostics engine — auto-detects Go/TypeScript/Python checkers
   at startup, runs them after file edits, injects errors into
   agent context so it self-corrects.

New slash commands: /trust, /diagnostics
33 new tests (117 total), all passing.

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

Author: halfaipg

agent.go

@@ -24,6 +24,7 @@ const (
 	EventTurnStart                   // new agentic turn
 	EventDone                        // agent finished all turns
 	EventError                       // error occurred
+	EventPermission                  // permission request for TUI
 )
 
 type TokenUsage struct {
@@ -37,11 +38,12 @@ type AgentEvent struct {
 	Tool    string         // EventToolStart / EventToolResult — tool name
 	ToolID  string         // EventToolStart / EventToolResult — tool call ID
 	Args    map[string]any // EventToolStart — parsed arguments
-	Output  string         // EventToolResult — tool output
-	Success bool           // EventToolResult
-	Tokens  TokenUsage     // EventUsage
-	Turn    int            // EventTurnStart
-	Error   error          // EventError
+	Output     string             // EventToolResult — tool output
+	Success    bool               // EventToolResult
+	Tokens     TokenUsage         // EventUsage
+	Turn       int                // EventTurnStart
+	Error      error              // EventError
+	Permission *PermissionRequest // EventPermission
 }
 
 // ──────────────────────────────────────────────────────────────
@@ -64,24 +66,34 @@ Available tools:
 - 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, git, package management.
+- shell: Run any shell command. Use for builds, tests, package management.
+- 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.
+- git_commit: Stage files and create a commit.
+- git_branch: List, create, or switch branches.
 
 Guidelines:
 - You can call multiple tools in parallel — read_file, list_files, search_files, web_search, and dispatch_agent 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
 - When finished, briefly summarize what you changed and why`
 
 type Agent struct {
-	client   *LLMClient
-	workDir  string
-	history  []ChatMessage
-	events   chan<- AgentEvent
-	stopCh   <-chan struct{}
-	files    int // count of files created/modified
+	client    *LLMClient
+	workDir   string
+	history   []ChatMessage
+	events    chan<- AgentEvent
+	stopCh    <-chan struct{}
+	files     int // count of files created/modified
+	permCh    chan PermissionResponse
+	permState *PermissionState
+	diag      *DiagnosticsEngine
 }
 
 func NewAgent(client *LLMClient, workDir string, events chan<- AgentEvent, stopCh <-chan struct{}) *Agent {
@@ -94,6 +106,9 @@ func NewAgent(client *LLMClient, workDir string, events chan<- AgentEvent, stopC
 		history: []ChatMessage{
 			{Role: "system", Content: strPtr(sysContent)},
 		},
+		permCh:    make(chan PermissionResponse, 1),
+		permState: &PermissionState{TrustedTools: map[string]bool{}},
+		diag:      NewDiagnosticsEngine(workDir),
 	}
 }
 
@@ -412,6 +427,32 @@ func (a *Agent) executeToolCalls(toolCalls []ToolCall, consecutiveErrors *int) {
 			argsMap = map[string]any{"_raw": tc.Function.Arguments}
 		}
 
+		// Check permission before executing
+		if !a.checkPermission(tc.Function.Name, argsMap) {
+			output := "Skipped: permission denied by user"
+			a.events <- AgentEvent{
+				Type:   EventToolStart,
+				Tool:   tc.Function.Name,
+				ToolID: tc.ID,
+				Args:   argsMap,
+			}
+			a.events <- AgentEvent{
+				Type:    EventToolResult,
+				Tool:    tc.Function.Name,
+				ToolID:  tc.ID,
+				Args:    argsMap,
+				Output:  output,
+				Success: false,
+			}
+			a.history = append(a.history, ChatMessage{
+				Role:       "tool",
+				ToolCallID: tc.ID,
+				Name:       tc.Function.Name,
+				Content:    strPtr(output),
+			})
+			continue
+		}
+
 		a.events <- AgentEvent{
 			Type:   EventToolStart,
 			Tool:   tc.Function.Name,
@@ -442,6 +483,7 @@ func (a *Agent) executeToolCalls(toolCalls []ToolCall, consecutiveErrors *int) {
 			allErrors = false
 			if tc.Function.Name == "write_file" || tc.Function.Name == "edit_file" || tc.Function.Name == "multi_edit" {
 				a.files++
+				a.maybeInjectDiagnostics(tc.Function.Name, argsMap)
 			}
 		}
 
@@ -473,3 +515,88 @@ func (a *Agent) executeToolCalls(toolCalls []ToolCall, consecutiveErrors *int) {
 func (a *Agent) FilesChanged() int {
 	return a.files
 }
+
+// maybeInjectDiagnostics runs language checkers after file modifications
+// and injects a system message with errors if found.
+func (a *Agent) maybeInjectDiagnostics(toolName string, args map[string]any) {
+	if a.diag == nil || !a.diag.Enabled {
+		return
+	}
+
+	// Determine which files were modified
+	var files []string
+	switch toolName {
+	case "write_file", "edit_file":
+		if p, ok := args["path"].(string); ok {
+			files = []string{p}
+		}
+	case "multi_edit":
+		if edits, ok := args["edits"]; ok {
+			if arr, ok := edits.([]interface{}); ok {
+				seen := map[string]bool{}
+				for _, e := range arr {
+					if m, ok := e.(map[string]interface{}); ok {
+						if p, ok := m["path"].(string); ok && !seen[p] {
+							files = append(files, p)
+							seen[p] = true
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if len(files) == 0 {
+		return
+	}
+
+	diags := a.diag.CheckFiles(files)
+	if len(diags) == 0 {
+		return
+	}
+
+	// Inject as system message so the LLM sees errors
+	msg := formatDiagnosticsMessage(diags)
+	a.history = append(a.history, ChatMessage{
+		Role:    "system",
+		Content: strPtr(msg),
+	})
+}
+
+// checkPermission asks the TUI for permission if needed.
+// Returns true if the tool should execute, false to skip.
+func (a *Agent) checkPermission(toolName string, args map[string]any) bool {
+	// Check session-level trust
+	if a.permState.Level == PermTrustAll {
+		return true
+	}
+	if a.permState.TrustedTools[toolName] {
+		return true
+	}
+
+	// Check if this tool needs permission
+	if !NeedsPermission(toolName, args) {
+		return true
+	}
+
+	// Send permission request to TUI
+	req := &PermissionRequest{
+		Tool:    toolName,
+		Args:    args,
+		Summary: PermissionSummary(toolName, args),
+	}
+	a.events <- AgentEvent{Type: EventPermission, Permission: req}
+
+	// Block waiting for TUI response (or stop signal)
+	select {
+	case resp := <-a.permCh:
+		if resp.TrustLevel == PermTrustTool {
+			a.permState.TrustedTools[toolName] = true
+		} else if resp.TrustLevel == PermTrustAll {
+			a.permState.Level = PermTrustAll
+		}
+		return resp.Allowed
+	case <-a.stopCh:
+		return false
+	}
+}

chat.go

@@ -23,6 +23,7 @@ const (
 	chatPlanning                    // Q&A planning phase
 	chatPlanReview                  // reviewing generated plan
 	chatStreaming                   // agent is working
+	chatPermission                  // waiting for permission approval
 	chatDoneFlash                   // brief green flash after completion
 )
 
@@ -66,6 +67,9 @@ type chatModel struct {
 	lastStreamRebuild time.Time // debounce streaming viewport rebuilds
 	inThink           bool      // inside <think> tags (MiniMax reasoning)
 
+	// Permission
+	permRequest *PermissionRequest // current pending permission prompt
+
 	// Glue + notifications
 	glue          *GlueClient
 	notify        *notifyManager
@@ -203,6 +207,21 @@ func (m chatModel) Update(msg tea.Msg) (chatModel, tea.Cmd) {
 				m.rebuildViewport()
 				return m, nil
 			}
+			if m.state == chatPermission {
+				// Deny the pending permission and return to streaming
+				if m.agent != nil {
+					m.agent.permCh <- PermissionResponse{Allowed: false}
+				}
+				m.permRequest = nil
+				m.state = chatStreaming
+				m.input.Placeholder = "describe what you want to build..."
+				m.segments = append(m.segments, segment{
+					kind: "text",
+					text: styleWarn.Render("  ✗ denied") + "\n",
+				})
+				m.rebuildViewport()
+				return m, m.waitForEvent()
+			}
 			if m.state == chatPlanning || m.state == chatPlanReview {
 				m.state = chatIdle
 				m.planState = nil
@@ -224,6 +243,30 @@ func (m chatModel) Update(msg tea.Msg) (chatModel, tea.Cmd) {
 			m.input.SetValue("")
 
 			switch m.state {
+			case chatPermission:
+				resp := parsePermissionInput(prompt)
+				if m.agent != nil {
+					m.agent.permCh <- resp
+				}
+				// Show what user decided
+				decision := styleOK.Render("  ✓ allowed")
+				if !resp.Allowed {
+					decision = styleWarn.Render("  ✗ denied")
+				} else if resp.TrustLevel == PermTrustTool {
+					decision = styleOK.Render("  ✓ allowed (always for this tool)")
+				} else if resp.TrustLevel == PermTrustAll {
+					decision = styleOK.Render("  ✓ allowed (trusting all)")
+				}
+				m.segments = append(m.segments, segment{
+					kind: "text",
+					text: decision + "\n",
+				})
+				m.permRequest = nil
+				m.state = chatStreaming
+				m.input.Placeholder = "describe what you want to build..."
+				m.rebuildViewport()
+				return m, m.waitForEvent()
+
 			case chatPlanning:
 				// User answering a planning question
 				cmds = append(cmds, m.handlePlanAnswer(prompt))
@@ -756,7 +799,7 @@ func (m *chatModel) handlePlanReview(input string) tea.Cmd {
 
 func (m *chatModel) handleAgentEvent(evt AgentEvent) tea.Cmd {
 	// Guard: ignore events if we're no longer streaming (e.g. after ctrl+c)
-	if m.state != chatStreaming && evt.Type != EventDone {
+	if m.state != chatStreaming && m.state != chatPermission && evt.Type != EventDone {
 		return nil
 	}
 
@@ -920,6 +963,21 @@ func (m *chatModel) handleAgentEvent(evt AgentEvent) tea.Cmd {
 			tea.Tick(5*time.Second, func(t time.Time) tea.Msg { return narrateTickMsg{} }),
 		)
 
+	case EventPermission:
+		m.flushStreamingText()
+		m.state = chatPermission
+		m.permRequest = evt.Permission
+		// Render the permission prompt
+		summary := evt.Permission.Summary
+		m.segments = append(m.segments, segment{
+			kind: "text",
+			text: "\n" + styleWarn.Render("  ⚡ Permission required: ") + styleMuted.Render(summary) + "\n" +
+				styleDim.Render("  y/n/a (yes, no, always for this tool): "),
+		})
+		m.input.Placeholder = "y/n/a..."
+		m.rebuildViewport()
+		return m.waitForEvent() // keep listening for other events while waiting
+
 	case EventError:
 		m.flushStreamingText()
 		errStr := "unknown error"
@@ -983,6 +1041,8 @@ func (m chatModel) View() string {
 		} else {
 			statusParts = append(statusParts, m.spinner.View()+styleMuted.Render(" working"))
 		}
+	case chatPermission:
+		statusParts = append(statusParts, styleWarn.Render("⚡ permission"))
 	case chatPlanning:
 		statusParts = append(statusParts, lipgloss.NewStyle().Foreground(colPurple).Render("◆ planning"))
 	case chatPlanReview:
@@ -1035,7 +1095,7 @@ func (m chatModel) View() string {
 	// ── Frame ────────────────────────────────────────────────
 	var frame lipgloss.Style
 	switch m.state {
-	case chatStreaming:
+	case chatStreaming, chatPermission:
 		frame = styleFrameActive.Width(m.width - 2)
 	case chatDoneFlash:
 		frame = styleFrameDone.Width(m.width - 2)
@@ -1066,6 +1126,8 @@ func (m chatModel) View() string {
 	switch m.state {
 	case chatStreaming:
 		hint = styleDim.Render("ctrl+c stop") + sep + styleDim.Render("↑↓ scroll")
+	case chatPermission:
+		hint = styleDim.Render("y allow") + sep + styleDim.Render("n deny") + sep + styleDim.Render("a always") + sep + styleDim.Render("ctrl+c deny")
 	case chatPlanning:
 		hint = styleDim.Render("ctrl+c cancel") + sep + styleDim.Render("enter answer")
 	case chatPlanReview: