refactor(failure_auto_filer): Phase B language-advantage pass — dichotomy wave

src/go/failure-filer/filer.go

@@ -232,6 +232,31 @@ func NewFailureAutoFiler(client ForgeClient, journal SpoolJournal, batchSize int
 	return f
 }
 
+// advanceState is the shared coalescing step behind File and flushGroup.
+// The oracle states the due predicate twice (file() vs _flush_group());
+// Go's multiple-return values collapse them into one guard-protected
+// helper returning both the due flag and the count snapshot.
+func (f *FailureAutoFiler) advanceState(sig sigKey, n int, now float64) (due bool, countAtFlush int) {
+	f.mu.Lock()
+	st := f.state[sig]
+	if st == nil {
+		st = &sigState{}
+		f.state[sig] = st
+	}
+	st.count += n
+	st.pending += n
+	due = st.count == n || // first flush for this signature
+		st.pending >= f.batchSize ||
+		(st.pending > 0 && now-st.windowStart >= batchIntervalSeconds)
+	countAtFlush = st.count
+	if due {
+		st.pending = 0
+		st.windowStart = now
+	}
+	f.mu.Unlock()
+	return due, countAtFlush
+}
+
 // ------------------------------------------------------ failure-path API
 
 // Call is oracle __call__ (the callable-filer contract): exactly Submit.
@@ -299,23 +324,7 @@ func (f *FailureAutoFiler) File(subsystem, errMsg string, tier int, now float64)
 	now = clockNow(now)
 	sig := signatureKey(subsystem, errMsg)
 	text := errMsg
-	f.mu.Lock()
-	st := f.state[sig]
-	if st == nil {
-		st = &sigState{}
-		f.state[sig] = st
-	}
-	st.count++
-	st.pending++
-	due := st.count == 1 ||
-		st.pending >= f.batchSize ||
-		(st.pending > 0 && now-st.windowStart >= batchIntervalSeconds)
-	countAtFlush := st.count
-	if due {
-		st.pending = 0
-		st.windowStart = now
-	}
-	f.mu.Unlock()
+	due, countAtFlush := f.advanceState(sig, 1, now)
 	if !due {
 		return false // coalesced: no client call for this occurrence
 	}
@@ -563,23 +572,7 @@ func (f *FailureAutoFiler) flushGroup(sig sigKey, group []filerItem) error {
 	now := last.now
 	text := last.text // last error of the batch
 	tier := last.tier
-	f.mu.Lock()
-	st := f.state[sig]
-	if st == nil {
-		st = &sigState{}
-		f.state[sig] = st
-	}
-	st.count += len(group)
-	st.pending += len(group)
-	due := st.count == len(group) ||
-		st.pending >= f.batchSize ||
-		(st.pending > 0 && now-st.windowStart >= batchIntervalSeconds)
-	countAtFlush := st.count
-	if due {
-		st.pending = 0
-		st.windowStart = now
-	}
-	f.mu.Unlock()
+	due, countAtFlush := f.advanceState(sig, len(group), now)
 	if due {
 		if _, err := f.write(sig, text, tier, countAtFlush, 0); err != nil {
 			return err