fix(memory): harden buffer excerpt against early-terminator collapse

Adversarial review (AI Verification Protocol) found two defects in
summarizeForBuffer:

- D-01 (critical): when the only sentence terminator in the window was an
  early abbreviation/version/domain ("e.g.", "v1.2", "node.js"), the
  excerpt collapsed to a few runes (e.g. "e.g.…") — destroying the
  summary. Now a sentence cut is only preferred when it lands at least
  halfway through the window; otherwise fall back to the word boundary
  near the cap.
- D-02 (minor): an unclosed code fence (unmatched by the fenced-block
  regex) left a stray backtick in the output. Residual backticks are now
  stripped after inline-code unwrapping.

Adds regression tests for both.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: jkyberneees

internal/memory/summarize.go

@@ -48,8 +48,10 @@ func summarizeForBuffer(text string) string {
 	hadCode := reCodeFence.MatchString(text)
 	text = reCodeFence.ReplaceAllString(text, " ")
 
-	// 2. Inline code -> inner text.
+	// 2. Inline code -> inner text, then drop any residual backticks (e.g. from
+	//    an unclosed fence that step 1 could not match).
 	text = reInlineCode.ReplaceAllString(text, "$1")
+	text = strings.ReplaceAll(text, "`", "")
 
 	// 3. Images/links -> their visible text.
 	text = reMdImage.ReplaceAllString(text, "$1")
@@ -84,6 +86,11 @@ func summarizeForBuffer(text string) string {
 // cuts at the last sentence terminator (.!?) before the cap, else the last
 // space, else hard-cuts at the cap — always on a rune boundary — and appends an
 // ellipsis. Never splits a multibyte rune.
+//
+// A sentence cut is only preferred when it lands at least halfway through the
+// window. Otherwise a single early terminator (an abbreviation like "e.g.", a
+// version "v1.2", or a domain "node.js") would collapse the summary to a few
+// runes; in that case we fall back to the word boundary near the cap instead.
 func excerptRunes(s string, max int) string {
 	if utf8.RuneCountInString(s) <= max {
 		return s
@@ -97,8 +104,10 @@ func excerptRunes(s string, max int) string {
 			cut = i + 1 // include the terminator
 		}
 	}
-	if cut <= 0 {
-		// No sentence end; fall back to the last word boundary.
+	if cut < max/2 {
+		// No (or only an early) sentence end; fall back to the last word
+		// boundary so we keep as much content as possible.
+		cut = -1
 		for i := len(window) - 1; i >= 0; i-- {
 			if window[i] == ' ' {
 				cut = i

internal/memory/summarize_test.go

@@ -94,6 +94,34 @@ func TestSummarizeForBuffer_HardCutSingleLongToken(t *testing.T) {
 	}
 }
 
+// TestSummarizeForBuffer_EarlyAbbreviationNoCollapse guards against an early,
+// lone sentence terminator (abbreviation / version / domain) collapsing the
+// excerpt to a few runes. The cut must fall back to the word boundary near the
+// cap and retain most of the content.
+func TestSummarizeForBuffer_EarlyAbbreviationNoCollapse(t *testing.T) {
+	cases := []string{
+		"e.g., " + strings.Repeat("we should refactor the module ", 20),
+		"node.js " + strings.Repeat("is a runtime for building scalable apps ", 20),
+		"v1.2 " + strings.Repeat("introduces many features and improvements ", 20),
+	}
+	for _, in := range cases {
+		got := summarizeForBuffer(in)
+		if n := utf8.RuneCountInString(got); n < maxBufferSummaryRunes/2 {
+			t.Errorf("early-abbreviation excerpt collapsed to %d runes: %q", n, got)
+		}
+	}
+}
+
+// TestSummarizeForBuffer_UnclosedFence ensures an unclosed code fence leaves no
+// stray backticks in the summary.
+func TestSummarizeForBuffer_UnclosedFence(t *testing.T) {
+	in := "Here is some code:\n```go\nfunc main() { panic() }\nand more text after"
+	got := summarizeForBuffer(in)
+	if strings.Contains(got, "`") {
+		t.Errorf("summary contains a leftover backtick: %q", got)
+	}
+}
+
 func TestSummarizeForBuffer_MultibyteBoundarySafe(t *testing.T) {
 	// A long run of 3-byte runes with no spaces/sentence ends: must hard-cut on a
 	// rune boundary, never splitting a rune.