fix(codebuff): address review findings - ForceReplace, ID lookup, model, lifecycle

1. ForceReplace: Created codebuffSourceSet wrapper that overrides Parse
   to set ForceReplace: true on successful parses, ensuring full message
   replacement for the mutable transcript.

2. codebuffFindFile: Updated to split project:timestamp in raw ID for
   the new session ID format, with legacy timestamp-only fallback.

3. Usage events: Added placeholder model name "codebuff" so usage
   queries filter correctly and cost display works.

4. File-path policies: Made alias-aware for both Codebuff and Freebuff
   in ListSessionIDsByFilePath and HasTrashedSessionByFilePath.

Author: scross01

internal/parser/codebuff.go

@@ -187,14 +187,15 @@ func parseCodebuffSession(
 	// this value. Leave peak context unavailable.
 
 	// 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.
+	// (selected server-side, can change mid-session), so use a placeholder
+	// model name. Usage queries filter out events with empty model, so a
+	// non-empty value is required for cost display.
 	if rs.CreditsUsed > 0 {
 		cost := rs.CreditsUsed * 0.01
 		sess.UsageEvents = []ParsedUsageEvent{{
 			SessionID: fullID,
 			Source:    "session",
+			Model:     "codebuff",
 			OccurredAt: func() string {
 				if !endedAt.IsZero() {
 					return endedAt.Format(time.RFC3339Nano)

internal/parser/codebuff_provider.go

@@ -1,6 +1,7 @@
 package parser
 
 import (
+	"context"
 	"crypto/sha256"
 	"fmt"
 	"os"
@@ -12,11 +13,11 @@ import (
 // Freebuff sessions are handled through the same provider and distinguished
 // via AgentLabel rather than a separate agent type.
 func newCodebuffProviderFactory(def AgentDef) ProviderFactory {
-	return NewSingleFileProviderFactory(
+	return NewSourceSetFactory(
 		def,
 		codebuffProviderCapabilities(),
-		func(cfg ProviderConfig) singleFileSourceSet {
-			return NewSingleFileSourceSet(
+		func(cfg ProviderConfig) SourceSet {
+			inner := NewSingleFileSourceSet(
 				def.Type,
 				cfg.Roots,
 				WithStreamingFileDiscovery(codebuffDiscoverEach),
@@ -38,10 +39,30 @@ func newCodebuffProviderFactory(def AgentDef) ProviderFactory {
 					return codebuffParseFile(src, req)
 				}),
 			)
+			return codebuffSourceSet{inner}
 		},
 	)
 }
 
+// codebuffSourceSet wraps singleFileSourceSet to force full message
+// replacement on every successful parse. Codebuff reparses the entire
+// mutable JSON transcript on every sync, so the append-only writer
+// would leave stale ordinals and missed in-place block updates.
+type codebuffSourceSet struct {
+	singleFileSourceSet
+}
+
+func (s codebuffSourceSet) Parse(
+	ctx context.Context,
+	req ParseRequest,
+) (ParseOutcome, error) {
+	outcome, err := s.singleFileSourceSet.Parse(ctx, req)
+	if err == nil && outcome.ResultSetComplete && len(outcome.Results) > 0 {
+		outcome.ForceReplace = true
+	}
+	return outcome, err
+}
+
 // codebuffWatchRoots creates watch plans for recursive watching of
 // each root. Since sessions are two levels deep under chats/, we need
 // recursive watching.
@@ -101,9 +122,28 @@ func codebuffClassifyPath(
 	return singleFileMatch{}, false
 }
 
-// codebuffFindFile finds a session by raw session ID (timestamp) under
-// the root. Searches across all project subdirectories.
+// codebuffFindFile finds a session by raw session ID under the root.
+// The rawID may be either "project:timestamp" (new format) or just
+// "timestamp" (legacy compatibility). For the new format, it searches
+// the specific project directory. For legacy format, it searches all
+// project subdirectories.
 func codebuffFindFile(root, rawID string) (singleFileMatch, bool) {
+	// Try to split into project:timestamp.
+	parts := strings.SplitN(rawID, ":", 2)
+	if len(parts) == 2 {
+		projectName := parts[0]
+		timestamp := parts[1]
+		chatPath := filepath.Join(root, projectName, "chats", timestamp, "chat-messages.json")
+		if IsRegularFile(chatPath) {
+			return singleFileMatch{
+				Path:        chatPath,
+				ProjectHint: projectName,
+			}, true
+		}
+		return singleFileMatch{}, false
+	}
+
+	// Legacy format: search all projects for the timestamp.
 	projects, err := os.ReadDir(root)
 	if err != nil {
 		return singleFileMatch{}, false

internal/sync/engine.go

@@ -7407,18 +7407,42 @@ func (e *Engine) applyProviderFilePathPolicies(
 		currentID := result.Session.ID
 		currentPrefixedID := e.idPrefix + result.Session.ID
 
-		existingIDs, err := e.db.ListSessionIDsByFilePath(lookupPath, string(agent))
-		if err != nil {
-			log.Printf("list session IDs by file path: %v", err)
-			kept = append(kept, result)
-			continue
+		// Freebuff shares the Codebuff provider. Query both agent types
+		// so stale rows and resurrection guards work for both.
+		agentsToQuery := []string{string(agent)}
+		if agent == parser.AgentCodebuff {
+			agentsToQuery = append(agentsToQuery, string(parser.AgentFreebuff))
+		}
+		var existingIDs []string
+		for _, agentStr := range agentsToQuery {
+			ids, err := e.db.ListSessionIDsByFilePath(lookupPath, agentStr)
+			if err != nil {
+				log.Printf("list session IDs by file path: %v", err)
+				continue
+			}
+			existingIDs = append(existingIDs, ids...)
+		}
+		if len(existingIDs) == 0 && len(agentsToQuery) > 1 {
+			// Check if the query for the primary agent failed.
+			_, err := e.db.ListSessionIDsByFilePath(lookupPath, string(agent))
+			if err != nil {
+				log.Printf("list session IDs by file path: %v", err)
+				kept = append(kept, result)
+				continue
+			}
 		}
 
 		// Resurrection guard. The path's identity is removed when a trashed row
 		// shares it, or when any alternate identity for the path (the
 		// provider's excluded fallback IDs or a stale stored ID) is trashed or
 		// permanently excluded. In that case the new row must not be written.
-		suppress := e.db.HasTrashedSessionByFilePath(lookupPath, string(agent))
+		suppress := false
+		for _, agentStr := range agentsToQuery {
+			if e.db.HasTrashedSessionByFilePath(lookupPath, agentStr) {
+				suppress = true
+				break
+			}
+		}
 		if !suppress {
 			for id := range excluded {
 				if id == currentID || id == currentPrefixedID {