insertion-normalization: never strip the tail — a final-message duplicate is payload (insertion slice of fork e0f8fcb)

Path-scoped slice of fork commit e0f8fcb: the insertion-normalization
tail guard and its tests. The same commit's output-guard
assistant-terminal invariant (proxy/extensions/output-guard.mjs,
test/output-guard.test.mjs) belongs to the output-guard slice (cnighswonger#278) and
is not part of this PR.

Co-Authored-By: Claude opus-5 <noreply@anthropic.com>

Author: Gunther-Schulz

proxy/extensions/insertion-normalization.mjs

@@ -854,11 +854,24 @@ export function classifyPinned(messages, priorCanonical) {
   // findSuppressibleDuplicate returns null, the entry is untouched here,
   // and whatever the existing rules above already decided (append/splice/
   // edit-shaped reset) stands — no new reset path is introduced.
+  // TAIL GUARD (BACKLOG.md, "suppression can strip a request's FINAL
+  // message", 2026-07-30). Three real 400s ("must end with a user
+  // message"): report-enforcer injects identical instruction bytes at
+  // every SubagentStop; the first occurrence gets pinned, and when the
+  // SAME bytes arrive again as the resume request's ONLY/new final
+  // message, suppressing it left the forwarded array ending on the prior
+  // assistant turn. A tail-position duplicate is never a stray migration
+  // copy of already-pinned content — CC just sent it as the live,
+  // load-bearing final entry of THIS request, and the model needs to see
+  // it. Applies uniformly to both single-block and join-hash matches: the
+  // guard is positional, not about which hash set matched.
+  const lastIdx = messages.length - 1;
   const pinnedHashes = pinnedBlockHashes(priorCanonical);
   const pinnedJoin = pinnedJoinHashes(priorCanonical);
   const suppressions = [];
   for (const e of newEntries) {
     if (e.r === "assistant") continue;
+    if (e.index === lastIdx) continue;
     const h = findSuppressibleDuplicate(messages[e.index], pinnedHashes, pinnedJoin);
     if (h !== null) suppressions.push({ index: e.index, hash: h });
   }

test/insertion-merge-suppression.test.mjs

@@ -100,19 +100,54 @@ test("GREEN: the real merged standalone matches the join-hash of its pinned entr
   assert.notEqual(h, null, "the real merged standalone must be recognized as a suppressible duplicate");
 });
 
-test("classifyPinned end-to-end: the real merged standalone is suppressed as a new entry, not forwarded twice", () => {
+test("classifyPinned end-to-end: the real merged standalone is suppressed as a new entry, not forwarded twice (MID-HISTORY — matches the real capture, which had dozens of messages after msg864)", () => {
   const toolUseId = REAL_MSG863.content[0].tool_use_id;
   const canon = pinCanon([assistantToolUse(toolUseId), REAL_MSG863]);
 
-  const messages = [assistantToolUse(toolUseId), REAL_MSG863, { ...REAL_MERGED_STANDALONE }];
+  // A trailing turn after the standalone, so it sits at a genuine
+  // mid-history position (index 2 of 4) rather than the array's final
+  // index — the real capture had ~57 more messages after msg864. The
+  // tail-guard test below covers the DIFFERENT real incident where the
+  // duplicate IS the final message.
+  const messages = [
+    assistantToolUse(toolUseId),
+    REAL_MSG863,
+    { ...REAL_MERGED_STANDALONE },
+    { role: "assistant", content: [{ type: "text", text: "a-after" }] },
+  ];
   const result = classifyPinned(messages, canon);
 
   assert.equal(result.suppressed, 1, "the merged standalone must be counted as a suppression");
   assert.equal(result.suppressions.length, 1);
   assert.equal(result.suppressions[0].index, 2);
   // The pinned inline form (index 1) already carries both reminders; the
   // standalone must not also appear in the forwarded array.
-  assert.equal(result.messages.length, 2, "the standalone must not be forwarded alongside the pinned inline form");
+  assert.equal(result.messages.length, 3, "the standalone must not be forwarded alongside the pinned inline form");
+});
+
+// =====================================================================
+// TAIL GUARD (BACKLOG.md, "suppression can strip a request's FINAL
+// message", 2026-07-30) — the join-hash-specific case. Three real 400s
+// traced to suppression removing a resume request's ONLY/new final
+// message, leaving the forwarded array ending on the prior assistant
+// turn -> upstream "must end with a user message". A tail-position
+// duplicate is the request's live payload, not a stray migration copy.
+// =====================================================================
+
+test("TAIL GUARD: the real merged standalone as the FINAL message is never suppressed", () => {
+  const toolUseId = REAL_MSG863.content[0].tool_use_id;
+  const canon = pinCanon([assistantToolUse(toolUseId), REAL_MSG863]);
+
+  const messages = [assistantToolUse(toolUseId), REAL_MSG863, { ...REAL_MERGED_STANDALONE }];
+  const result = classifyPinned(messages, canon);
+
+  assert.equal(result.suppressed, 0, "a final-position merged duplicate must be forwarded, not suppressed");
+  assert.equal(result.messages.length, 3, "the standalone must remain on the wire as the live final message");
+  assert.equal(
+    result.messages[result.messages.length - 1].content,
+    REAL_MERGED_STANDALONE.content,
+    "the final message content is unchanged",
+  );
 });
 
 // =====================================================================

test/insertion-suppression.test.mjs

@@ -155,6 +155,53 @@ test("classifyPinned: a standalone duplicate of a pinned block is suppressed; th
   assert.deepEqual(result.messages[result.messages.length - 1], userMsg("continue"));
 });
 
+// =====================================================================
+// TAIL GUARD (BACKLOG.md, "suppression can strip a request's FINAL
+// message", 2026-07-30). Three real 400s ("must end with a user
+// message"): report-enforcer injects identical instruction bytes at
+// every SubagentStop; the first occurrence is pinned, and when the SAME
+// bytes arrive again as a resume request's ONLY/new final message,
+// suppressing it left the forwarded array ending on the prior assistant
+// turn. A tail-position duplicate is CC's live payload for THIS request,
+// not a migration copy of already-pinned content, regardless of role or
+// which hash set (single-block or join) matched it.
+// =====================================================================
+
+test("TAIL GUARD: a standalone duplicate at the FINAL index is never suppressed — it is live payload, not a migration", () => {
+  const orig = [withReminderMsg("tool result"), assistantMsg("a1")];
+  const canon = pinCanon(orig);
+
+  const strippedTail = { role: "user", content: [{ type: "text", text: "tool result" }] };
+  const standaloneDuplicate = { role: "system", content: [{ type: "text", text: REMINDER_INNER }] };
+  // No trailing entry after the duplicate — it IS the array's final
+  // message, mirroring the real resume-request shape.
+  const next = [strippedTail, assistantMsg("a1"), standaloneDuplicate];
+
+  const result = classifyPinned(next, canon);
+  assert.equal(result.suppressed, 0, "a final-position duplicate must never be suppressed");
+  assert.equal(result.suppressions.length, 0);
+  assert.deepEqual(
+    result.messages[result.messages.length - 1],
+    standaloneDuplicate,
+    "the final message must be forwarded intact — this is exactly what would otherwise strip a resume's last turn",
+  );
+});
+
+test("REGRESSION: the same standalone duplicate, mid-history (not final), is still suppressed", () => {
+  const orig = [withReminderMsg("tool result"), assistantMsg("a1")];
+  const canon = pinCanon(orig);
+
+  const strippedTail = { role: "user", content: [{ type: "text", text: "tool result" }] };
+  const standaloneDuplicate = { role: "system", content: [{ type: "text", text: REMINDER_INNER }] };
+  // Same duplicate, same position (index 2) as the tail-guard test above,
+  // but with a trailing turn after it — no longer the final index.
+  const next = [strippedTail, assistantMsg("a1"), standaloneDuplicate, userMsg("continue")];
+
+  const result = classifyPinned(next, canon);
+  assert.equal(result.suppressed, 1, "mid-history duplicates are suppressed exactly as before the tail guard");
+  assert.equal(result.suppressions[0].index, 2);
+});
+
 test("classifyPinned: suppression is stable across a THIRD request — CC keeps resending the duplicate, it keeps getting suppressed, with no persisted marker needed", () => {
   const orig = [withReminderMsg("tool result"), assistantMsg("a1")];
   let canon = pinCanon(orig);