Function bodies 169 total

func pruneTask(logsBase, runsBase, taskID string, opts PruneOptions) PruneResult {
	var result PruneResult

	logDir := filepath.Join(logsBase, taskID)
	runDir := filepath.Join(runsBase, taskID)

	// Prune runs (and corresponding logs)
	runFiles := listDataFiles(runDir, ".json")
	logFiles := listDataFiles(logDir, ".log")

	// Build a map of log files by run ID for easy lookup
	logByRunID := make(map[string]fileEntry)
	for _, lf := range logFiles {
		runID := strings.TrimSuffix(lf.name, ".log")
		logByRunID[runID] = lf
	}

	// Sort runs by mod time, newest first
	sort.Slice(runFiles, func(i, j int) bool {
		return runFiles[i].modTime.After(runFiles[j].modTime)
	})

	for i, rf := range runFiles {
		runID := strings.TrimSuffix(rf.name, ".json")
		shouldPrune := false

		// Check max_runs limit
		if opts.MaxRuns > 0 && i >= opts.MaxRuns {
			shouldPrune = true
		}

		// Check max_age limit
		if opts.MaxAge > 0 && opts.Now.Sub(rf.modTime) > opts.MaxAge {
			shouldPrune = true
		}

		if !shou

func listDataFiles(dir, suffix string) []fileEntry {
	entries, err := os.ReadDir(dir)
	if err != nil {
		return nil
	}

	var files []fileEntry
	for _, e := range entries {
		if e.IsDir() || e.Name() == "current" || !strings.HasSuffix(e.Name(), suffix) {
			continue
		}
		info, err := e.Info()
		if err != nil {
			continue
		}
		files = append(files, fileEntry{
			path:    filepath.Join(dir, e.Name()),
			modTime: info.ModTime(),
			name:    e.Name(),
		})
	}
	return files
}

func (r *Runner) Run(ctx context.Context, dir string, sessionID string, resume bool, skipPermissions bool, allowedTools []string, content string, taskLabel string, logDir string, skipIndices map[int]bool, onStart func(pid int, logPath string, sessionID string), onStatus func(status string)) (usedSessionID string, logPath string, usedRunnerIndex int, stderrOutput string, err error) {
	var lastErr error
	var lastStderr string
	var lastRunnerIndex int

	// Safety guard: never pass --resume with an empty session ID
	if resume && sessionID == "" {
		resume = false
	}

	// One log file is shared across all runner attempts for this Run() call.
	// It is opened before the first attempt so that output from every attempt
	// is captured, and closed via defer when Run() returns.
	var logFile *os.File
	if logDir != "" {
		if mkErr := os.MkdirAll(logDir, 0755); mkErr != nil {
			log.Printf("runner [%s] failed to create log dir %s: %v", taskLabel, logDir, mkErr)
		} else {
			// Use a random run ID 

func cleanEnv() []string {
	keep := map[string]bool{
		"ANTHROPIC_API_KEY":  true,
		"ANTHROPIC_BASE_URL": true,
	}
	var env []string
	for _, e := range os.Environ() {
		key := strings.SplitN(e, "=", 2)[0]
		if keep[key] {
			env = append(env, e)
			continue
		}
		if strings.HasPrefix(key, "CLAUDE") || strings.HasPrefix(key, "ANTHROPIC") {
			continue
		}
		env = append(env, e)
	}
	return env
}

func (sw *statusWriter) Write(p []byte) (int, error) {
	n := len(p)
	sw.buf = append(sw.buf, p...)

	for {
		idx := bytes.IndexByte(sw.buf, '\n')
		if idx < 0 {
			break
		}
		line := string(sw.buf[:idx])
		sw.buf = sw.buf[idx+1:]

		if strings.HasPrefix(line, statusPrefix) {
			status := strings.TrimSpace(line[len(statusPrefix):])
			if status != "" && sw.onStatus != nil {
				sw.onStatus(status)
			}
			// Strip status lines from downstream output
			continue
		}

		// Pass non-status lines through
		if _, err := sw.downstream.Write([]byte(line + "\n")); err != nil {
			return n, err
		}
	}
	return n, nil
}

func (sw *statusWriter) Flush() {
	if len(sw.buf) > 0 {
		line := string(sw.buf)
		if strings.HasPrefix(line, statusPrefix) {
			status := strings.TrimSpace(line[len(statusPrefix):])
			if status != "" && sw.onStatus != nil {
				sw.onStatus(status)
			}
		} else {
			sw.downstream.Write(sw.buf)
		}
		sw.buf = nil
	}
}

func ParseTokenUsage(stderr string) TokenUsage {
	var usage TokenUsage
	for _, line := range strings.Split(stderr, "\n") {
		line = strings.TrimSpace(line)
		if n, ok := extractTokenCount(line, "input"); ok {
			usage.InputTokens = n
		}
		if n, ok := extractTokenCount(line, "output"); ok {
			usage.OutputTokens = n
		}
	}
	return usage
}

func extractTokenCount(line, direction string) (int, bool) {
	lower := strings.ToLower(line)
	if !strings.Contains(lower, direction) || !strings.Contains(lower, "token") {
		return 0, false
	}
	// Extract the last number on the line (the token count)
	parts := strings.Fields(line)
	for i := len(parts) - 1; i >= 0; i-- {
		// Strip commas from numbers like "12,345"
		cleaned := strings.ReplaceAll(parts[i], ",", "")
		if n, err := strconv.Atoi(cleaned); err == nil && n >= 0 {
			return n, true
		}
	}
	return 0, false
}

func New() (Manager, error) {
	home, err := os.UserHomeDir()
	if err != nil {
		return nil, fmt.Errorf("cannot determine home directory: %w", err)
	}
	return &launchdManager{
		plistPath: filepath.Join(home, "Library", "LaunchAgents", launchdLabel+".plist"),
		logPath:   filepath.Join(home, ".anvil", "daemon.log"),
	}, nil
}

func (m *launchdManager) Install(binaryPath string) error {
	// Warn if binary looks temporary
	if strings.Contains(binaryPath, "/tmp/") || strings.Contains(binaryPath, "go-build") {
		fmt.Fprintf(os.Stderr, "warning: binary path looks temporary: %s\n", binaryPath)
		fmt.Fprintf(os.Stderr, "  install anvil to a permanent location first (e.g. go install or anvil update)\n")
	}

	// Ensure LaunchAgents directory exists
	if err := os.MkdirAll(filepath.Dir(m.plistPath), 0755); err != nil {
		return fmt.Errorf("creating LaunchAgents directory: %w", err)
	}

	// If service is currently loaded, unload it first for idempotent re-install
	if m.isLoaded() {
		_ = exec.Command("launchctl", "bootout", fmt.Sprintf("gui/%d/%s", os.Getuid(), launchdLabel)).Run()
	}

	// Generate plist
	f, err := os.Create(m.plistPath)
	if err != nil {
		return fmt.Errorf("creating plist: %w", err)
	}
	defer f.Close()

	data := struct {
		Label      string
		BinaryPath string
		LogPath    string
	}{
		Label:      laun

func (m *launchdManager) Uninstall() error {
	if _, err := os.Stat(m.plistPath); os.IsNotExist(err) {
		return nil // not installed, nothing to do
	}

	// Unload the service
	domain := fmt.Sprintf("gui/%d/%s", os.Getuid(), launchdLabel)
	cmd := exec.Command("launchctl", "bootout", domain)
	if _, err := cmd.CombinedOutput(); err != nil {
		// Fall back to legacy unload
		cmd2 := exec.Command("launchctl", "unload", m.plistPath)
		_ = cmd2.Run()
	}

	// Remove the plist file
	if err := os.Remove(m.plistPath); err != nil && !os.IsNotExist(err) {
		return fmt.Errorf("removing plist: %w", err)
	}

	return nil
}

func (m *launchdManager) Status() (ServiceStatus, error) {
	if _, err := os.Stat(m.plistPath); os.IsNotExist(err) {
		return ServiceStatus{
			Installed: false,
			Running:   false,
			Message:   "not installed",
		}, nil
	}

	running := m.isLoaded()
	msg := "installed, stopped"
	if running {
		msg = "installed, running"
	}

	return ServiceStatus{
		Installed: true,
		Running:   running,
		Message:   msg,
	}, nil
}

func New() (Manager, error) {
	home, err := os.UserHomeDir()
	if err != nil {
		return nil, fmt.Errorf("cannot determine home directory: %w", err)
	}
	unitDir := filepath.Join(home, ".config", "systemd", "user")
	return &systemdManager{
		unitPath: filepath.Join(unitDir, "anvil.service"),
	}, nil
}

func (m *systemdManager) Install(binaryPath string) error {
	// Warn if binary looks temporary
	if strings.Contains(binaryPath, "/tmp/") || strings.Contains(binaryPath, "go-build") {
		fmt.Fprintf(os.Stderr, "warning: binary path looks temporary: %s\n", binaryPath)
		fmt.Fprintf(os.Stderr, "  install anvil to a permanent location first (e.g. go install or anvil update)\n")
	}

	// Ensure unit directory exists
	if err := os.MkdirAll(filepath.Dir(m.unitPath), 0755); err != nil {
		return fmt.Errorf("creating systemd user directory: %w", err)
	}

	// Generate unit file
	f, err := os.Create(m.unitPath)
	if err != nil {
		return fmt.Errorf("creating unit file: %w", err)
	}
	defer f.Close()

	data := struct {
		BinaryPath string
	}{
		BinaryPath: binaryPath,
	}
	if err := unitTemplate.Execute(f, data); err != nil {
		return fmt.Errorf("writing unit file: %w", err)
	}

	// Reload systemd to pick up the new unit
	if out, err := exec.Command("systemctl", "--user", "daemon-reload").CombinedOutpu

func (m *systemdManager) Uninstall() error {
	if _, err := os.Stat(m.unitPath); os.IsNotExist(err) {
		return nil // not installed
	}

	// Disable and stop the service
	_ = exec.Command("systemctl", "--user", "disable", "--now", "anvil.service").Run()

	// Remove the unit file
	if err := os.Remove(m.unitPath); err != nil && !os.IsNotExist(err) {
		return fmt.Errorf("removing unit file: %w", err)
	}

	// Reload systemd
	_ = exec.Command("systemctl", "--user", "daemon-reload").Run()

	return nil
}

func (m *systemdManager) Status() (ServiceStatus, error) {
	if _, err := os.Stat(m.unitPath); os.IsNotExist(err) {
		return ServiceStatus{
			Installed: false,
			Running:   false,
			Message:   "not installed",
		}, nil
	}

	// Check if the service is active
	cmd := exec.Command("systemctl", "--user", "is-active", "anvil.service")
	out, err := cmd.Output()
	active := err == nil && strings.TrimSpace(string(out)) == "active"

	msg := "installed, stopped"
	if active {
		msg = "installed, running"
	}

	return ServiceStatus{
		Installed: true,
		Running:   active,
		Message:   msg,
	}, nil
}

func CheckLatest() (string, error) {
	client := &http.Client{Timeout: 15 * time.Second}
	resp, err := client.Get(releaseURL)
	if err != nil {
		return "", fmt.Errorf("update check failed: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return "", fmt.Errorf("update check failed: HTTP %d", resp.StatusCode)
	}

	var release struct {
		TagName string `json:"tag_name"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
		return "", fmt.Errorf("failed to parse release info: %w", err)
	}

	if release.TagName == "" {
		return "", fmt.Errorf("no releases found")
	}

	return release.TagName, nil
}

func Rollback(backupPath string) error {
	execPath, err := os.Executable()
	if err != nil {
		return fmt.Errorf("failed to determine executable path: %w", err)
	}
	execPath, err = filepath.EvalSymlinks(execPath)
	if err != nil {
		return fmt.Errorf("failed to resolve executable path: %w", err)
	}

	if _, err := os.Stat(backupPath); err != nil {
		return fmt.Errorf("backup not found at %s: %w", backupPath, err)
	}

	return os.Rename(backupPath, execPath)
}

func copyFile(src, dst string) error {
	in, err := os.Open(src)
	if err != nil {
		return err
	}
	defer in.Close()

	out, err := os.Create(dst)
	if err != nil {
		return err
	}
	defer out.Close()

	if _, err := io.Copy(out, in); err != nil {
		return err
	}

	// Preserve executable permissions
	info, err := os.Stat(src)
	if err != nil {
		return err
	}
	return os.Chmod(dst, info.Mode())
}