pi-mega-compact 0.11.3 → 0.11.4

package/dist/extensions/mega-compact-s38.test.js

@@ -46,6 +46,26 @@ function eventTypes(stateDir) {
     } })
         .filter((t) => typeof t === "string");
 }
+/** R11: read events.log and return full JSON payloads for a given type. */
+function eventPayloads(stateDir, type) {
+    const { readFileSync: rf, existsSync: ex } = require("node:fs");
+    const { join: j } = require("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) => typeof p === "object" && p !== null && p.type === type);
+}
 /** Build a mock pi + ctx and load the extension into them. */
 function harness(opts = {}) {
     const stateDir = join(baseTmp, `run-${counter++}`);
@@ -109,7 +129,7 @@ function harness(opts = {}) {
         ctx: makeCtx, session,
     };
 }
-const { classifyError: classifyErrorFn } = require("./mega-events.js");
+const { classifyError: classifyErrorFn, classifyErrorDetailed: classifyErrorDetailedFn, extractErrorSignature: extractErrorSignatureFn } = require("./mega-events.js");
 /** 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. */
 async function s38TurnEnd(h, stopReason, text) {
@@ -270,15 +290,26 @@ 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 () => {
     const h = harness();
@@ -402,10 +433,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");
@@ -453,8 +487,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++) {
@@ -475,6 +512,10 @@ test("R6(a): 10 consecutive identical 0-token transient failures produce at most
             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;
     }
 });
 test("R6(b): poisoned-context fires zero retry nudges and exactly one advise message", async () => {
@@ -507,9 +548,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).
@@ -538,6 +582,10 @@ test("R6(c): transient burst retries with backoff gating — second immediate nu
             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;
     }
 });
 test("R6(d): user abort (stopReason aborted) never nudges, even across repeated aborts", async () => {
@@ -610,6 +658,14 @@ test("R3: repeated identical transient error text upgrades to poisoned-context a
             process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
     }
 });
+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
@@ -799,6 +855,513 @@ test("R7 classifier: bare network phrasings → 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.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.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 {