Address review: gate window reset on a real turn advance + fix comments

- Only re-anchor the prompt window when SessionTurnCount actually increases,
  so a repeated/stale hook (same cumulative TurnCount) no longer clears the
  deferred reset early and break back-to-back checkpoint counts (Cursor bug).
  Adds a regression test.
- Correct the checkpointStepCount doc (attach uses attachStepCount, not this
  path) and the WriteCommittedOptions.CheckpointsCount comment (now a prompt
  "steps" count, not a checkpoint count).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: dipree

cmd/entire/cli/checkpoint/checkpoint.go

@@ -227,7 +227,9 @@ type WriteCommittedOptions struct {
 	// FilesTouched are files modified during the session
 	FilesTouched []string
 
-	// CheckpointsCount is the number of checkpoints in this session
+	// CheckpointsCount is the displayed "steps" count for this session: the number
+	// of user prompts attributed to this checkpoint (floored at 1). Despite the
+	// historical name/JSON tag, it is no longer a count of checkpoints.
 	CheckpointsCount int
 
 	// SaveStepCount is the number of SaveStep-recorded steps (shadow-branch

cmd/entire/cli/lifecycle.go

@@ -1121,11 +1121,14 @@ func persistEventMetadataToState(event *agent.Event, state *strategy.SessionStat
 	} else if event.Type == agent.TurnEnd {
 		state.SessionTurnCount++
 	}
-	// Deferred checkpoint-window reset: the first time a turn is counted after a
-	// checkpoint was written, re-anchor the window base to the turn count from
-	// before this turn so the current turn becomes the first prompt of the new
-	// window. Until then, back-to-back checkpoints keep reporting the same count.
-	if (event.TurnCount > 0 || event.Type == agent.TurnEnd) && state.PromptWindowResetPending {
+	// Deferred checkpoint-window reset: the first time the turn count actually
+	// advances after a checkpoint was written, re-anchor the window base to the
+	// count from before this turn so the current turn becomes the first prompt of
+	// the new window. Gate on a real advance (not just a TurnEnd / non-zero
+	// TurnCount) so a repeated or stale hook reporting the same cumulative count
+	// doesn't re-anchor early — that would make a later back-to-back checkpoint
+	// report 1 instead of matching the prior count.
+	if state.SessionTurnCount > prevTurnCount && state.PromptWindowResetPending {
 		state.PromptWindowBase = prevTurnCount
 		state.PromptWindowResetPending = false
 	}

cmd/entire/cli/lifecycle_test.go

@@ -2038,3 +2038,30 @@ func TestPromptWindowExecModeCumulativeTurnCount(t *testing.T) {
 		t.Fatalf("exec checkpoint B = %d, want 2", got)
 	}
 }
+
+// TestPromptWindowStaleHookDoesNotResetEarly guards against a repeated/stale hook
+// (same cumulative TurnCount, so the count doesn't actually advance) clearing the
+// deferred reset early. If it did, a later back-to-back checkpoint would report 1
+// instead of matching the prior checkpoint's count.
+func TestPromptWindowStaleHookDoesNotResetEarly(t *testing.T) {
+	exec := func(s *strategy.SessionState, cumulative int) {
+		persistEventMetadataToState(&agent.Event{Type: agent.TurnEnd, TurnCount: cumulative}, s)
+	}
+
+	s := &strategy.SessionState{}
+	exec(s, 1)
+	exec(s, 2)
+	exec(s, 3)
+	if got := writeCheckpoint(s); got != 3 {
+		t.Fatalf("checkpoint A = %d, want 3", got)
+	}
+
+	// Stale hook: same cumulative count, no real advance — must not re-anchor.
+	exec(s, 3)
+	if !s.PromptWindowResetPending {
+		t.Fatalf("stale hook should not clear ResetPending")
+	}
+	if got := writeCheckpoint(s); got != 3 {
+		t.Fatalf("back-to-back checkpoint B after stale hook = %d, want 3", got)
+	}
+}

cmd/entire/cli/strategy/manual_commit_condensation.go

@@ -105,8 +105,9 @@ var redactSessionJSONLBytes = redact.JSONLBytes
 // checkpoint being written: the turns counted since the current window's base.
 // The base is re-anchored (deferred) the next time a turn is counted after a
 // checkpoint write, so back-to-back checkpoints with no prompt between them share
-// a count. Floored at 1 so we never record 0 (covers attach, a fast-path
-// checkpoint before any turn, and exec-mode gaps where turns weren't counted).
+// a count. Floored at 1 so we never record 0 (covers a fast-path checkpoint
+// before any turn, and exec-mode gaps where turns weren't counted). Attach has
+// its own count (see attachStepCount); it does not go through this path.
 func checkpointStepCount(s *SessionState) int {
 	if w := s.SessionTurnCount - s.PromptWindowBase; w >= 1 {
 		return w