feat(pb): colorize pretty log output

- colorize pretty log labels, event types, issue IDs, and detail values
- keep table/json output uncolored; add colorized log test coverage
- stabilize pretty log tests by disabling color for assertions

Refs: pb-3ee

Regeneration-Prompt: |
  Add ANSI color styling to `pb log` pretty output only (not table/json),
  respecting NO_COLOR/PB_NO_COLOR and existing colorEnabled logic. Use
  distinct colors for event types and issue IDs, dim field labels, and
  reuse existing status/priority/type color rules for detail values.
  Update pretty log tests to be deterministic regardless of TTY, and add
  a color-enabled test to assert ANSI codes appear in output.

Author: jalehman

.pebbles/events.jsonl

@@ -231,3 +231,5 @@
 {"type":"close","timestamp":"2026-01-19T23:14:04.98486Z","issue_id":"pb-9d7","payload":{}}
 {"type":"close","timestamp":"2026-01-19T23:14:09.877599Z","issue_id":"pb-d59","payload":{}}
 {"type":"close","timestamp":"2026-01-19T23:14:16.391561Z","issue_id":"pb-fc0","payload":{}}
+{"type":"status_update","timestamp":"2026-01-19T22:46:23.832916Z","issue_id":"pb-3ee","payload":{"status":"in_progress"}}
+{"type":"close","timestamp":"2026-01-19T22:52:26.673547Z","issue_id":"pb-3ee","payload":{}}

cmd/pb/log.go

@@ -512,25 +512,93 @@ func formatPayloadValue(key, value string) string {
 	return value
 }
 
+// logEventTypeColor returns the ANSI color for a log event label.
+func logEventTypeColor(eventType string) string {
+	// Keep event colors distinct so each log entry is easy to scan.
+	switch strings.ToLower(eventType) {
+	case "create":
+		return ansiBrightBlue
+	case "status":
+		return ansiBrightYellow
+	case "close":
+		return ansiBrightGreen
+	case "comment":
+		return ansiBrightMagenta
+	case "dep_add":
+		return ansiCyan
+	case "dep_rm":
+		return ansiRed
+	default:
+		return ansiYellow
+	}
+}
+
+// renderLogEventType returns a colored event label when enabled.
+func renderLogEventType(eventType string) string {
+	return colorize(eventType, logEventTypeColor(eventType))
+}
+
+// renderLogLabel applies muted styling to log field labels.
+func renderLogLabel(label string) string {
+	return colorize(label, ansiDim+ansiGray)
+}
+
+// renderLogIssueID returns a colored issue ID for log output.
+func renderLogIssueID(issueID string) string {
+	return colorize(issueID, ansiCyan)
+}
+
+// renderLogDetail formats a log detail key/value with ANSI styling.
+func renderLogDetail(detail string) string {
+	parts := strings.SplitN(detail, "=", 2)
+	if len(parts) != 2 {
+		return detail
+	}
+	key := parts[0]
+	value := parts[1]
+	return renderLogLabel(key) + "=" + renderLogDetailValue(key, value)
+}
+
+// renderLogDetailValue returns a colored detail value when enabled.
+func renderLogDetailValue(key, value string) string {
+	// Use existing list/show color rules for known detail values.
+	switch key {
+	case "status":
+		return renderStatusValue(value)
+	case "priority":
+		priority, err := pebbles.ParsePriority(value)
+		if err != nil {
+			return value
+		}
+		return renderPriorityLabel(priority)
+	case "type":
+		return renderIssueType(value)
+	case "depends_on":
+		return renderLogIssueID(value)
+	default:
+		return value
+	}
+}
+
 // formatPrettyLog renders a multi-line log entry for humans.
 func formatPrettyLog(entry logEntry, line logLine) string {
 	var output strings.Builder
 	// Header line includes the log line number, event type, and issue id.
-	output.WriteString(fmt.Sprintf("event %d %s %s\n", entry.Entry.Line, line.EventType, line.IssueID))
+	output.WriteString(fmt.Sprintf("%s %d %s %s\n", renderLogLabel("event"), entry.Entry.Line, renderLogEventType(line.EventType), renderLogIssueID(line.IssueID)))
 	// Add core metadata lines with aligned labels.
-	output.WriteString(fmt.Sprintf("Title: %s\n", line.IssueTitle))
-	output.WriteString(fmt.Sprintf("When:  %s\n", line.EventTime))
-	output.WriteString(fmt.Sprintf("Actor: %s (%s)\n", line.Actor, line.ActorDate))
+	output.WriteString(fmt.Sprintf("%s %s\n", renderLogLabel("Title:"), colorize(line.IssueTitle, ansiBold)))
+	output.WriteString(fmt.Sprintf("%s  %s\n", renderLogLabel("When:"), line.EventTime))
+	output.WriteString(fmt.Sprintf("%s %s (%s)\n", renderLogLabel("Actor:"), line.Actor, line.ActorDate))
 	// Render payload details with indentation or an explicit none marker.
 	details := logEventDetailLines(entry.Entry.Event)
 	if len(details) == 0 {
-		output.WriteString("Details: (none)")
+		output.WriteString(fmt.Sprintf("%s %s", renderLogLabel("Details:"), renderLogLabel("(none)")))
 		return output.String()
 	}
-	output.WriteString("Details:\n")
+	output.WriteString(fmt.Sprintf("%s\n", renderLogLabel("Details:")))
 	for index, detail := range details {
 		output.WriteString("  ")
-		output.WriteString(detail)
+		output.WriteString(renderLogDetail(detail))
 		if index < len(details)-1 {
 			output.WriteString("\n")
 		}

cmd/pb/log_test.go

@@ -182,6 +182,12 @@ func TestParseGitBlame(t *testing.T) {
 
 // TestFormatPrettyLogWithDetails ensures pretty output includes details lines.
 func TestFormatPrettyLogWithDetails(t *testing.T) {
+	previous := colorEnabled
+	colorEnabled = false
+	defer func() {
+		colorEnabled = previous
+	}()
+
 	entry := logEntry{
 		Entry: pebbles.EventLogEntry{
 			Line:  5,
@@ -209,6 +215,12 @@ func TestFormatPrettyLogWithDetails(t *testing.T) {
 
 // TestFormatPrettyLogNoDetails ensures empty payloads show (none).
 func TestFormatPrettyLogNoDetails(t *testing.T) {
+	previous := colorEnabled
+	colorEnabled = false
+	defer func() {
+		colorEnabled = previous
+	}()
+
 	entry := logEntry{
 		Entry: pebbles.EventLogEntry{
 			Line:  2,
@@ -229,6 +241,42 @@ func TestFormatPrettyLogNoDetails(t *testing.T) {
 	}
 }
 
+// TestFormatPrettyLogColors verifies ANSI styling is applied when enabled.
+func TestFormatPrettyLogColors(t *testing.T) {
+	previous := colorEnabled
+	colorEnabled = true
+	defer func() {
+		colorEnabled = previous
+	}()
+
+	entry := logEntry{
+		Entry: pebbles.EventLogEntry{
+			Line:  7,
+			Event: pebbles.Event{Type: pebbles.EventTypeCreate, IssueID: "pb-9", Payload: map[string]string{"type": "task", "priority": "1"}},
+		},
+		ParsedTime: time.Date(2026, 1, 19, 10, 0, 0, 0, time.UTC),
+		ParsedOK:   true,
+	}
+	line := logLine{
+		Actor:      "Josh",
+		ActorDate:  "2026-01-19",
+		EventTime:  "2026-01-19 10:00:00",
+		EventType:  "create",
+		IssueID:    "pb-9",
+		IssueTitle: "Pretty Log",
+	}
+	output := formatPrettyLog(entry, line)
+	if !strings.Contains(output, ansiBrightBlue) {
+		t.Fatalf("expected event type color in output: %q", output)
+	}
+	if !strings.Contains(output, ansiCyan) {
+		t.Fatalf("expected issue id color in output: %q", output)
+	}
+	if !strings.Contains(output, ansiBold) {
+		t.Fatalf("expected title color in output: %q", output)
+	}
+}
+
 // TestShouldUsePager verifies pager selection logic.
 func TestShouldUsePager(t *testing.T) {
 	if shouldUsePager(true, true) {