feat(T1.2): implement structured logging and Prometheus metrics

- Add internal/logging package with zap-based structured JSON logging
- Support development (colored) and production (JSON) modes via ENVIRONMENT env var
- Add logging helpers: Info(), Error(), Warn(), Debug(), Fatal()
- Add field helpers: String(), Int(), Int64(), Err()
- Add internal/metrics package with 16 comprehensive Prometheus metrics
- Track workflows: starts, completions, duration by type/status
- Track activities: starts, completions, duration, retries by type
- Track LLM calls: total calls and latency by model
- Track git operations: total and duration by operation type
- Track judge decisions: decisions by type
- Track Temporal errors: connection errors by type
- Track cache efficiency: hits and misses by cache type
- Track tasks in progress: gauge metric by task type
- Metrics exported on /metrics endpoint (Prometheus text format)
- Integrate structured logging in cmd/worker and cmd/starter
- Replace all log.Printf/log.Fatalf with structured logging
- Add /metrics endpoint to health check server
- 8/8 logging tests passing, 13/13 metrics tests passing
- All verification criteria met

Dependencies added:
- go.uber.org/zap v1.28.0 (structured logging)
- github.com/prometheus/client_golang v1.24.1 (metrics export)

Closes T1.2

cmd/starter/main.go

@@ -11,6 +11,7 @@ import (
 	"go.temporal.io/sdk/client"
 	"github.com/rockliang/poimen/workflows/internal/config"
 	"github.com/rockliang/poimen/workflows/internal/health"
+	"github.com/rockliang/poimen/workflows/internal/logging"
 	"github.com/rockliang/poimen/workflows/statemachine"
 )
 
@@ -27,37 +28,45 @@ func main() {
 	)
 	flag.Parse()
 
+	// Initialize structured logging
+	if err := logging.InitLogger(); err != nil {
+		log.Fatalf("failed to initialize logger: %v", err)
+	}
+	defer logging.Sync()
+
 	// Load configuration first
 	cfg, err := config.LoadConfig()
 	if err != nil {
-		log.Fatalf("failed to load config: %v", err)
+		logging.Fatal("failed to load config", logging.Err(err))
 	}
 
 	// Connect to Temporal
+	logging.Info("connecting to Temporal", logging.String("hostPort", cfg.Temporal.HostPort), logging.String("namespace", cfg.Temporal.Namespace))
 	c, err := client.Dial(client.Options{
 		HostPort:  cfg.Temporal.HostPort,
 		Namespace: cfg.Temporal.Namespace,
 	})
 	if err != nil {
-		log.Fatalf("failed to connect to temporal: %v", err)
+		logging.Fatal("failed to connect to temporal", logging.Err(err))
 	}
 	defer c.Close()
 
 	// If health check requested, do it and exit
 	if *healthCheck {
+		logging.Info("running health check")
 		healthChecker := health.NewChecker(c)
 		report := healthChecker.Check(context.Background())
 		jsonReport, _ := report.ToJSON()
 		fmt.Println(string(jsonReport))
 		if report.Status != health.StatusHealthy {
-			log.Fatalf("health check failed")
+			logging.Fatal("health check failed")
 		}
 		return
 	}
 
 	// Validate required flags for workflow start
 	if *repoPath == "" || *remoteURL == "" {
-		log.Fatalf("--repo and --remote flags are required")
+		logging.Fatal("--repo and --remote flags are required")
 	}
 
 
@@ -102,12 +111,13 @@ func main() {
 
 	// Start workflow
 	workflowID := "orch-" + strings.ReplaceAll(*repoPath, "/", "-")
+	logging.Info("starting orchestrator workflow", logging.String("workflowID", workflowID), logging.String("repo", *repoPath))
 	run, err := c.ExecuteWorkflow(context.Background(), client.StartWorkflowOptions{
 		ID:        workflowID,
 		TaskQueue: "poimen-taskqueue",
 	}, statemachine.OrchestratorWorkflow, input)
 	if err != nil {
-		log.Fatalf("failed to start workflow: %v", err)
+		logging.Fatal("failed to start workflow", logging.Err(err))
 	}
 
 	fmt.Printf("\n=== Workflow Started ===\n")