redact: preserve thinking-block signatures (fix omp replay 400)

shouldSkipJSONLField only skipped a field named exactly "signature"
(Claude Code). Oh My Pi stores the extended-thinking signature under
"thinkingSignature", which slipped through to the entropy scanner. Its
value is high-entropy base64, so redaction replaced segments with
"REDACTED", corrupting the signature.

When such a redacted transcript is replayed, the Anthropic API rejects it
with "messages.N.content.0: Invalid `signature` in `thinking` block" (400)
— it validates signatures on every history turn, not just the last.

Skip any field whose lowercased name ends in "signature" (covers
"signature" and "thinkingSignature"). "signatures" (plural) still redacts.
Add field-skip and end-to-end preservation tests.

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

Author: gtrrz-victor

redact/redact.go

@@ -827,12 +827,19 @@ func collectJSONLReplacements(v any, redactor func(string) string) []jsonReplace
 }
 
 // shouldSkipJSONLField returns true if a JSON key should be excluded from scanning/redaction.
-// Skips "signature" (exact), ID fields (ending in "id"/"ids"), and common path/directory fields.
+// Skips signature fields (any key ending in "signature"), ID fields (ending in "id"/"ids"),
+// and common path/directory fields.
 func shouldSkipJSONLField(key string) bool {
-	if key == "signature" {
+	lower := strings.ToLower(key)
+
+	// Skip signature fields: cryptographic attestations, not secrets. Covers
+	// "signature" (Claude Code) and provider variants like "thinkingSignature"
+	// (Oh My Pi). Their values are high-entropy base64, so the entropy scanner
+	// would otherwise redact them — corrupting extended-thinking signatures and
+	// breaking transcript replay ("Invalid `signature` in `thinking` block").
+	if strings.HasSuffix(lower, "signature") {
 		return true
 	}
-	lower := strings.ToLower(key)
 
 	// Skip ID fields
 	if strings.HasSuffix(lower, "id") || strings.HasSuffix(lower, "ids") {

redact/redact_test.go

@@ -224,8 +224,10 @@ func TestShouldSkipJSONLField(t *testing.T) {
 		{"ids", true},
 		{"session_ids", true},
 		{"userIds", true},
-		// Exact match "signature" should be skipped.
+		// Signature fields should be skipped (any key ending in "signature").
 		{"signature", true},
+		{"thinkingSignature", true},
+		{"thinking_signature", true},
 		// Path-related fields should be skipped.
 		{"filePath", true},
 		{"file_path", true},
@@ -245,7 +247,7 @@ func TestShouldSkipJSONLField(t *testing.T) {
 		{"args", false},
 		{"video", false},      // ends in "o", not "id"
 		{"identify", false},   // ends in "ify", not "id"
-		{"signatures", false}, // not exact match "signature"
+		{"signatures", false}, // does not end in "signature"
 		{"signal_data", false},
 		{"consideration", false}, // contains "id" but doesn't end with it
 	}
@@ -292,6 +294,22 @@ func TestJSONLContent_SkippedFieldValueCollision(t *testing.T) {
 	}
 }
 
+func TestJSONLContent_PreservesThinkingSignature(t *testing.T) {
+	t.Parallel()
+	// Oh My Pi stores extended-thinking signatures under "thinkingSignature".
+	// Their base64 value is high-entropy; redacting it corrupts the signature and
+	// breaks replay with "Invalid `signature` in `thinking` block".
+	input := `{"type":"thinking","thinking":"plan","thinkingSignature":"` + highEntropySecret + `"}`
+
+	result, err := JSONLContent(input)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(result, `"thinkingSignature":"`+highEntropySecret+`"`) {
+		t.Fatalf("expected thinkingSignature to be preserved verbatim, got: %s", result)
+	}
+}
+
 func TestString_PatternDetection(t *testing.T) {
 	// These secrets have entropy below 4.5 so entropy-only detection misses them.
 	// Betterleaks pattern matching should catch them.