pi-mega-compact 0.11.2 → 0.11.4

package/extensions/mega-compact-s38.test.ts

@@ -44,6 +44,21 @@ function eventTypes(stateDir: string): string[] {
 		.filter((t): t is string => typeof t === "string");
 }
 
+/** R11: read events.log and return full JSON payloads for a given type. */
+function eventPayloads(stateDir: string, type: string): Record<string, unknown>[] {
+	const { readFileSync: rf, existsSync: ex } =
+		require("node:fs") as typeof import("node:fs");
+	const { join: j } = require("node:path") as typeof import("node:path");
+	const logPath = j(stateDir, "events.log");
+	if (!ex(logPath)) return [];
+	const content = rf(logPath, "utf-8").trim();
+	if (content.length === 0) return [];
+	return content
+		.split("\n")
+		.map((line) => { try { return JSON.parse(line); } catch { return undefined; } })
+		.filter((p): p is Record<string, unknown> => typeof p === "object" && p !== null && p.type === type);
+}
+
 /** Build a mock pi + ctx and load the extension into them. */
 function harness(opts: { keepTier?: boolean; keepThreshold?: boolean } = {}) {
 	const stateDir = join(baseTmp, `run-${counter++}`);
@@ -106,8 +121,8 @@ function harness(opts: { keepTier?: boolean; keepThreshold?: boolean } = {}) {
 	};
 }
 
-const { classifyError: classifyErrorFn } =
-	require("./mega-events.js") as { classifyError: typeof import("./mega-events.js").classifyError };
+const { classifyError: classifyErrorFn, classifyErrorDetailed: classifyErrorDetailedFn, extractErrorSignature: extractErrorSignatureFn } =
+	require("./mega-events.js") as { classifyError: typeof import("./mega-events.js").classifyError; classifyErrorDetailed: typeof import("./mega-events.js").classifyErrorDetailed; extractErrorSignature: typeof import("./mega-events.js").extractErrorSignature };
 
 /** S38 helper: fire a turn_end with a given stopReason + optional text, using a
  *  low-pressure ctx so the durable-trim branch (ctx.compact) does NOT fire. */
@@ -318,14 +333,22 @@ test("S38: R1 burst of immediate transient errors fires 1 nudge (dedup), rest su
 	// the queued nudge (deliverAs:'followUp') has not been consumed by a new
 	// agent turn. errorRetryCount still advances for each error turn, so the
 	// per-burst max + circuit breaker still bound the burst.
-	const h = harness();
-	for (let i = 0; i < 5; i++) await s38TurnEnd(h, "error", `internal server error ${i}`);
-	assert.equal(h.sendUserMessages.length, 1, "R1 dedup: 1 nudge in burst (rest suppressed)");
-	// The 6th turn reaches count=6 > max=5 → exhausted (count advances even for dedup'd turns).
-	await s38TurnEnd(h, "error", "internal server error 5");
-	assert.equal(h.sendUserMessages.length, 1, "exhausted: still 1 nudge (no 6th)");
-	assert.ok(eventTypes(h.stateDir).includes("error_retry_exhausted"), "exhausted event logged on max+1");
-	assert.ok(eventTypes(h.stateDir).includes("error_retry_dedup_skip"), "dedup_skip events logged for suppressed turns");
+	// R10: disable outage advisory so this test isolates nudge dedup only.
+	const prevOutage = process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD;
+	process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD = "0";
+	try {
+		const h = harness();
+		for (let i = 0; i < 5; i++) await s38TurnEnd(h, "error", `internal server error ${i}`);
+		assert.equal(h.sendUserMessages.length, 1, "R1 dedup: 1 nudge in burst (rest suppressed)");
+		// The 6th turn reaches count=6 > max=5 → exhausted (count advances even for dedup'd turns).
+		await s38TurnEnd(h, "error", "internal server error 5");
+		assert.equal(h.sendUserMessages.length, 1, "exhausted: still 1 nudge (no 6th)");
+		assert.ok(eventTypes(h.stateDir).includes("error_retry_exhausted"), "exhausted event logged on max+1");
+		assert.ok(eventTypes(h.stateDir).includes("error_retry_dedup_skip"), "dedup_skip events logged for suppressed turns");
+	} finally {
+		if (prevOutage === undefined) delete process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD;
+		else process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD = prevOutage;
+	}
 });
 
 test("S38: retry fires 1x for permanent errors then stops", async () => {
@@ -447,10 +470,13 @@ test("S38.5: strict (default) defers ctx.compact() via setTimeout re-check", asy
 
 // ---- R3 classifier unit tests: poisoned-context signals ----
 
-test("R3 classifier: 0-token generic error (usage present, 0 tokens) → poisoned-context", () => {
-	// The 2026-07-28 incident: stopReason 'error' + usage 0 tokens. The turn
-	// never reached the model; retrying re-submits the same poisoned context.
-	assert.equal(classifyErrorFn({ stopReason: "error", usage: { inputTokens: 0, outputTokens: 0 } }), "poisoned-context");
+test("R9 classifier: bare 0-token generic error (usage present, 0 tokens) → transient (corroboration required)", () => {
+	// R9: The 2026-07-30 incidents proved that 0-token ≠ deterministic rejection
+	// when a router fronts the provider (the request never reached any model).
+	// Signal 3 now returns 'transient'; the repeat detector in agent-handlers.ts
+	// becomes the corroboration mechanism. A bare 0-token error that repeats
+	// ≥ poisonedContextRepeatThreshold (default 3) upgrades to poisoned.
+	assert.equal(classifyErrorFn({ stopReason: "error", usage: { inputTokens: 0, outputTokens: 0 } }), "transient");
 	// Bare stopReason 'error' with NO usage field stays transient (unknown tokens
 	// — conservative; preserves the pre-R3 mid-response/partial-content behavior).
 	assert.equal(classifyErrorFn({ stopReason: "error" }), "transient");
@@ -511,8 +537,11 @@ test("R6(a): 10 consecutive identical 0-token transient failures produce at most
 	// exercises the SESSION CAP, not the repeat signal.
 	const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
 	const prevRepeat = process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
+	const prevOutage = process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD;
 	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
 	process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = "999";
+	// R10: disable the outage advisory so this test isolates the session cap only.
+	process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD = "0";
 	try {
 		const h = harness();
 		for (let i = 0; i < 10; i++) {
@@ -528,6 +557,8 @@ test("R6(a): 10 consecutive identical 0-token transient failures produce at most
 		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
 		if (prevRepeat === undefined) delete process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
 		else process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = prevRepeat;
+		if (prevOutage === undefined) delete process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD;
+		else process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD = prevOutage;
 	}
 });
 
@@ -562,9 +593,12 @@ test("R6(c): transient burst retries with backoff gating — second immediate nu
 	const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
 	const prevSession = process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX;
 	const prevRepeat = process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
+	const prevOutage = process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD;
 	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
 	process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX = "999"; // don't let session cap bind
 	process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = "999"; // don't let repeat upgrade bind
+	// R10: disable the outage advisory so this test isolates backoff gating only.
+	process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD = "0";
 	try {
 		const h = harness();
 		// Turn 1: transient → nudge 1 fires (pending=true, backoff=1ms).
@@ -586,6 +620,8 @@ test("R6(c): transient burst retries with backoff gating — second immediate nu
 		else process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX = prevSession;
 		if (prevRepeat === undefined) delete process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
 		else process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = prevRepeat;
+		if (prevOutage === undefined) delete process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD;
+		else process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD = prevOutage;
 	}
 });
 
@@ -624,9 +660,11 @@ test("R6(e): success resets retry-nudge-pending state", async () => {
 
 test("R3: repeated identical transient error text upgrades to poisoned-context at threshold", async () => {
 	// The stateful repeat signal: 3 consecutive identical transient errors
-	// (default threshold) upgrade to poisoned. Uses "5xx server error" (5xx
-	// marker → transient) so the classifier returns transient, then the repeat
-	// tracker upgrades it. auto=false to skip the compact attempt.
+	// (default threshold) upgrade to poisoned. Uses "5xx server error" —
+	// deliberately NO known-retryable marker ("5xx" is not /5\d\d/, and
+	// "server error" alone matches nothing): the classifier returns transient
+	// via the generic 'error' fallthrough, then the repeat tracker upgrades it.
+	// auto=false to skip the compact attempt.
 	const prevAuto = process.env.MEGACOMPACT_AUTO;
 	const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
 	process.env.MEGACOMPACT_AUTO = "false";
@@ -652,6 +690,729 @@ test("R3: repeated identical transient error text upgrades to poisoned-context a
 	}
 });
 
+test("R9: extractErrorSignature fallback — bare 0-token error -> 'bare-0-token-error'", () => {
+	// The repeat detector needs a non-empty signature to track bare 0-token errors.
+	assert.equal(extractErrorSignatureFn({ stopReason: "error", usage: { inputTokens: 0, outputTokens: 0 } }), "bare-0-token-error");
+	// Without usage, stopReason alone does NOT get the fallback (mid-response deaths stay out of repeat tracking).
+	assert.equal(extractErrorSignatureFn({ stopReason: "error" }), "");
+	// Normal text content is returned as-is.
+	assert.equal(extractErrorSignatureFn({ stopReason: "error", content: "x" }), "x");
+});
+
+
+// ---- R7 regression tests: network/throughput errors must NEVER upgrade to ----
+// ---- poisoned-context (2026-07-30 false-alarm incident) ----
+
+/** R7 helper: fire the same transient error text `count` times with turn_start
+ *  + elapsed backoff between turns so each turn's nudge can fire. */
+async function r7RepeatTurns(h: ReturnType<typeof harness>, text: string, count: number) {
+	for (let i = 0; i < count; i++) {
+		await s38TurnEnd(h, "error", text);
+		await h.fire("turn_start", { type: "turn_start", turnIndex: i + 2 }, h.ctx());
+		await new Promise((r) => setTimeout(r, 3));
+	}
+}
+
+/** R7 helper: shared assertions for "stays transient" — no poisoned upgrade,
+ *  no /clear advise, and the transient retry path actually ran. */
+function assertStaysTransient(h: ReturnType<typeof harness>, label: string) {
+	assert.ok(
+		!eventTypes(h.stateDir).includes("poisoned_context"),
+		`${label}: no poisoned_context event (network errors never upgrade)`,
+	);
+	assert.ok(
+		!h.sendUserMessages.some((m) => m.includes("/clear")),
+		`${label}: no /clear advise message`,
+	);
+	assert.ok(
+		eventTypes(h.stateDir).includes("error_retry"),
+		`${label}: transient retry path ran (error_retry event)`,
+	);
+}
+
+test("R7(a): repeated 'timed out' phrasing (2026-07-30 incident text) stays transient — no poisoned upgrade", async () => {
+	// The incident error text was "Request timed out or failed. Try again" —
+	// "timed out" (two words) does NOT match the old guard's /timeout/, so the
+	// 3rd repeat fired the /clear poisoned advise. Must stay transient.
+	const prevAuto = process.env.MEGACOMPACT_AUTO;
+	const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	process.env.MEGACOMPACT_AUTO = "false";
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	try {
+		const h = harness();
+		await r7RepeatTurns(h, "Request timed out or failed. Try again", 3);
+		assertStaysTransient(h, "timed out x3");
+	} finally {
+		if (prevAuto === undefined) delete process.env.MEGACOMPACT_AUTO;
+		else process.env.MEGACOMPACT_AUTO = prevAuto;
+		if (prevBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
+	}
+});
+
+test("R7(b): repeated ETIMEDOUT errno stays transient", async () => {
+	// Node's timeout errno lowercases to "etimedout" — does NOT contain the
+	// substring "timeout". Slipped through the old guard.
+	const prevAuto = process.env.MEGACOMPACT_AUTO;
+	const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	process.env.MEGACOMPACT_AUTO = "false";
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	try {
+		const h = harness();
+		await r7RepeatTurns(h, "connect ETIMEDOUT 142.250.80.46:443", 3);
+		assertStaysTransient(h, "ETIMEDOUT x3");
+	} finally {
+		if (prevAuto === undefined) delete process.env.MEGACOMPACT_AUTO;
+		else process.env.MEGACOMPACT_AUTO = prevAuto;
+		if (prevBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
+	}
+});
+
+test("R7(c): repeated 'socket hang up' stays transient", async () => {
+	// Node surfaces ECONNRESET as the message "socket hang up" (the errno lives
+	// in error.code, which extractErrorSignature never sees).
+	const prevAuto = process.env.MEGACOMPACT_AUTO;
+	const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	process.env.MEGACOMPACT_AUTO = "false";
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	try {
+		const h = harness();
+		await r7RepeatTurns(h, "socket hang up", 3);
+		assertStaysTransient(h, "socket hang up x3");
+	} finally {
+		if (prevAuto === undefined) delete process.env.MEGACOMPACT_AUTO;
+		else process.env.MEGACOMPACT_AUTO = prevAuto;
+		if (prevBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
+	}
+});
+
+test("R7(d): repeated 429 rate-limit stays transient", async () => {
+	// /clear cannot fix a rate limit — the classifier explicitly keeps 429
+	// transient, so the repeat-upgrade must not override that verdict.
+	const prevAuto = process.env.MEGACOMPACT_AUTO;
+	const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	process.env.MEGACOMPACT_AUTO = "false";
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	try {
+		const h = harness();
+		await r7RepeatTurns(h, "429 Too Many Requests: rate limit exceeded", 3);
+		assertStaysTransient(h, "429 x3");
+	} finally {
+		if (prevAuto === undefined) delete process.env.MEGACOMPACT_AUTO;
+		else process.env.MEGACOMPACT_AUTO = prevAuto;
+		if (prevBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
+	}
+});
+
+test("R7(e): 0-token 'timed out' turn is NOT poisoned on first occurrence", async () => {
+	// Deeper gap: with usage PRESENT at 0 tokens, the classifier's 0-token
+	// poisoned signal fires on turn ONE for "timed out" phrasing (the stopReason
+	// 'error' is in the text blob and no transient marker matched). The network
+	// markers must be checked before that signal so this returns transient.
+	const prevAuto = process.env.MEGACOMPACT_AUTO;
+	process.env.MEGACOMPACT_AUTO = "false";
+	try {
+		const h = harness();
+		await s38TurnEndUsage(h, "error", "Request timed out or failed. Try again", 0);
+		assert.ok(
+			!eventTypes(h.stateDir).includes("poisoned_context"),
+			"0-token timed out: no poisoned_context on first turn",
+		);
+		assert.ok(
+			!h.sendUserMessages.some((m) => m.includes("/clear")),
+			"0-token timed out: no /clear advise on first turn",
+		);
+	} finally {
+		if (prevAuto === undefined) delete process.env.MEGACOMPACT_AUTO;
+		else process.env.MEGACOMPACT_AUTO = prevAuto;
+	}
+});
+
+test("R7(f): repeated non-network transient still upgrades to poisoned-context (control)", async () => {
+	// True-positive control: an error with NO known-retryable marker that
+	// repeats identically must still upgrade (the R3 feature itself).
+	const prevAuto = process.env.MEGACOMPACT_AUTO;
+	const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	process.env.MEGACOMPACT_AUTO = "false";
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	try {
+		const h = harness();
+		await r7RepeatTurns(h, "upstream rejected the request", 3);
+		assert.ok(
+			eventTypes(h.stateDir).includes("poisoned_context"),
+			"non-network repeat: poisoned_context event logged",
+		);
+		assert.ok(
+			h.sendUserMessages.some((m) => m.includes("/clear")),
+			"non-network repeat: /clear advise fired",
+		);
+	} finally {
+		if (prevAuto === undefined) delete process.env.MEGACOMPACT_AUTO;
+		else process.env.MEGACOMPACT_AUTO = prevAuto;
+		if (prevBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
+	}
+});
+
+test("R7(g): 'Request failed — please retry.' 0-token stays poisoned-context (2026-07-28 control)", async () => {
+	// The deterministic-rejection incident that motivated R3 must remain
+	// poisoned: the shared marker pattern must NOT match this text.
+	const prevAuto = process.env.MEGACOMPACT_AUTO;
+	process.env.MEGACOMPACT_AUTO = "false";
+	try {
+		const h = harness();
+		await s38TurnEndUsage(h, "error", "Request failed — please retry.", 0);
+		assert.ok(
+			eventTypes(h.stateDir).includes("poisoned_context"),
+			"deterministic rejection: poisoned_context event logged",
+		);
+		assert.ok(h.sendUserMessages.some((m) => m.includes("/clear")), "deterministic rejection: /clear advise fired");
+	} finally {
+		if (prevAuto === undefined) delete process.env.MEGACOMPACT_AUTO;
+		else process.env.MEGACOMPACT_AUTO = prevAuto;
+	}
+});
+
+test("R7 classifier: 0-token 'timed out' error → transient (not poisoned)", () => {
+	// Unit-level pin of the R7(e) gap.
+	assert.equal(
+		classifyErrorFn({
+			stopReason: "error",
+			content: "Request timed out or failed. Try again",
+			usage: { inputTokens: 0, outputTokens: 0 },
+		}),
+		"transient",
+	);
+});
+
+test("R7 classifier: bare network phrasings → transient", () => {
+	assert.equal(classifyErrorFn("socket hang up"), "transient");
+	assert.equal(classifyErrorFn("the operation timed out"), "transient");
+	assert.equal(classifyErrorFn("connect ETIMEDOUT 10.0.0.1:443"), "transient");
+});
+
+test("R7 classifier: 429/rate-limit → transient (control)", () => {
+	assert.equal(classifyErrorFn("429 Too Many Requests: rate limit exceeded"), "transient");
+});
+
+// ---- R8 regression tests: router-wrapped infra errors (2026-07-30 incident #2) ----
+// pi's console "Error: 500:" prefix is NOT part of the delivered message body,
+// so router phrasings ("All targets failed", "No healthy target selected",
+// "Too many concurrent requests") matched NO marker and the 0-token signal
+// poisoned the session on the FIRST turn.
+
+/** The exact error bodies from the 2026-07-30 incident (GLM router flapping). */
+const R8_NO_HEALTHY_TARGET =
+	'{"message":"No healthy target selected for alias \'hf:zai-org/GLM-4.7\'","type":"api_error"}';
+const R8_SOCKET_CLOSED =
+	"All targets failed: modal/zai-org/GLM-5.1-FP8. Last error: The socket connection was closed unexpectedly. For more information, pass `verbose: true` in the second argument to fetch()"; // guardrails-allow PREVENT-PI-004: verbatim 2026-07-30 incident error text (string fixture, not a network call)
+const R8_TOO_MANY_CONCURRENT =
+	'All targets failed: modal/zai-org/GLM-5.1-FP8. Last error: {"error": "Too many concurrent requests for this model"}';
+
+test("R8 classifier: router phrasings → transient, even at 0 tokens", () => {
+	for (const text of [R8_NO_HEALTHY_TARGET, R8_SOCKET_CLOSED, R8_TOO_MANY_CONCURRENT]) {
+		assert.equal(
+			classifyErrorFn({ stopReason: "error", content: text, usage: { inputTokens: 0, outputTokens: 0 } }),
+			"transient",
+			`0-token router error must be transient: ${text.slice(0, 60)}`,
+		);
+	}
+});
+
+test("R8 classifier: structured status field wins over phrasing", () => {
+	// 5xx → transient even with zero recognizable text.
+	assert.equal(
+		classifyErrorFn({ stopReason: "error", error: { status: 502, message: "???" }, usage: { inputTokens: 0, outputTokens: 0 } }),
+		"transient",
+	);
+	// 429 structured → transient.
+	assert.equal(
+		classifyErrorFn({ stopReason: "error", error: { statusCode: 429, message: "???" }, usage: { inputTokens: 0, outputTokens: 0 } }),
+		"transient",
+	);
+	// 401 → permanent (not transient, not poisoned).
+	assert.equal(
+		classifyErrorFn({ stopReason: "error", error: { status: 401, message: "???" } }),
+		"permanent",
+	);
+	// 400 with deterministic-rejection text → still poisoned (text rules 4xx).
+	assert.equal(
+		classifyErrorFn({ stopReason: "error", error: { status: 400, message: "orphaned tool result: tooluse ids mismatch" }, usage: { inputTokens: 0, outputTokens: 0 } }),
+		"poisoned-context",
+	);
+});
+
+test("R8(a): 0-token 'No healthy target' turn is NOT poisoned on first occurrence", async () => {
+	const prevAuto = process.env.MEGACOMPACT_AUTO;
+	process.env.MEGACOMPACT_AUTO = "false";
+	try {
+		const h = harness();
+		await s38TurnEndUsage(h, "error", R8_NO_HEALTHY_TARGET, 0);
+		assert.ok(!eventTypes(h.stateDir).includes("poisoned_context"), "no poisoned_context on first turn");
+		assert.ok(!h.sendUserMessages.some((m) => m.includes("/clear")), "no /clear advise");
+	} finally {
+		if (prevAuto === undefined) delete process.env.MEGACOMPACT_AUTO;
+		else process.env.MEGACOMPACT_AUTO = prevAuto;
+	}
+});
+
+test("R8(b): repeated 'No healthy target' x3 stays transient", async () => {
+	const prevAuto = process.env.MEGACOMPACT_AUTO;
+	const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	process.env.MEGACOMPACT_AUTO = "false";
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	try {
+		const h = harness();
+		await r7RepeatTurns(h, R8_NO_HEALTHY_TARGET, 3);
+		assertStaysTransient(h, "no-healthy-target x3");
+	} finally {
+		if (prevAuto === undefined) delete process.env.MEGACOMPACT_AUTO;
+		else process.env.MEGACOMPACT_AUTO = prevAuto;
+		if (prevBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
+	}
+});
+
+test("R8(c): repeated 'All targets failed / socket closed' x3 stays transient", async () => {
+	const prevAuto = process.env.MEGACOMPACT_AUTO;
+	const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	process.env.MEGACOMPACT_AUTO = "false";
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	try {
+		const h = harness();
+		await r7RepeatTurns(h, R8_SOCKET_CLOSED, 3);
+		assertStaysTransient(h, "all-targets-failed x3");
+	} finally {
+		if (prevAuto === undefined) delete process.env.MEGACOMPACT_AUTO;
+		else process.env.MEGACOMPACT_AUTO = prevAuto;
+		if (prevBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
+	}
+});
+
+
+test("R9 handler: bare 0-token error turn x1 is transient (no poisoned, no advise)", async () => {
+	const h = harness();
+	const origBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	process.env.MEGACOMPACT_AUTO = "false";
+	try {
+		// Single bare 0-token error turn
+		await s38TurnEndUsage(h, "error", undefined, 0);
+		await h.fire("turn_start", { type: "turn_start", turnIndex: 2 }, h.ctx());
+		await new Promise((r) => setTimeout(r, 3));
+		// No poisoned_context event should be logged
+		assert.ok(!eventTypes(h.stateDir).includes("poisoned_context"), "bare 0-token single turn must not log poisoned_context");
+		// No /clear advise message
+		assert.equal(h.sendUserMessages.filter((m) => m.includes("/clear")).length, 0, "bare 0-token single turn must not /clear");
+		// An error_retry event should be emitted
+		assert.ok(eventTypes(h.stateDir).includes("error_retry"), "bare 0-token single turn must trigger error_retry");
+	} finally {
+		if (origBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = origBackoff;
+		delete process.env.MEGACOMPACT_AUTO;
+	}
+});
+
+test("R9 handler: bare 0-token error x3 upgrades to poisoned at threshold (corroborated)", async () => {
+	const h = harness();
+	const origBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	process.env.MEGACOMPACT_AUTO = "false";
+	try {
+		// Three consecutive bare 0-token error turns
+		for (let i = 0; i < 3; i++) {
+			await s38TurnEndUsage(h, "error", undefined, 0);
+			await h.fire("turn_start", { type: "turn_start", turnIndex: i + 2 }, h.ctx());
+			await new Promise((r) => setTimeout(r, 3));
+		}
+		// poisoned_context event should eventually be logged
+		assert.ok(eventTypes(h.stateDir).includes("poisoned_context"), "bare 0-token x3 must log poisoned_context");
+		// Exactly one /clear advise total
+		assert.equal(h.sendUserMessages.filter((m) => m.includes("/clear")).length, 1, "bare 0-token x3 must produce exactly one /clear advise");
+	} finally {
+		if (origBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = origBackoff;
+		delete process.env.MEGACOMPACT_AUTO;
+	}
+});
+
+
+// ---- R10 tests: provider outage advisory (2026-07-30) ----
+
+test("R10: 3 consecutive transient failures fire one provider-outage advisory (no /clear)", async () => {
+	const origBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	const origSession = process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX;
+	const origRepeat = process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX = "999";
+	process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = "999";
+	try {
+		const h = harness();
+		for (let i = 0; i < 3; i++) {
+			await s38TurnEnd(h, "error", "socket hang up");
+			await h.fire("turn_start", { type: "turn_start", turnIndex: i + 2 }, h.ctx());
+			await new Promise((r) => setTimeout(r, 3));
+		}
+		const providerMessages = h.sendUserMessages.filter((m) => m.includes("provider is having issues"));
+		assert.equal(providerMessages.length, 1, "exactly one provider-outage advisory");
+		const clearMessages = h.sendUserMessages.filter((m) => m.includes("/clear"));
+		assert.equal(clearMessages.length, 0, "no /clear in outage advisory");
+		assert.ok(eventTypes(h.stateDir).includes("error_retry"), "error_retry events present");
+	} finally {
+		if (origBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = origBackoff;
+		if (origSession === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX;
+		else process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX = origSession;
+		if (origRepeat === undefined) delete process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
+		else process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = origRepeat;
+	}
+});
+
+test("R10: advisory fires once per outage episode", async () => {
+	const origBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	const origSession = process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX;
+	const origRepeat = process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX = "999";
+	process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = "999";
+	try {
+		const h = harness();
+		// Episode 1: 5 consecutive transient failures → 1 advisory at consecutiveErrors=3.
+		for (let i = 0; i < 5; i++) {
+			await s38TurnEnd(h, "error", "socket hang up");
+			await h.fire("turn_start", { type: "turn_start", turnIndex: i + 2 }, h.ctx());
+			await new Promise((r) => setTimeout(r, 3));
+		}
+		assert.equal(h.sendUserMessages.filter((m) => m.includes("provider is having issues")).length, 1, "episode 1: 1 advisory after 5 transient turns");
+
+		// Success turn: resets consecutiveErrors + providerOutageAdvised.
+		await s38TurnEnd(h, "stop");
+		await h.fire("turn_start", { type: "turn_start", turnIndex: 8 }, h.ctx());
+		await new Promise((r) => setTimeout(r, 3));
+
+		// Episode 2: 3 more transient failures → second advisory.
+		for (let i = 0; i < 3; i++) {
+			await s38TurnEnd(h, "error", "socket hang up");
+			await h.fire("turn_start", { type: "turn_start", turnIndex: 9 + i }, h.ctx());
+			await new Promise((r) => setTimeout(r, 3));
+		}
+		assert.equal(h.sendUserMessages.filter((m) => m.includes("provider is having issues")).length, 2, "episode 2: exactly 2 advisories total");
+	} finally {
+		if (origBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = origBackoff;
+		if (origSession === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX;
+		else process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX = origSession;
+		if (origRepeat === undefined) delete process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
+		else process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = origRepeat;
+	}
+});
+
+test("R10: MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD=0 disables the advisory", async () => {
+	const origBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	const origSession = process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX;
+	const origRepeat = process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
+	const origThreshold = process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD;
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX = "999";
+	process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = "999";
+	process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD = "0";
+	try {
+		const h = harness();
+		for (let i = 0; i < 5; i++) {
+			await s38TurnEnd(h, "error", "socket hang up");
+			await h.fire("turn_start", { type: "turn_start", turnIndex: i + 2 }, h.ctx());
+			await new Promise((r) => setTimeout(r, 3));
+		}
+		const providerMessages = h.sendUserMessages.filter((m) => m.includes("provider is having issues"));
+		assert.equal(providerMessages.length, 0, "threshold=0: zero advisory messages");
+	} finally {
+		if (origBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = origBackoff;
+		if (origSession === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX;
+		else process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX = origSession;
+		if (origRepeat === undefined) delete process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
+		else process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = origRepeat;
+		if (origThreshold === undefined) delete process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD;
+		else process.env.MEGACOMPACT_PROVIDER_OUTAGE_THRESHOLD = origThreshold;
+	}
+});
+
+test("R10: poisoned-context path does NOT fire the outage advisory", async () => {
+	// Single "Request failed — please retry." 0-token turn: poisoned on turn 1
+	// (auto=false to skip the compact attempt).
+	const origBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	const origAuto = process.env.MEGACOMPACT_AUTO;
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	process.env.MEGACOMPACT_AUTO = "false";
+	try {
+		const h = harness();
+		await s38TurnEndUsage(h, "error", "Request failed — please retry.", 0);
+		// /clear advise should fire.
+		assert.ok(h.sendUserMessages.some((m) => m.includes("/clear")), "poisoned: /clear advise fires");
+		// No provider-outage advisory.
+		assert.equal(h.sendUserMessages.filter((m) => m.includes("provider is having issues")).length, 0, "poisoned path: no outage advisory");
+	} finally {
+		if (origBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = origBackoff;
+		if (origAuto === undefined) delete process.env.MEGACOMPACT_AUTO;
+		else process.env.MEGACOMPACT_AUTO = origAuto;
+	}
+});
+
+
+// ── R11: diagnostic signal + rawText logging ──────────────────────────────
+
+test("R11 classifier: classifyErrorDetailed signal tags", () => {
+	// length → signal 'length-guard', category null
+	const len = classifyErrorDetailedFn({ stopReason: "length" });
+	assert.equal(len.signal, "length-guard");
+	assert.equal(len.category, null);
+
+	// aborted → 'cancelled'
+	const abort = classifyErrorDetailedFn({ stopReason: "aborted" });
+	assert.equal(abort.signal, "cancelled");
+	assert.equal(abort.category, "cancelled");
+
+	// stop → 'success'
+	assert.equal(classifyErrorDetailedFn({ stopReason: "stop" }).signal, "success");
+
+	// compaction-noop
+	const compact = classifyErrorDetailedFn("Error: Already compacted");
+	assert.equal(compact.signal, "compaction-noop");
+	assert.equal(compact.category, "compaction-noop");
+
+	// context-overflow
+	const overflow = classifyErrorDetailedFn("too long for this model");
+	assert.equal(overflow.signal, "context-overflow");
+	assert.equal(overflow.category, "context-overflow");
+
+	// transient-marker (text-matched)
+	const tm = classifyErrorDetailedFn("socket hang up");
+	assert.equal(tm.signal, "transient-marker");
+	assert.equal(tm.category, "transient");
+
+	// transient-status (HTTP status-matched) — use outer-level status + non-5xx-matching error text
+	// so extractHttpStatus finds it but the text doesn't contain "5xx" digits
+	const ts = classifyErrorDetailedFn({ stopReason: "error", error: { type: "upstream_error", message: "request aborted" }, status: 502 });
+	assert.equal(ts.signal, "transient-status");
+	assert.equal(ts.category, "transient");
+	assert.equal(ts.httpStatus, 502);
+
+	// permanent-status
+	const ps = classifyErrorDetailedFn({ stopReason: "error", error: { type: "auth_error", message: "session expired" }, status: 401 });
+	assert.equal(ps.signal, "permanent-status");
+	assert.equal(ps.category, "permanent");
+	assert.equal(ps.httpStatus, 401);
+
+	// poisoned-invalid-request (needs stopReason so sr is non-empty)
+	const pir = classifyErrorDetailedFn({ stopReason: "error", error: { type: "invalid_request_error", message: "bad request" } });
+	assert.equal(pir.signal, "poisoned-invalid-request");
+	assert.equal(pir.category, "poisoned-context");
+
+	// poisoned-request-failed (from R9/R3)
+	const prf = classifyErrorDetailedFn("Request failed — please retry.");
+	assert.equal(prf.signal, "poisoned-request-failed");
+	assert.equal(prf.category, "poisoned-context");
+
+	// bare-0-token (R9) — usage present with 0 tokens, stopReason error
+	const b0 = classifyErrorDetailedFn({ stopReason: "error", usage: { inputTokens: 0, outputTokens: 0 } });
+	assert.equal(b0.signal, "bare-0-token");
+	assert.equal(b0.category, "transient");
+
+	// generic-error
+	const ge = classifyErrorDetailedFn({ stopReason: "error", content: "something odd" });
+	assert.equal(ge.signal, "generic-error");
+	assert.equal(ge.category, "transient");
+
+	// permanent-auth
+	const pa = classifyErrorDetailedFn("unauthorized: invalid api key");
+	assert.equal(pa.signal, "permanent-auth");
+	assert.equal(pa.category, "permanent");
+
+	// unknown (plain string, no markers)
+	const unk = classifyErrorDetailedFn("some random text with no pattern");
+	assert.equal(unk.signal, "unknown");
+	assert.equal(unk.category, null);
+});
+
+test("R11: poisoned_context event carries signal + rawText", async () => {
+	const prevAuto = process.env.MEGACOMPACT_AUTO;
+	process.env.MEGACOMPACT_AUTO = "false";
+	try {
+		const h = harness();
+		await s38TurnEndUsage(h, "error", "Request failed — please retry.", 0);
+		const payloads = eventPayloads(h.stateDir, "poisoned_context");
+		assert.ok(payloads.length >= 1, "expected a poisoned_context event");
+		const last = payloads[payloads.length - 1];
+		assert.equal(last.signal, "poisoned-request-failed", "signal field present and correct");
+		assert.ok(
+			typeof last.rawText === "string" && (last.rawText as string).toLowerCase().includes("request failed"),
+			"rawText contains error text",
+		);
+	} finally {
+		if (prevAuto === undefined) delete process.env.MEGACOMPACT_AUTO;
+		else process.env.MEGACOMPACT_AUTO = prevAuto;
+	}
+});
+
+test("R11: provider outage advisory payload carries signal + rawText", async () => {
+	const origBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	const origSession = process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX;
+	const origRepeat = process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX = "999";
+	process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = "999";
+	try {
+		const h = harness();
+		for (let i = 0; i < 3; i++) {
+			await s38TurnEnd(h, "error", "socket hang up");
+			await h.fire("turn_start", { type: "turn_start", turnIndex: i + 2 }, h.ctx());
+			await new Promise((r) => setTimeout(r, 3));
+		}
+		const payloads = eventPayloads(h.stateDir, "provider_outage_advised");
+		assert.ok(payloads.length >= 1, "expected provider_outage_advised event");
+		const last = payloads[payloads.length - 1];
+		assert.equal(last.signal, "transient-marker", "outage event carries signal");
+		assert.ok(
+			typeof last.rawText === "string" && (last.rawText as string).includes("socket hang up"),
+			"outage event carries rawText",
+		);
+	} finally {
+		if (origBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = origBackoff;
+		if (origSession === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX;
+		else process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX = origSession;
+		if (origRepeat === undefined) delete process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
+		else process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = origRepeat;
+	}
+});
+
+test("R11: repeat-upgrade-declined signal is transient-marker for retryable marker", () => {
+	// The repeat-upgrade-declined log fires when isKnownRetryable(signature) is true
+	// but the count hasn't reached the threshold yet (decline path).  Since the
+	// test harness doesn't expose internal logger output, we unit-test the signal
+	// tag that the handler would log.
+	const detail = classifyErrorDetailedFn("Request timed out or failed. Try again");
+	assert.equal(detail.signal, "transient-marker", "repeat-guard text gets transient-marker signal");
+	assert.equal(detail.category, "transient");
+});
+
+// ── R12: normalize volatile tokens in extractErrorSignature ──────────────
+
+test("R12: extractErrorSignature normalizes volatile tokens", () => {
+	// Model/provider paths → <model>
+	const sigA = extractErrorSignatureFn("All targets failed: modal/zai-org/GLM-5.1-FP8. Last error: boom");
+	const sigB = extractErrorSignatureFn("All targets failed: hf/other-org/GLM-4.7. Last error: boom");
+	assert.equal(sigA, sigB, "different model paths must normalize to the same signature");
+	assert.ok(sigA.includes("<model>"), "normalized sig should contain <model>");
+	assert.ok(!sigA.includes("modal"), "original model alias must be replaced");
+	assert.ok(!sigA.includes("hf/other-org"), "original model alias must be replaced");
+
+	// IP:port → <ip>
+	const ipA = extractErrorSignatureFn("connect ETIMEDOUT 10.0.0.1:443");
+	const ipB = extractErrorSignatureFn("connect ETIMEDOUT 192.168.0.2:8443");
+	assert.equal(ipA, ipB, "different IPs must normalize to the same signature");
+	assert.ok(ipA.includes("<ip>"), "normalized sig should contain <ip>");
+	assert.ok(!ipA.includes("10.0.0.1"), "original IP must be replaced");
+
+	// Hex ids (8+ chars) → <hex>
+	const hexA = extractErrorSignatureFn("request id a1b2c3d4e5f6 failed");
+	const hexB = extractErrorSignatureFn("request id 9f8e7d6c5b4a failed");
+	assert.equal(hexA, hexB, "different hex ids must normalize to the same signature");
+	assert.ok(hexA.includes("<hex>"), "normalized sig should contain <hex>");
+
+	// "after N attempts" → "after <n> attempts"
+	const rA = extractErrorSignatureFn("Retry failed after 3 attempts: boom");
+	const rB = extractErrorSignatureFn("Retry failed after 5 attempts: boom");
+	assert.equal(rA, rB, "different attempt counts must normalize to the same signature");
+	assert.ok(rA.includes("after <n> attempts"), "normalized sig should contain 'after <n> attempts'");
+
+	// Status codes (3-digit) survive — NOT merged by the 4+ digit rule
+	const s500 = extractErrorSignatureFn("error 500 now");
+	const s502 = extractErrorSignatureFn("error 502 now");
+	assert.notEqual(s500, s502, "3-digit status codes must NOT merge");
+
+	// Empty + bare 0-token error object still returns "bare-0-token-error" (R9 preserved)
+	assert.equal(
+		extractErrorSignatureFn({ stopReason: "error", usage: { inputTokens: 0, outputTokens: 0 } }),
+		"bare-0-token-error",
+		"R9 bare-0-token fallback must survive normalization change",
+	);
+	// Empty content with no usage keeps returning ""
+	assert.equal(extractErrorSignatureFn({ stopReason: "error" }), "", "bare error with no usage must return empty");
+});
+
+test("R12: alternating-but-equivalent marker-less errors upgrade at threshold", async () => {
+	const origBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	const origRepeat = process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = "3";
+	process.env.MEGACOMPACT_AUTO = "false";
+	try {
+		const h = harness();
+		// Two texts that differ ONLY in model alias — no known-retryable markers.
+		// "upstream rejected alias modal/a-b/X-1" has no network/timeout/socket/
+		// 429/5xx markers in KNOWN_RETRYABLE_TRANSIENT_PATTERN.
+		const textA = "upstream rejected alias modal/a-b/X-1";
+		const textB = "upstream rejected alias hf/c-d/Y-2";
+		// Turn 1 (textA): count → 1
+		await s38TurnEnd(h, "error", textA);
+		await h.fire("turn_start", { type: "turn_start", turnIndex: 2 }, h.ctx());
+		await new Promise((r) => setTimeout(r, 3));
+		// Turn 2 (textB): normalized matches → count → 2
+		await s38TurnEnd(h, "error", textB);
+		await h.fire("turn_start", { type: "turn_start", turnIndex: 3 }, h.ctx());
+		await new Promise((r) => setTimeout(r, 3));
+		// Turn 3 (textA again): normalized matches → count → 3 → upgrade
+		await s38TurnEnd(h, "error", textA);
+		await h.fire("turn_start", { type: "turn_start", turnIndex: 4 }, h.ctx());
+		await new Promise((r) => setTimeout(r, 3));
+		assert.ok(eventTypes(h.stateDir).includes("poisoned_context"), "equivalent alternating errors must upgrade to poisoned at threshold");
+		assert.equal(h.sendUserMessages.filter((m) => m.includes("/clear")).length, 1, "exactly one /clear advise");
+	} finally {
+		if (origBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = origBackoff;
+		if (origRepeat === undefined) delete process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
+		else process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = origRepeat;
+		delete process.env.MEGACOMPACT_AUTO;
+	}
+});
+
+test("R12: genuinely different marker-less errors do NOT merge", async () => {
+	// Characterization/control test: two truly distinct error messages must NOT
+	// merge under normalization — their signatures stay different and the repeat
+	// counter never reaches threshold.  This should pass both before and after
+	// the R12 normalization change (guard against over-normalization).
+	const origBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	const origRepeat = process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = "3";
+	process.env.MEGACOMPACT_AUTO = "false";
+	try {
+		const h = harness();
+		const textA = "upstream rejected the request";
+		const textB = "provider returned an empty response";
+		// Alternate a,b,a,b — counter never exceeds 1.
+		for (let i = 0; i < 4; i++) {
+			await s38TurnEnd(h, "error", i % 2 === 0 ? textA : textB);
+			await h.fire("turn_start", { type: "turn_start", turnIndex: i + 2 }, h.ctx());
+			await new Promise((r) => setTimeout(r, 3));
+		}
+		assert.ok(!eventTypes(h.stateDir).includes("poisoned_context"), "truly different errors must NOT trigger poisoned_context");
+		assert.equal(h.sendUserMessages.filter((m) => m.includes("/clear")).length, 0, "no /clear for non-repeating errors");
+	} finally {
+		if (origBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = origBackoff;
+		if (origRepeat === undefined) delete process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD;
+		else process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = origRepeat;
+		delete process.env.MEGACOMPACT_AUTO;
+	}
+});
+
 test("cleanup", async () => {
 	// PGlite WASM close can hang; race with a timeout to prevent 40-min hangs.
 	try {
@@ -661,8 +1422,12 @@ test("cleanup", async () => {
 	// Force-exit: each harness() creates a MegaRuntime with an fs.watch
 	// game-state watcher that is never disposed (no session_shutdown in tests).
 	// Those handles keep the event loop alive indefinitely after all tests
-	// complete, so `node --test` (without --test-force-exit) would hang. The
-	// streaming reporter has already printed every test result by this point;
-	// process.exit(0) just forces the exit the watchers are preventing.
+	// complete, so `node --test` (without --test-force-exit) would hang.
+	// Drain stdout/stderr, then defer the exit: a bare process.exit() discards
+	// unflushed pipe buffers — observed 2026-07-30: when piped, the trailing
+	// tests' results and the run summary silently vanished from the report.
+	await new Promise((r) => process.stdout.write("", r));
+	await new Promise((r) => process.stderr.write("", r));
+	await new Promise((r) => setTimeout(r, 1500));
 	process.exit(0);
 });