Skip no day when Basecamp's date is ahead of this machine's

The feed's undated request reads today in the person's Basecamp time zone,
and the dated walk began at yesterday on this machine. When Basecamp's
date was a day ahead, the machine's today was never read. The walk now
begins at the machine's today; when the dates agree that day comes back
twice, which the seen-set already absorbs, at one extra request for a
quiet account.

`timeline` without --date had the same gap in its breadcrumb, which named
the machine's yesterday. Undated, the CLI can't know Basecamp's today, so
the breadcrumb now offers `--date <YYYY-MM-DD>`; with --date it still names
the exact day before.

Author: robzolkos

internal/commands/timeline.go

@@ -150,21 +150,23 @@ func runTimeline(cmd *cobra.Command, args []string, project, person, date string
 		return convertSDKError(err)
 	}
 
+	// Undated, the day is today in the person's Basecamp time zone, which
+	// this machine's clock can't name, so neither can the day before it.
 	summary := fmt.Sprintf("%d events today", len(result.Events))
-	previous := basecamp.DateOf(time.Now().AddDate(0, 0, -1))
+	earlier := output.Breadcrumb{Action: "earlier", Cmd: "basecamp timeline --date <YYYY-MM-DD>", Description: "View an earlier day"}
 	if !day.IsZero() {
 		summary = fmt.Sprintf("%d events on %s", len(result.Events), day)
-		previous = basecamp.DateOf(day.In(time.Local).AddDate(0, 0, -1))
+		earlier = output.Breadcrumb{
+			Action:      "previous",
+			Cmd:         fmt.Sprintf("basecamp timeline --date %s", basecamp.DateOf(day.In(time.Local).AddDate(0, 0, -1))),
+			Description: "View the day before",
+		}
 	}
 
 	respOpts := []output.ResponseOption{
 		output.WithSummary(summary),
 		output.WithBreadcrumbs(
-			output.Breadcrumb{
-				Action:      "previous",
-				Cmd:         fmt.Sprintf("basecamp timeline --date %s", previous),
-				Description: "View the day before",
-			},
+			earlier,
 			output.Breadcrumb{
 				Action:      "project",
 				Cmd:         "basecamp timeline --in <project>",

internal/commands/timeline_test.go

@@ -1,6 +1,8 @@
 package commands
 
 import (
+	"bytes"
+	"encoding/json"
 	"errors"
 	"io"
 	"net/http"
@@ -28,6 +30,18 @@ func (p *progressTransport) RoundTrip(req *http.Request) (*http.Response, error)
 	return &http.Response{StatusCode: http.StatusOK, Header: header, Body: io.NopCloser(strings.NewReader(`[]`)), Request: req}, nil
 }
 
+func firstBreadcrumb(t *testing.T, buf *bytes.Buffer) string {
+	t.Helper()
+	var envelope struct {
+		Breadcrumbs []struct {
+			Cmd string `json:"cmd"`
+		} `json:"breadcrumbs"`
+	}
+	require.NoError(t, json.Unmarshal(buf.Bytes(), &envelope))
+	require.NotEmpty(t, envelope.Breadcrumbs)
+	return envelope.Breadcrumbs[0].Cmd
+}
+
 func TestTimelineDateReadsThatDay(t *testing.T) {
 	transport := &progressTransport{}
 	app, buf := newTestAppWithTransport(t, transport)
@@ -37,17 +51,21 @@ func TestTimelineDateReadsThatDay(t *testing.T) {
 
 	require.Len(t, transport.queries, 1)
 	assert.Equal(t, "2026-08-30", transport.queries[0].Get("date"))
-	assert.Contains(t, buf.String(), "basecamp timeline --date 2026-08-29")
+	assert.Equal(t, "basecamp timeline --date 2026-08-29", firstBreadcrumb(t, buf))
 }
 
 func TestTimelineWithoutDateReadsToday(t *testing.T) {
 	transport := &progressTransport{}
-	app, _ := newTestAppWithTransport(t, transport)
+	app, buf := newTestAppWithTransport(t, transport)
+	app.Flags.Hints = true
 
 	require.NoError(t, executeCommand(NewTimelineCmd(), app))
 
 	require.Len(t, transport.queries, 1)
 	assert.False(t, transport.queries[0].Has("date"))
+	// Undated, the day is Basecamp's today, which this machine's clock can't
+	// name, so the breadcrumb can't name the day before it either.
+	assert.Equal(t, "basecamp timeline --date <YYYY-MM-DD>", firstBreadcrumb(t, buf))
 }
 
 func TestTimelineDateRefusals(t *testing.T) {

internal/tui/workspace/data/hub_global.go

@@ -608,22 +608,24 @@ func (h *Hub) Timeline() *Pool[[]TimelineEventInfo] {
 // timelineFeedSize is how many events the activity feed shows.
 const timelineFeedSize = 80
 
-// timelineLookbackDays is how many days a quiet account's feed reads back.
+// timelineLookbackDays is how many days, today included, a quiet account's
+// feed reads.
 const timelineLookbackDays = 7
 
 // fetchTimelineEvents fetches timeline events from a single account.
 // Basecamp serves the activity feed one day per request, so this asks for
-// today (undated, so in the person's Basecamp time zone) and then steps back
-// a day at a time from yesterday on this machine until the feed is full.
-// When the two time zones disagree on the date a day can come back twice,
-// so an event already seen is skipped.
+// today undated, which is today in the person's Basecamp time zone, then
+// steps back a day at a time from today on this machine until the feed is
+// full. Starting the dated walk at this machine's today, not yesterday, keeps
+// a day from being skipped when Basecamp's date is ahead; when the dates
+// agree that day comes back twice, so an event already seen is skipped.
 func fetchTimelineEvents(ctx context.Context, client *basecamp.AccountClient, acct AccountInfo) ([]TimelineEventInfo, error) {
 	var events []basecamp.TimelineEvent
 	seen := make(map[int64]bool)
 	today := hubNow()
-	for back := 0; back < timelineLookbackDays && len(events) < timelineFeedSize; back++ {
+	for back := -1; back < timelineLookbackDays && len(events) < timelineFeedSize; back++ {
 		opts := &basecamp.ProgressOptions{Limit: timelineFeedSize - len(events)}
-		if back > 0 {
+		if back >= 0 {
 			opts.Date = basecamp.DateOf(today.AddDate(0, 0, -back))
 		}
 		result, err := client.Timeline().Progress(ctx, opts)

internal/tui/workspace/data/timeline_feed_test.go

@@ -89,7 +89,7 @@ func TestFetchTimelineEventsStopsAtTheLookback(t *testing.T) {
 	}}
 
 	assert.Empty(t, fetchActivityDays(t, transport))
-	assert.Equal(t, []string{"", "2026-10-22", "2026-10-21", "2026-10-20", "2026-10-19", "2026-10-18", "2026-10-17"}, transport.asked)
+	assert.Equal(t, []string{"", "2026-10-23", "2026-10-22", "2026-10-21", "2026-10-20", "2026-10-19", "2026-10-18", "2026-10-17"}, transport.asked)
 }
 
 func TestFetchTimelineEventsKeepsAnEventSeenTwiceOnce(t *testing.T) {
@@ -100,3 +100,13 @@ func TestFetchTimelineEventsKeepsAnEventSeenTwiceOnce(t *testing.T) {
 
 	assert.Equal(t, []int64{1, 2, 3}, fetchActivityDays(t, transport))
 }
+
+func TestFetchTimelineEventsMissesNoDayWhenBasecampIsAhead(t *testing.T) {
+	transport := &activityDaysTransport{today: "2026-10-24", days: map[string][]int64{
+		"2026-10-24": {1},
+		"2026-10-23": {2},
+		"2026-10-22": {3},
+	}}
+
+	assert.Equal(t, []int64{1, 2, 3}, fetchActivityDays(t, transport))
+}