feat(activity): add Activity reporting dashboard

Add a time-windowed Activity view that summarizes agent sessions: summary cards, a concurrency timeline, breakdowns by project, model, and agent with a toggle between agent-minutes and cost, a sessions table, and generated insights. Range controls move between time windows.

Split activity into automated and interactive segments, building on the existing automated-session detection, so roborev CI and other automated runs are measured separately from interactive work.

Implement the activity report query across SQLite, PostgreSQL, and DuckDB with matching shape and ordering, exposed through a huma OpenAPI route and an activity CLI subcommand.

Attribute CI worktree sessions (ci-worktrees/<repo>/...) to their owning repository instead of the per-run scratch worktree name, so CI reviews group under the repo in project breakdowns.

Author: wesm

AGENTS.md

@@ -10,7 +10,9 @@ Instructions for autonomous coding agents working in this repository.
 
 ## Required Git Rules
 
-1. Commit every turn.
+1. Commit every turn that changes tracked files.
+1. Do not make empty commits. If a turn is read-only or only changes ignored
+   files, state that no commit was made.
 1. Do not amend commits.
 1. Do not change branches without explicit user permission.
 

Makefile

@@ -245,11 +245,11 @@ test-postgres: ensure-embed-dir postgres-up
 	@echo "Waiting for postgres to be ready..."
 	@sleep 2
 	TEST_PG_URL="postgres://agentsview_test:agentsview_test_password@localhost:5433/agentsview_test?sslmode=disable" \
-		CGO_ENABLED=1 go test -tags "fts5,pgtest" -v ./internal/postgres/... -count=1
+		CGO_ENABLED=1 go test -tags "fts5,pgtest" -v ./internal/postgres/... ./internal/activity/... -count=1
 
 # PostgreSQL integration tests for CI (postgres already running as service)
 test-postgres-ci: ensure-embed-dir
-	CGO_ENABLED=1 go test -tags "fts5,pgtest" -v ./internal/postgres/... -count=1
+	CGO_ENABLED=1 go test -tags "fts5,pgtest" -v ./internal/postgres/... ./internal/activity/... -count=1
 
 # Start test SSH container
 ssh-up:

cmd/agentsview/activity.go

@@ -0,0 +1,239 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"text/tabwriter"
+	"time"
+
+	"go.kenn.io/agentsview/internal/activity"
+	"go.kenn.io/agentsview/internal/db"
+)
+
+// ActivityReportConfig holds the flags for `agentsview activity report`.
+type ActivityReportConfig struct {
+	Preset   string
+	Date     string
+	From     string
+	To       string
+	Timezone string
+	Bucket   string
+	Project  string
+	Agent    string
+	Machine  string
+	JSON     bool
+	NoSync   bool
+	Offline  bool
+}
+
+// runActivityReport syncs, resolves the range, runs the report, and prints it.
+func runActivityReport(cfg ActivityReportConfig) {
+	database, appCfg := openUsageDB()
+	defer database.Close()
+
+	ensureFreshData(appCfg, database, cfg.NoSync)
+
+	r, err := resolveActivityReportPriced(cfg, database)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		os.Exit(1)
+	}
+
+	if cfg.JSON {
+		enc := json.NewEncoder(os.Stdout)
+		enc.SetIndent("", "  ")
+		if err := enc.Encode(r); err != nil {
+			fmt.Fprintf(os.Stderr, "error: %v\n", err)
+			os.Exit(1)
+		}
+		return
+	}
+
+	printActivityReport(r)
+}
+
+// resolveActivityReportPriced seeds fallback pricing so fresh-DB token usage is
+// costed, then resolves the report. runActivityReport and the pricing test
+// share this seam so the test exercises the same seeding the command performs.
+func resolveActivityReportPriced(
+	cfg ActivityReportConfig, database *db.DB,
+) (activity.Report, error) {
+	ensurePricing(database, cfg.Offline)
+	return resolveActivityReport(cfg, database)
+}
+
+// resolveActivityReport defaults the timezone and date, resolves the range
+// query, and runs the report against the database. It is the testable seam:
+// all validation (timezone, bounds, bucket allow-list, range limits) happens
+// inside activity.ResolveQuery before any database query.
+func resolveActivityReport(
+	cfg ActivityReportConfig, database *db.DB,
+) (activity.Report, error) {
+	tz := cfg.Timezone
+	if tz == "" {
+		tz = localTimezone()
+	}
+
+	date := cfg.Date
+	if cfg.Preset != "custom" && cfg.From == "" && date == "" {
+		date = todayIn(tz)
+	}
+
+	input := activity.QueryInput{
+		Preset:         cfg.Preset,
+		Date:           date,
+		From:           cfg.From,
+		To:             cfg.To,
+		Timezone:       tz,
+		BucketOverride: cfg.Bucket,
+	}
+	q, err := activity.ResolveQuery(input, time.Now())
+	if err != nil {
+		return activity.Report{}, err
+	}
+
+	f := db.AnalyticsFilter{
+		Timezone:         tz,
+		Project:          cfg.Project,
+		Agent:            cfg.Agent,
+		Machine:          cfg.Machine,
+		ExcludeOneShot:   false,
+		ExcludeAutomated: false,
+	}
+	return database.GetActivityReport(context.Background(), f, q)
+}
+
+// todayIn returns today's date as YYYY-MM-DD in the given IANA timezone,
+// falling back to the local zone when tz is unknown.
+func todayIn(tz string) string {
+	loc, err := time.LoadLocation(tz)
+	if err != nil {
+		loc = time.Local
+	}
+	return time.Now().In(loc).Format("2006-01-02")
+}
+
+// printActivityReport renders the human-readable report: a header, totals,
+// peak concurrency, top breakdowns, and top sessions. It deliberately omits
+// the dense per-bucket timeline, which only the --json output exposes.
+func printActivityReport(r activity.Report) {
+	loc, err := time.LoadLocation(r.Timezone)
+	if err != nil {
+		loc = time.UTC
+	}
+	fmt.Printf(
+		"Activity %s to %s (%s, %s buckets)\n",
+		fmtRangeBound(r.RangeStart, loc), fmtRangeBound(r.RangeEnd, loc),
+		r.Timezone, r.BucketUnit,
+	)
+	if r.Partial {
+		fmt.Printf("Partial range, data as of %s\n", fmtInstant(r.AsOf, loc))
+	}
+	fmt.Println()
+
+	printActivityTotals(r.Totals)
+	fmt.Println()
+	printActivityPeak(r.Peak, loc)
+	fmt.Println()
+	printKeyMinutes("By project", r.ByProject)
+	printKeyMinutes("By model", r.ByModel)
+	printKeyMinutes("By agent", r.ByAgent)
+	printActivitySessions(r.BySession)
+}
+
+// printActivityTotals prints the totals block via a tabwriter.
+func printActivityTotals(t activity.Totals) {
+	w := tabwriter.NewWriter(os.Stdout, 0, 4, 2, ' ', 0)
+	fmt.Fprintf(w, "Active minutes\t%.1f\n", t.ActiveMinutes)
+	fmt.Fprintf(w, "Idle minutes\t%.1f\n", t.IdleMinutes)
+	fmt.Fprintf(w, "Agent minutes\t%.1f\n", t.AgentMinutes)
+	fmt.Fprintf(w, "Sessions\t%d (%d untimed)\n", t.Sessions, t.UntimedSessions)
+	fmt.Fprintf(w, "Distinct projects\t%d\n", t.DistinctProjects)
+	fmt.Fprintf(w, "Distinct models\t%d\n", t.DistinctModels)
+	fmt.Fprintf(w, "Output tokens\t%d\n", t.OutputTokens)
+	fmt.Fprintf(w, "Cost\t%s\n", fmtCost(t.Cost))
+	w.Flush()
+}
+
+// printActivityPeak prints peak concurrency and when it occurred, in loc.
+func printActivityPeak(p activity.Peak, loc *time.Location) {
+	fmt.Printf("Peak concurrency: %d agents at %s\n",
+		p.Agents, fmtInstant(p.At, loc))
+}
+
+// printKeyMinutes prints the top 5 rows of a key/agent-minutes breakdown.
+func printKeyMinutes(label string, rows []activity.KeyMinutes) {
+	fmt.Printf("%s (top 5):\n", label)
+	if len(rows) == 0 {
+		fmt.Println("  (none)")
+		fmt.Println()
+		return
+	}
+	w := tabwriter.NewWriter(os.Stdout, 0, 4, 2, ' ', 0)
+	for _, row := range topKeyMinutes(rows, 5) {
+		fmt.Fprintf(w, "  %s\t%.1f min\n", row.Key, row.AgentMinutes)
+	}
+	w.Flush()
+	fmt.Println()
+}
+
+// printActivitySessions prints the top 5 sessions by appearance order.
+func printActivitySessions(rows []activity.SessionRow) {
+	fmt.Println("Top sessions (top 5):")
+	if len(rows) == 0 {
+		fmt.Println("  (none)")
+		return
+	}
+	w := tabwriter.NewWriter(os.Stdout, 0, 4, 2, ' ', 0)
+	fmt.Fprintln(w, "  TITLE\tPROJECT\tAGENT\tMINUTES\tCOST")
+	limit := min(len(rows), 5)
+	for _, s := range rows[:limit] {
+		fmt.Fprintf(w, "  %s\t%s\t%s\t%s\t%s\n",
+			s.Title, s.Project, s.Agent,
+			fmtMinutes(s.AgentMinutes), fmtCost(s.Cost),
+		)
+	}
+	w.Flush()
+}
+
+// topKeyMinutes returns the first n rows of rows (already sorted by the query).
+func topKeyMinutes(rows []activity.KeyMinutes, n int) []activity.KeyMinutes {
+	return rows[:min(len(rows), n)]
+}
+
+// fmtRangeBound renders an RFC3339 range bound in loc, dropping the time
+// component when the local wall time is exactly midnight.
+func fmtRangeBound(ts string, loc *time.Location) string {
+	t, err := time.Parse(time.RFC3339, ts)
+	if err != nil {
+		return ts
+	}
+	t = t.In(loc)
+	if t.Hour() == 0 && t.Minute() == 0 && t.Second() == 0 {
+		return t.Format("2006-01-02")
+	}
+	return t.Format("2006-01-02 15:04")
+}
+
+// fmtMinutes renders an agent-minutes value, printing a dash for untimed
+// sessions whose pointer is nil.
+func fmtMinutes(m *float64) string {
+	if m == nil {
+		return "—"
+	}
+	return fmt.Sprintf("%.1f", *m)
+}
+
+// fmtInstant renders a nullable RFC3339 instant in loc as "YYYY-MM-DD HH:MM",
+// printing a dash when nil.
+func fmtInstant(ts *string, loc *time.Location) string {
+	if ts == nil {
+		return "—"
+	}
+	if t, err := time.Parse(time.RFC3339, *ts); err == nil {
+		return t.In(loc).Format("2006-01-02 15:04")
+	}
+	return *ts
+}