Function bodies 82 total

func gatherTiming(artifactsDir, phaseName string) string {
	timing, err := state.LoadTiming(artifactsDir)
	if err != nil {
		return ""
	}
	var parts []string
	for _, e := range timing.Entries {
		if e.Phase != phaseName {
			continue
		}
		if e.Duration != "" {
			parts = append(parts, fmt.Sprintf("%s started %s, duration %s",
				e.Phase, e.Start.Format("15:04:05"), e.Duration))
		} else {
			parts = append(parts, fmt.Sprintf("%s started %s (did not complete)",
				e.Phase, e.Start.Format("15:04:05")))
		}
	}
	return strings.Join(parts, "; ")
}

func gatherLoopCounts(artifactsDir string) string {
	counts, err := state.LoadLoopCounts(artifactsDir)
	if err != nil {
		return ""
	}
	if len(counts) == 0 {
		return ""
	}
	var parts []string
	for k, v := range counts {
		parts = append(parts, fmt.Sprintf("%s=%d", k, v))
	}
	return strings.Join(parts, ", ")
}

func filteredEnv() []string {
	var env []string
	for _, e := range os.Environ() {
		key := strings.SplitN(e, "=", 2)[0]
		if strings.HasPrefix(key, "CLAUDECODE") {
			continue
		}
		env = append(env, e)
	}
	return env
}

func runClaude(ctx context.Context, prompt string) error {
	cmd := exec.CommandContext(ctx, "claude", "-p", prompt, "--model", "opus")
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	cmd.Env = filteredEnv()
	return cmd.Run()
}

func Parse(text string) []FileBlock {
	lines := strings.Split(text, "\n")
	var blocks []FileBlock
	var current *FileBlock
	var buf strings.Builder

	for _, line := range lines {
		if current != nil {
			// Inside a block — look for closing fence
			trimmed := strings.TrimSpace(line)
			if trimmed == "```" {
				current.Content = buf.String()
				blocks = append(blocks, *current)
				current = nil
				buf.Reset()
				continue
			}
			if buf.Len() > 0 {
				buf.WriteByte('\n')
			}
			buf.WriteString(line)
			continue
		}

		// Not inside a block — look for opening fence with file=
		m := fenceOpenRe.FindStringSubmatch(strings.TrimSpace(line))
		if m != nil {
			current = &FileBlock{Path: m[1]}
			buf.Reset()
		}
	}

	return blocks
}

func (r *Runner) failAndHint(status string, err error) error {
	r.State.Status = status
	if saveErr := r.State.Save(r.Env.ArtifactsDir); saveErr != nil {
		fmt.Fprintf(os.Stderr, "warning: failed to save state: %v\n", saveErr)
	}
	if r.Timing != nil {
		if flushErr := r.Timing.Flush(r.Env.ArtifactsDir); flushErr != nil {
			fmt.Fprintf(os.Stderr, "warning: failed to flush timing: %v\n", flushErr)
		}
	}
	ux.ResumeHint(r.State.Ticket)
	return err
}

func (r *Runner) Run(ctx context.Context) error {
	if err := state.EnsureDir(r.Env.ArtifactsDir); err != nil {
		return err
	}

	loopCounts, err := state.LoadLoopCounts(r.Env.ArtifactsDir)
	if err != nil {
		return fmt.Errorf("loading loop counts: %w", err)
	}

	timing, err := state.LoadTiming(r.Env.ArtifactsDir)
	if err != nil {
		return fmt.Errorf("loading timing: %w", err)
	}
	r.Timing = timing

	total := len(r.Config.Phases)

	for r.State.PhaseIndex < total {
		i := r.State.PhaseIndex
		phase := r.Config.Phases[i]

		// Check for context cancellation
		if ctx.Err() != nil {
			return r.failAndHint(state.StatusInterrupted, ctx.Err())
		}

		// Evaluate condition
		if phase.Condition != "" {
			if !evalCondition(ctx, phase, r.Env) {
				ux.PhaseSkip(i, phase.Name)
				r.State.Advance()
				if err := r.State.Save(r.Env.ArtifactsDir); err != nil {
					return fmt.Errorf("saving state after skip: %w", err)
				}
				continue
			}
		}

		// Handle parallel-with
		if phase.ParallelWith !=

func (r *Runner) DryRunPrint() {
	total := len(r.Config.Phases)
	fmt.Printf("\n%sDry run — %d phases:%s\n\n", ux.Bold, total, ux.Reset)

	if len(r.Env.CustomVars) > 0 {
		fmt.Printf("  %sVars:%s\n", ux.Bold, ux.Reset)
		keys := make([]string, 0, len(r.Env.CustomVars))
		for k := range r.Env.CustomVars {
			keys = append(keys, k)
		}
		sort.Strings(keys)
		for _, k := range keys {
			fmt.Printf("    %s = %s\n", k, r.Env.CustomVars[k])
		}
		fmt.Println()
	}

	for i, p := range r.Config.Phases {
		fmt.Printf("  %s%d.%s %s%s%s (%s)", ux.Cyan, i+1, ux.Reset, ux.Bold, p.Name, ux.Reset, p.Type)
		if p.Description != "" {
			fmt.Printf(" — %s", p.Description)
		}
		fmt.Println()

		switch p.Type {
		case "script":
			expanded := dispatch.ExpandVars(p.Run, r.Env.Vars())
			fmt.Printf("     run: %s\n", expanded)
		case "agent":
			fmt.Printf("     prompt: %s\n", p.Prompt)
			fmt.Printf("     model: %s, timeout: %dm\n", p.Model, p.Timeout)
			if len(p.AllowTools) > 0 {
				fmt.Printf("     allow

func (r *Runner) runParallel(parentCtx context.Context, idx1, idx2, total int, loopCounts map[string]int) error {
	phase1 := r.Config.Phases[idx1]
	phase2 := r.Config.Phases[idx2]

	ux.PhaseHeader(idx1, total, phase1)
	ux.PhaseHeader(idx2, total, phase2)

	r.Timing.AddStart(phase1.Name)
	r.Timing.AddStart(phase2.Name)

	ctx, cancel := context.WithCancel(parentCtx)
	defer cancel()

	type phaseResult struct {
		idx    int
		result *dispatch.Result
		err    error
	}

	results := make(chan phaseResult, 2)
	var wg sync.WaitGroup
	wg.Add(2)

	start := time.Now()

	go func() {
		defer wg.Done()
		env1 := r.Env.Clone()
		env1.PhaseIndex = idx1
		res, err := r.Dispatcher.Dispatch(ctx, phase1, env1)
		results <- phaseResult{idx: idx1, result: res, err: err}
	}()

	go func() {
		defer wg.Done()
		env2 := r.Env.Clone()
		env2.PhaseIndex = idx2
		res, err := r.Dispatcher.Dispatch(ctx, phase2, env2)
		results <- phaseResult{idx: idx2, result: res, err: err}
	}()

	// Wait for both to complete
	go fu

func evalCondition(ctx context.Context, phase config.Phase, env *dispatch.Environment) bool {
	expanded := dispatch.ExpandVars(phase.Condition, env.Vars())
	cmd := exec.CommandContext(ctx, "bash", "-c", expanded)
	cmd.Dir = dispatch.PhaseWorkDir(phase, env)
	cmd.Env = dispatch.BuildEnv(env)
	return cmd.Run() == nil
}

func Init(ctx context.Context, targetDir string) error {
	orcDir := filepath.Join(targetDir, ".orc")
	if _, err := os.Stat(orcDir); err == nil {
		return fmt.Errorf(".orc directory already exists in %s", targetDir)
	}

	return initWithAI(ctx, targetDir)
}

func initWithAI(ctx context.Context, targetDir string) error {
	fmt.Printf("\n  %sAnalyzing project...%s\n", ux.Dim, ux.Reset)

	pc, err := contextgather.Gather(targetDir)
	if err != nil {
		return fmt.Errorf("gathering context: %w", err)
	}

	prompt := buildInitPrompt(pc.Render())

	fmt.Printf("  %sGenerating workflow config...%s\n", ux.Dim, ux.Reset)

	output, err := runClaudeCapture(ctx, prompt)
	if err != nil {
		return err
	}

	blocks := fileblocks.Parse(output)
	if len(blocks) == 0 {
		return fmt.Errorf("no file blocks in claude output")
	}

	// Validate that we got a config.yaml
	hasConfig := false
	for _, b := range blocks {
		if b.Path == ".orc/config.yaml" {
			hasConfig = true
		}
	}
	if !hasConfig {
		return fmt.Errorf("claude output missing .orc/config.yaml")
	}

	// Create directories and write files
	var written []string
	for _, b := range blocks {
		if !strings.HasPrefix(b.Path, ".orc/") {
			continue // security: only write inside .orc/
		}

		fullPath := filepath.Join

func runClaudeCapture(ctx context.Context, prompt string) (string, error) {
	cmd := exec.CommandContext(ctx, "claude", "-p", prompt, "--model", "opus")
	var stdout bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = os.Stderr
	cmd.Env = filteredEnv()
	if err := cmd.Run(); err != nil {
		return "", fmt.Errorf("claude: %w", err)
	}
	return stdout.String(), nil
}

func filteredEnv() []string {
	var env []string
	for _, e := range os.Environ() {
		key := strings.SplitN(e, "=", 2)[0]
		if strings.HasPrefix(key, "CLAUDECODE") {
			continue
		}
		env = append(env, e)
	}
	return env
}

func renderWorkflowSummary(phases []config.Phase) string {
	// Build map of parallel partners: the "earlier" phase -> "earlier ∥ later"
	parallelOf := make(map[string]string)
	skipSelf := make(map[string]bool)
	for _, p := range phases {
		if p.ParallelWith != "" {
			parallelOf[p.ParallelWith] = fmt.Sprintf("%s ∥ %s", p.ParallelWith, p.Name)
			skipSelf[p.Name] = true
		}
	}

	var parts []string
	for _, p := range phases {
		if skipSelf[p.Name] {
			continue
		}
		if group, ok := parallelOf[p.Name]; ok {
			parts = append(parts, group)
		} else {
			parts = append(parts, p.Name)
		}
	}
	return strings.Join(parts, " → ")
}

func EnsureDir(artifactsDir string) error {
	dirs := []string{
		artifactsDir,
		filepath.Join(artifactsDir, "prompts"),
		filepath.Join(artifactsDir, "logs"),
		filepath.Join(artifactsDir, "feedback"),
	}
	for _, d := range dirs {
		if err := os.MkdirAll(d, 0755); err != nil {
			return fmt.Errorf("creating artifacts dir %s: %w", d, err)
		}
	}
	return nil
}

func LoadLoopCounts(artifactsDir string) (map[string]int, error) {
	path := filepath.Join(artifactsDir, "loop-counts.json")
	data, err := os.ReadFile(path)
	if err != nil {
		if errors.Is(err, fs.ErrNotExist) {
			return make(map[string]int), nil
		}
		return nil, err
	}
	var counts map[string]int
	if err := json.Unmarshal(data, &counts); err != nil {
		return nil, err
	}
	return counts, nil
}

func SaveLoopCounts(artifactsDir string, counts map[string]int) error {
	data, err := json.MarshalIndent(counts, "", "  ")
	if err != nil {
		return err
	}
	return writeFileAtomic(filepath.Join(artifactsDir, "loop-counts.json"), data, 0644)
}

func CheckOutputs(artifactsDir string, outputs []string) []string {
	var missing []string
	for _, o := range outputs {
		path := filepath.Join(artifactsDir, o)
		if _, err := os.Stat(path); err != nil {
			missing = append(missing, o)
		}
	}
	return missing
}

func writeFileAtomic(path string, data []byte, perm os.FileMode) error {
	tmp := path + ".tmp"
	f, err := os.OpenFile(tmp, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
	if err != nil {
		return err
	}
	if _, err := f.Write(data); err != nil {
		f.Close()
		os.Remove(tmp)
		return err
	}
	if err := f.Sync(); err != nil {
		f.Close()
		os.Remove(tmp)
		return err
	}
	if err := f.Close(); err != nil {
		os.Remove(tmp)
		return err
	}
	if err := os.Rename(tmp, path); err != nil {
		os.Remove(tmp)
		return err
	}
	return nil
}

func Load(artifactsDir string) (*State, error) {
	path := statePath(artifactsDir)
	data, err := os.ReadFile(path)
	if err != nil {
		if errors.Is(err, fs.ErrNotExist) {
			return &State{Status: StatusRunning}, nil
		}
		return nil, err
	}
	var s State
	if err := json.Unmarshal(data, &s); err != nil {
		return nil, err
	}
	return &s, nil
}

func (s *State) Save(artifactsDir string) error {
	data, err := json.MarshalIndent(s, "", "  ")
	if err != nil {
		return err
	}
	return writeFileAtomic(statePath(artifactsDir), data, 0644)
}

func LoadTiming(artifactsDir string) (*Timing, error) {
	path := timingPath(artifactsDir)
	data, err := os.ReadFile(path)
	if err != nil {
		if errors.Is(err, fs.ErrNotExist) {
			return &Timing{}, nil
		}
		return nil, err
	}
	var t Timing
	if err := json.Unmarshal(data, &t); err != nil {
		return nil, err
	}
	return &t, nil
}

func (t *Timing) save(artifactsDir string) error {
	data, err := json.MarshalIndent(t, "", "  ")
	if err != nil {
		return err
	}
	return writeFileAtomic(timingPath(artifactsDir), data, 0644)
}

func (t *Timing) AddStart(phaseName string) {
	t.mu.Lock()
	defer t.mu.Unlock()
	t.Entries = append(t.Entries, TimingEntry{
		Phase: phaseName,
		Start: time.Now(),
	})
}

func (t *Timing) AddEnd(phaseName string) {
	t.mu.Lock()
	defer t.mu.Unlock()
	for i := len(t.Entries) - 1; i >= 0; i-- {
		if t.Entries[i].Phase == phaseName && t.Entries[i].End.IsZero() {
			t.Entries[i].End = time.Now()
			d := t.Entries[i].End.Sub(t.Entries[i].Start)
			t.Entries[i].Duration = formatDuration(d)
			break
		}
	}
}

func PhaseHeader(index, total int, phase config.Phase) {
	fmt.Printf("\n%s[%s]%s %s══════════════════════════════════════%s\n",
		Dim, timestamp(), Reset, Cyan, Reset)
	desc := ""
	if phase.Description != "" {
		desc = fmt.Sprintf(" — %s", phase.Description)
	}
	fmt.Printf("%s[%s]%s  %sPhase %d/%d: %s (%s)%s%s\n",
		Dim, timestamp(), Reset, Bold, index+1, total, phase.Name, phase.Type, desc, Reset)
	fmt.Printf("%s[%s]%s %s══════════════════════════════════════%s\n",
		Dim, timestamp(), Reset, Cyan, Reset)
}

func PhaseComplete(index int, duration time.Duration) {
	m := int(duration.Minutes())
	s := int(duration.Seconds()) % 60
	fmt.Printf("%s[%s]%s  %s✓ Phase %d complete (%dm %02ds)%s\n",
		Dim, timestamp(), Reset, Green, index+1, m, s, Reset)
}

func ToolUse(name, input string) {
	summary := input
	if len(summary) > 80 {
		summary = summary[:77] + "..."
	}
	fmt.Printf("  %s⚡ %s%s %s\n", Cyan, name, Reset, summary)
}

func ToolDenied(name, input string) {
	summary := input
	if len(summary) > 80 {
		summary = summary[:77] + "..."
	}
	fmt.Printf("  %s✗ %s(denied)%s %s\n", Red, name, Reset, summary)
}

func RenderStatus(cfg *config.Config, st *state.State, artifactsDir string) {
	timing, _ := state.LoadTiming(artifactsDir)

	// Header
	fmt.Printf("%sTicket:%s  %s\n", Bold, Reset, st.Ticket)
	if st.PhaseIndex >= len(cfg.Phases) {
		fmt.Printf("%sState:%s   %s%scompleted%s\n", Bold, Reset, Green, Bold, Reset)
	} else {
		phase := cfg.Phases[st.PhaseIndex]
		fmt.Printf("%sState:%s   %d/%d (%s) — %s\n",
			Bold, Reset, st.PhaseIndex+1, len(cfg.Phases), phase.Name, st.Status)
	}

	// Completed phases
	if st.PhaseIndex > 0 {
		fmt.Printf("\n%sCompleted:%s\n", Bold, Reset)
		for i := 0; i < st.PhaseIndex && i < len(cfg.Phases); i++ {
			p := cfg.Phases[i]
			dur := findDuration(timing, p.Name)
			fmt.Printf("  %s%d%s  %-20s %sdone%s  %s\n",
				Dim, i+1, Reset, p.Name, Green, Reset, dur)
		}
	}

	// Remaining phases
	if st.PhaseIndex < len(cfg.Phases) {
		fmt.Printf("\n%sRemaining:%s\n", Bold, Reset)
		for i := st.PhaseIndex; i < len(cfg.Phases); i++ {
			p := cfg.Phases[i]
			marker := "  

func findDuration(timing *state.Timing, phaseName string) string {
	if timing == nil {
		return ""
	}
	for i := len(timing.Entries) - 1; i >= 0; i-- {
		if timing.Entries[i].Phase == phaseName && timing.Entries[i].Duration != "" {
			return fmt.Sprintf("(%s)", timing.Entries[i].Duration)
		}
	}
	return ""
}