fix(codebuff): address five roborev findings

1. Freebuff identity: Reverted to AgentFreebuff for distinct filtering,
   with prefix alias in AgentByPrefix for lifecycle operations.

2. Model name accuracy: Left model unknown since actual LLM model is
   selected server-side and can change mid-session. Credits usage
   events are emitted independently of model.

3. AI block ordering: Agent output now emitted immediately with tool
   call, system blocks (mode/plan/ask-user) emitted in source order
   instead of deferred to end.

4. Cross-midnight timestamps: Track date in parseCodebuffMessages and
   advance when time-of-day wraps past midnight.

5. PeakContextTokens: Removed incorrect peak context assertion since
   contextTokenCount from run-state.json is the final per-step value,
   not the peak (compaction can reduce it).

Author: scross01

internal/parser/codebuff.go

@@ -43,9 +43,10 @@ func parseCodebuffSession(
 	// Read chat-meta.json for session name and timing hints.
 	meta := readCodebuffChatMeta(chatMetaPath)
 
-	// Model name is the raw agentType from run-state.json
-	// (e.g. "base2-free-deepseek", "base2-free-mimo").
-	model := rs.AgentType
+	// The actual LLM model is selected server-side based on the agentType
+	// template and can change mid-session. The on-disk format does not
+	// persist the actual model, so leave it unknown.
+	model := ""
 
 	// Read and parse the chat messages.
 	data, err := os.ReadFile(chatMessagesPath)
@@ -105,15 +106,14 @@ func parseCodebuffSession(
 		}
 	}
 
-	// Determine agent label from run-state agentType field.
+	// Determine agent type from run-state agentType field.
 	// Sessions with "free" in the agentType are Freebuff, others are Codebuff.
-	// Both share the same on-disk layout and the same agent type (Codebuff)
-	// so that lifecycle operations (reconciliation, deletion, baselines)
-	// keyed by agent type work correctly. The UI distinguishes them via
-	// AgentLabel.
+	// Both share the same on-disk layout; the parser splits them by type
+	// so the UI can filter each agent independently.
 	agent := AgentCodebuff
 	agentLabel := "Codebuff"
 	if strings.Contains(strings.ToLower(rs.AgentType), "free") {
+		agent = AgentFreebuff
 		agentLabel = "Freebuff"
 	}
 
@@ -178,37 +178,31 @@ func parseCodebuffSession(
 		File:             fileInfo,
 	}
 
-	// Token counts from run-state.
-	if rs.ContextTokenCount > 0 {
-		sess.PeakContextTokens = rs.ContextTokenCount
-		sess.HasPeakContextTokens = true
-	}
-
-	sess.aggregateTokenPresenceKnown =
-		sess.HasTotalOutputTokens || sess.HasPeakContextTokens
+	// contextTokenCount from run-state.json is the final per-step context
+	// count, not the peak. Compaction can make the final value lower than
+	// the true peak, so we cannot reliably derive PeakContextTokens from
+	// this value. Leave peak context unavailable.
 
-	// Emit usage event with clean model name for catalog pricing.
-	// Credits are billing units (1 credit = $0.01), mapped to CostUSD.
-	if model != "" {
-		evt := ParsedUsageEvent{
+	// Emit usage event for reported credits. The actual model is unknown
+	// (selected server-side, can change mid-session), so Model is left
+	// empty. Credits are billing units (1 credit = $0.01), mapped to
+	// CostUSD for cost display.
+	if rs.CreditsUsed > 0 {
+		cost := rs.CreditsUsed * 0.01
+		sess.UsageEvents = []ParsedUsageEvent{{
 			SessionID: fullID,
 			Source:    "session",
-			Model:     model,
 			OccurredAt: func() string {
 				if !endedAt.IsZero() {
 					return endedAt.Format(time.RFC3339Nano)
 				}
 				return startedAt.Format(time.RFC3339Nano)
 			}(),
-			DedupKey: "session:" + fullID,
-		}
-		if rs.CreditsUsed > 0 {
-			cost := rs.CreditsUsed * 0.01
-			evt.CostUSD = &cost
-			evt.CostStatus = "reported"
-			evt.CostSource = "session"
-		}
-		sess.UsageEvents = []ParsedUsageEvent{evt}
+			CostUSD:    &cost,
+			CostStatus: "reported",
+			CostSource: "session",
+			DedupKey:   "session:" + fullID,
+		}}
 	}
 
 	return sess, msgs, nil
@@ -440,14 +434,35 @@ func parseCodebuffMessages(
 		startedAt time.Time
 		endedAt   time.Time
 		ordinal   int
+		// Track the current date for cross-midnight sessions. Start with
+		// the session directory date and advance when time-of-day wraps
+		// past midnight.
+		currentDate = sessionDate
+		prevHour    = -1
 	)
 
 	root.ForEach(func(_, msg gjson.Result) bool {
 		variant := msg.Get("variant").Str
 		ts := parseCodebuffTimestamp(
-			msg.Get("timestamp").Str, sessionDate,
+			msg.Get("timestamp").Str, currentDate,
 		)
 
+		// Detect midnight rollover for time-only timestamps: if the
+		// parsed hour is less than the previous hour, we've crossed
+		// midnight and should advance the date.
+		if !ts.IsZero() && prevHour >= 0 {
+			if ts.Hour() < prevHour {
+				currentDate = currentDate.AddDate(0, 0, 1)
+				// Re-parse with the advanced date.
+				ts = parseCodebuffTimestamp(
+					msg.Get("timestamp").Str, currentDate,
+				)
+			}
+		}
+		if !ts.IsZero() {
+			prevHour = ts.Hour()
+		}
+
 		if !ts.IsZero() {
 			if startedAt.IsZero() || ts.Before(startedAt) {
 				startedAt = ts
@@ -539,12 +554,11 @@ func parseCodebuffAIMessage(
 	}
 
 	var (
-		out           []ParsedMessage
-		thinkingBuf   []string
-		textBuf       []string
-		toolCalls     []ParsedToolCall
-		toolResults   []ParsedToolResult
-		pendingSys    []string
+		out         []ParsedMessage
+		thinkingBuf []string
+		textBuf     []string
+		toolCalls   []ParsedToolCall
+		toolResults []ParsedToolResult
 	)
 
 	// flushText emits any accumulated thinking and text as assistant messages,
@@ -687,45 +701,73 @@ func parseCodebuffAIMessage(
 			}
 			toolCalls = append(toolCalls, tc)
 
-			// Agent output goes into text buffer for the next flush.
+			// Emit agent output text immediately associated with the
+			// tool call, not deferred to a later flush.
 			if output := block.Get("content"); output.Exists() && output.Str != "" {
 				prefix := agentName
 				if agentType != "" {
 					prefix = agentType + ":" + agentName
 				}
+				// Flush accumulated tool calls first, then emit output.
+				flushTools()
 				textBuf = append(textBuf,
 					"["+prefix+" ("+status+")]\n"+output.Str)
+				flushText()
 			}
 
 		case "mode-divider":
 			flushText()
 			flushTools()
 			mode := block.Get("mode").Str
 			if mode != "" {
-				pendingSys = append(pendingSys, "[Mode: "+mode+"]")
+				// Emit system blocks immediately, not deferred.
+				out = append(out, ParsedMessage{
+					Role:          RoleSystem,
+					Content:       "[Mode: " + mode + "]",
+					Timestamp:     ts,
+					ContentLength: len("[Mode: " + mode + "]"),
+					IsSystem:      true,
+				})
 			}
 
 		case "plan":
 			flushText()
 			flushTools()
 			content := block.Get("content").Str
 			if strings.TrimSpace(content) != "" {
-				pendingSys = append(pendingSys, "[Plan]\n"+content)
+				// Emit system blocks immediately, not deferred.
+				out = append(out, ParsedMessage{
+					Role:          RoleSystem,
+					Content:       "[Plan]\n" + content,
+					Timestamp:     ts,
+					ContentLength: len("[Plan]\n" + content),
+					IsSystem:      true,
+				})
 			}
 
 		case "ask-user":
 			flushText()
 			flushTools()
 			questions := block.Get("questions")
 			if questions.IsArray() {
+				var parts []string
 				questions.ForEach(func(_, q gjson.Result) bool {
 					questionText := q.Get("question").Str
 					if strings.TrimSpace(questionText) != "" {
-						pendingSys = append(pendingSys,
-							"[Agent asked] "+questionText)
+						parts = append(parts, "[Agent asked] "+questionText)
 					}
 					return true
 				})
+				if len(parts) > 0 {
+					content := strings.Join(parts, "\n")
+					out = append(out, ParsedMessage{
+						Role:          RoleSystem,
+						Content:       content,
+						Timestamp:     ts,
+						ContentLength: len(content),
+						IsSystem:      true,
+					})
+				}
 			}
 
 		case "image":
@@ -743,18 +785,6 @@ func parseCodebuffAIMessage(
 	flushText()
 	flushTools()
 
-	// Emit system messages after all other content.
-	if len(pendingSys) > 0 {
-		sysContent := strings.Join(pendingSys, "\n")
-		out = append(out, ParsedMessage{
-			Role:          RoleSystem,
-			Content:       sysContent,
-			Timestamp:     ts,
-			ContentLength: len(sysContent),
-			IsSystem:      true,
-		})
-	}
-
 	if len(out) == 0 {
 		return nil
 	}

internal/parser/codebuff_test.go

@@ -89,8 +89,8 @@ func TestParseCodebuffSession_BasicUserAndAIMessages(t *testing.T) {
 	assert.Equal(t, "Fix the login bug", sess.FirstMessage)
 	assert.Equal(t, 2, sess.MessageCount)
 	assert.Equal(t, 1, sess.UserMessageCount)
-	assert.True(t, sess.HasPeakContextTokens)
-	assert.Equal(t, 50000, sess.PeakContextTokens)
+	// PeakContextTokens is not set because contextTokenCount from
+	// run-state.json is the final per-step count, not the peak.
 
 	require.Len(t, msgs, 2)
 	assert.Equal(t, RoleUser, msgs[0].Role)
@@ -121,10 +121,10 @@ func TestParseCodebuffSession_FreebuffClassification(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, sess)
 
-	// Freebuff sessions use AgentCodebuff so that lifecycle operations
-	// (reconciliation, deletion, baselines) keyed by agent type work
-	// correctly. The UI distinguishes them via AgentLabel.
-	assert.Equal(t, AgentCodebuff, sess.Agent)
+	// Freebuff sessions use AgentFreebuff for distinct filtering, while
+	// lifecycle operations are handled via the freebuff: prefix alias
+	// in AgentByPrefix.
+	assert.Equal(t, AgentFreebuff, sess.Agent)
 	assert.Equal(t, "Freebuff", sess.AgentLabel)
 }
 
@@ -414,13 +414,9 @@ func TestParseCodebuffSession_UsageEvent(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, sess)
 
-	require.Len(t, sess.UsageEvents, 1)
-	evt := sess.UsageEvents[0]
-	assert.Equal(t, sess.ID, evt.SessionID)
-	assert.Equal(t, "session", evt.Source)
-	assert.Equal(t, "base2-deepseek", evt.Model)
-	assert.NotEmpty(t, evt.OccurredAt)
-	assert.NotEmpty(t, evt.DedupKey)
+	// No usage event when credits are 0 (no billing data).
+	assert.Empty(t, sess.UsageEvents,
+		"no usage event when credits are 0")
 }
 
 func TestParseCodebuffSession_UsageEventEmptyModel(t *testing.T) {
@@ -1132,10 +1128,9 @@ func TestParseCodebuffSession_CreditsZero(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, sess)
 
-	// Freebuff sessions have no credits - CostUSD should be nil.
-	require.Len(t, sess.UsageEvents, 1)
-	assert.Nil(t, sess.UsageEvents[0].CostUSD,
-		"freebuff sessions should have no cost")
+	// Freebuff sessions have no credits - no usage event emitted.
+	assert.Empty(t, sess.UsageEvents,
+		"freebuff sessions should have no usage event")
 }
 
 func TestParseCodebuffSession_PlanBlock(t *testing.T) {

internal/sync/provider_effects.go

@@ -20,12 +20,18 @@ func validateProviderOutcome(
 	for _, result := range outcome.Results {
 		session := result.Result.Session
 		if session.Agent != def.Type {
-			return fmt.Errorf(
-				"%s: provider result session agent mismatch for %q: got %s",
-				def.Type,
-				session.ID,
-				session.Agent,
-			)
+			// The Codebuff provider may emit Freebuff sessions based on
+			// the agentType field in run-state.json. Both agents share
+			// the same on-disk layout and are discovered by one provider.
+			if def.Type != parser.AgentCodebuff ||
+				session.Agent != parser.AgentFreebuff {
+				return fmt.Errorf(
+					"%s: provider result session agent mismatch for %q: got %s",
+					def.Type,
+					session.ID,
+					session.Agent,
+				)
+			}
 		}
 		if err := validateProviderParseResultSessionIDs(def, result.Result); err != nil {
 			return err
@@ -104,6 +110,12 @@ func validateProviderSessionID(def parser.AgentDef, sessionID, field string) err
 	if strings.HasPrefix(sessionID, def.IDPrefix) {
 		return nil
 	}
+	// The Codebuff provider may emit Freebuff sessions whose IDs use
+	// the "freebuff:" prefix rather than the provider's "codebuff:" prefix.
+	if def.Type == parser.AgentCodebuff &&
+		strings.HasPrefix(sessionID, string(parser.AgentFreebuff)+":") {
+		return nil
+	}
 	return fmt.Errorf(
 		"%s: provider %s %q must use prefix %q",
 		def.Type,