pi-mega-compact 0.8.24 → 0.8.26

package/dist/src/vector-search.js

@@ -14,10 +14,13 @@ import { cosineSimilarity } from "./embedder.js";
 import { normalizeSessionId } from "./store.js";
 import { mmrRerank } from "./dedup/mmr.js";
 import { topK } from "./dedup/topk.js";
-import { listCheckpoints, getCheckpoint, maxCheckpointTimestamp, } from "./store/sqlite.js";
+import { listCheckpoints, getCheckpoint, maxCheckpointTimestamp, maxRaptorNodeBuiltAt, } from "./store/sqlite.js";
 import { initVectorIndex, searchAsync as vectorIndexSearch, } from "./store/vectorIndex.js";
 import { rehydrateRaptorTree, isShadowMode } from "./dedup/raptor/index.js";
 import { stagedExpansion } from "./dedup/raptor/retrieval.js";
+import { multilevelRetrieval } from "./dedup/raptor/multilevel.js";
+import { Logger } from "./log.js";
+const logger = new Logger();
 // ---------------------------------------------------------------------------
 // raptorSearchHits — internal helper (NOT exported)
 // ---------------------------------------------------------------------------
@@ -25,8 +28,13 @@ import { stagedExpansion } from "./dedup/raptor/retrieval.js";
  * Serve the RAPTOR tree for a query (Fix D): rehydrate the persisted tree and
  * return its staged-expansion leaf hits as SearchHits. Returns [] when no tree
  * exists (small sessions — flat search remains the path). Best-effort/non-fatal.
+ *
+ * `checkpoints` is the caller's already-loaded, dedup-status-filtered checkpoint
+ * list — pass it in so the flat-search path and the RAPTOR merge path share ONE
+ * `listCheckpoints` call per `vectorSearch` (eliminates a redundant full scan +
+ * N-row hydration at 500+ checkpoints — QA perf review).
  */
-function raptorSearchHits(store, sid, query, k) {
+function raptorSearchHits(store, sid, query, k, checkpoints) {
     const t0 = Date.now();
     try {
         const stateDir = store.stateDir;
@@ -38,17 +46,93 @@ function raptorSearchHits(store, sid, query, k) {
         // RAPTOR_SHADOW_MODE is anything other than "false".
         if (isShadowMode())
             return [];
-        const tree = rehydrateRaptorTree(sid, stateDir);
+        // S25 gate (b): freshness + fallback guards with per-session cache.
+        // The cache avoids O(n·leaves) rehydrate on every search when the tree
+        // hasn't changed. Freshness is validated via maxRaptorNodeBuiltAt (cheap
+        // indexed MAX query) — if the persisted builtAt matches the cached builtAt,
+        // the tree hasn't been rebuilt and can be served from cache.
+        const cacheKey = `${stateDir}::${sid}`;
+        const cached = store.raptorCache.get(cacheKey);
+        const latestBuiltAt = maxRaptorNodeBuiltAt(sid, stateDir);
+        let tree;
+        if (cached && cached.builtAt === latestBuiltAt && latestBuiltAt > 0) {
+            tree = cached.tree;
+        }
+        else {
+            tree = rehydrateRaptorTree(sid, stateDir);
+            if (tree && tree.rootId && !tree.timedOut) {
+                store.raptorCache.set(cacheKey, { tree, builtAt: tree.builtAt ?? 0 });
+            }
+            else {
+                store.raptorCache.delete(cacheKey);
+            }
+        }
         if (!tree || !tree.rootId)
             return [];
-        // S25 gate (b): freshness + fallback guards. Skip a tree built before the
-        // newest checkpoint (stale → may reference trimmed/deduped leaves) or one
-        // whose root is a budget-exhausted extractive fallback (level 99).
-        if (tree.timedOut)
-            return [];
+        // Freshness: skip persisted tree if the session has been compacted since
+        // the tree was built. The next runRaptor will rebuild.
         const maxTs = maxCheckpointTimestamp(sid, stateDir);
         if (tree.builtAt && tree.builtAt < maxTs)
             return [];
+        // S25: skip timedOut extractive-fallback trees (level === 99).
+        if (tree.timedOut)
+            return [];
+        // Use the caller's already-loaded checkpoint list (no second scan).
+        const all = checkpoints;
+        const qv = embedder.embed(query);
+        const hits = [];
+        // S42B: multi-level retrieval — score all tree levels (leaves + internal
+        // clusters), expand cluster hits to their leaf descendants, dedup overlaps,
+        // and MMR-rerank. Default ON (RAPTOR_MULTILEVEL_ENABLED). When OFF, the
+        // leaf-only stagedExpansion path below is used (identical to pre-S42B).
+        if (cfg.RAPTOR_MULTILEVEL_ENABLED) {
+            const mlHits = multilevelRetrieval(query, tree, {
+                embedder,
+                levelWeights: cfg.RAPTOR_LEVEL_WEIGHTS,
+                leafExpansion: cfg.RAPTOR_LEAF_EXPANSION,
+                maxLeafExpansion: cfg.RAPTOR_MAX_LEAF_EXPANSION,
+                k,
+                mmrLambda: cfg.MMR_LAMBDA,
+            });
+            if (mlHits.length === 0)
+                return [];
+            for (const mh of mlHits) {
+                // Leaf hits: nodeId IS the checkpointId — hydrate from the stored list.
+                const cp = all.find((c) => c.checkpointId === mh.nodeId);
+                if (cp) {
+                    hits.push({ checkpoint: cp, score: mh.score });
+                    continue;
+                }
+                // Orphaned leaf (checkpoint missing from the stored list, e.g. SemDeDup
+                // removed) — skip; synthesizing it would yield an empty cluster block.
+                if (mh.isLeaf)
+                    continue;
+                // Cluster hit: synthesize a SearchHit so the recall block can surface
+                // the hierarchical summary (not a stored checkpoint). The minimal
+                // StoredCheckpoint carries the node's centroid embedding for any
+                // downstream cosine / MMR the caller does.
+                hits.push({
+                    checkpoint: {
+                        checkpointId: mh.nodeId,
+                        sessionId: sid,
+                        summary: mh.summary,
+                        keyDecisions: [],
+                        nextSteps: [],
+                        filesModified: [],
+                        tokenEstimate: 0,
+                        regionHash: `raptor:${mh.nodeId}`,
+                        embedding: mh.embedding,
+                        timestamp: tree.builtAt ?? Date.now(),
+                    },
+                    score: mh.score,
+                    raptorSummary: mh.summary,
+                    raptorLevel: mh.level,
+                });
+            }
+            record("RAPTOR", hits.length > 0 ? "new" : "mark_only", `ml=${mlHits.length}`, Date.now() - t0);
+            return hits;
+        }
+        // S42B: flag OFF — leaf-only stagedExpansion (pre-S42B production path).
         const leafIds = stagedExpansion(query, tree, {
             embedder,
             k,
@@ -57,20 +141,24 @@ function raptorSearchHits(store, sid, query, k) {
         });
         if (leafIds.length === 0)
             return [];
-        const all = listCheckpoints(sid, stateDir).filter((cp) => cp.dedupStatus !== "removed");
-        const qv = embedder.embed(query);
-        const hits = [];
         for (const id of leafIds) {
             const cp = all.find((c) => c.checkpointId === id);
             if (cp)
-                hits.push({ checkpoint: cp, score: cosineSimilarity(qv, cp.embedding) });
+                hits.push({
+                    checkpoint: cp,
+                    score: cosineSimilarity(qv, cp.embedding),
+                });
         }
         // S25 monitoring: emit a raptor_serve decision so canary.ts can track
         // p95 latency + the tier's live traffic (non-fatal, best-effort).
         record("RAPTOR", hits.length > 0 ? "new" : "mark_only", `leaves=${leafIds.length}`, Date.now() - t0);
         return hits;
     }
-    catch {
+    catch (e) {
+        logger.warn("raptor_search_error", {
+            error: String(e),
+            sessionId: sid,
+        });
         return [];
     }
 }
@@ -109,7 +197,7 @@ export function vectorSearch(store, sessionId, query, k = 3) {
     // RAPTOR returns fewer, broader hits (O(log n) high-level nodes) than the
     // O(n) flat leaves, tightening the block at read time.
     if (cfg.RAPTOR_ENABLED) {
-        const rh = raptorSearchHits(store, sid, query, k);
+        const rh = raptorSearchHits(store, sid, query, k, checkpoints);
         if (rh.length > 0) {
             const merged = [...window];
             for (const h of rh) {
@@ -176,7 +264,11 @@ export async function vectorSearchAsync(store, sessionId, query, k = 3, opts = {
         const cp = getCheckpoint(h.sessionId, h.checkpointId, h.repoId);
         if (cp && cp.dedupStatus !== "removed") {
             const crossRepo = opts.crossRepo && selfRepo && h.repoId && h.repoId !== selfRepo;
-            hydrated.push({ checkpoint: cp, score: h.score, repoId: crossRepo ? h.repoId : undefined });
+            hydrated.push({
+                checkpoint: cp,
+                score: h.score,
+                repoId: crossRepo ? h.repoId : undefined,
+            });
         }
     }
     if (hydrated.length === 0)

package/dist/src/vectorStore.js

@@ -9,11 +9,11 @@
  */
 import { createHash } from "node:crypto";
 import { cosineSimilarity, defaultEmbedder } from "./embedder.js";
-import { loadDedupConfig } from "./config/dedup.js";
+import { loadDedupConfig, } from "./config/dedup.js";
 import { logDecision } from "./monitoring.js";
 import { getStateDir, normalizeSessionId, compressSmart } from "./store.js";
 import { computeContentDigest } from "./dedup/digest.js";
-import { minhashSignature, SIGNATURE_VERSION, NUM_HASHES } from "./dedup/l1-minhash.js";
+import { minhashSignature, SIGNATURE_VERSION, NUM_HASHES, } from "./dedup/l1-minhash.js";
 import { lshBands } from "./dedup/l1-lsh.js";
 import { isNearDuplicate } from "./dedup/l1-verify.js";
 import { openBloom, saveBloom } from "./store/bloom.js";
@@ -47,6 +47,10 @@ export class VectorStore {
      * global index keys on repoId so recall can span repos.
      */
     repoId;
+    /** S25: per-session cached rehydrated RaptorTree. Keyed by sessionId.
+     *  Freshness-validated via maxRaptorNodeBuiltAt on each lookup — a cheap
+     *  indexed MAX query replaces the O(n·leaves) rehydrate on every search. */
+    raptorCache = new Map();
     constructor(opts = {}) {
         this.embedder = opts.embedder ?? defaultEmbedder();
         this.stateDir = opts.stateDir ?? getStateDir();
@@ -125,7 +129,11 @@ export class VectorStore {
                     bumpDedupStats(true, this.stateDir);
                     // Deduped: whole original region discarded, nothing new stored.
                     addTokensSaved(origTokens, this.stateDir);
-                    const r = { checkpoint: contentMatch, deduped: true, reason: "contentHash" };
+                    const r = {
+                        checkpoint: contentMatch,
+                        deduped: true,
+                        reason: "contentHash",
+                    };
                     this.record("L0", "deduped", "contentHash", Date.now() - t0);
                     onTier?.({ tier: "L0", status: "deduped", detail: "contentHash" });
                     return r;
@@ -143,7 +151,11 @@ export class VectorStore {
                     bumpDedupStats(true, this.stateDir);
                     // Deduped: whole original region discarded, nothing new stored.
                     addTokensSaved(origTokens, this.stateDir);
-                    const r = { checkpoint: regionMatch, deduped: true, reason: "regionHash" };
+                    const r = {
+                        checkpoint: regionMatch,
+                        deduped: true,
+                        reason: "regionHash",
+                    };
                     this.record("L0", "deduped", "regionHash", Date.now() - t0);
                     onTier?.({ tier: "L0", status: "deduped", detail: "regionHash" });
                     return r;
@@ -167,7 +179,11 @@ export class VectorStore {
                     bumpDedupStats(true, this.stateDir);
                     // Deduped: whole original region discarded, nothing new stored.
                     addTokensSaved(origTokens, this.stateDir);
-                    const r = { checkpoint: summaryMatch, deduped: true, reason: "summaryHash" };
+                    const r = {
+                        checkpoint: summaryMatch,
+                        deduped: true,
+                        reason: "summaryHash",
+                    };
                     this.record("L0", "deduped", "summaryHash", Date.now() - t0);
                     onTier?.({ tier: "L0", status: "deduped", detail: "summaryHash" });
                     return r;
@@ -226,14 +242,26 @@ export class VectorStore {
                     bumpDedupStats(true, this.stateDir);
                     // Deduped: whole original region discarded, nothing new stored.
                     addTokensSaved(origTokens, this.stateDir);
-                    const r = { checkpoint: nearest.checkpoint, deduped: true, reason: "contentSimilarity" };
+                    const r = {
+                        checkpoint: nearest.checkpoint,
+                        deduped: true,
+                        reason: "contentSimilarity",
+                    };
                     this.record("L2", "deduped", "contentSimilarity", Date.now() - t0);
-                    onTier?.({ tier: "L2", status: "deduped", detail: nearest.sim.toFixed(2) });
+                    onTier?.({
+                        tier: "L2",
+                        status: "deduped",
+                        detail: nearest.sim.toFixed(2),
+                    });
                     return r;
                 }
                 markOnly = "L2";
             }
-            onTier?.({ tier: "L2", status: "passed", detail: `best ${nearest.sim.toFixed(2)}` });
+            onTier?.({
+                tier: "L2",
+                status: "passed",
+                detail: `best ${nearest.sim.toFixed(2)}`,
+            });
         }
         // 4. Genuinely new — create checkpoint
         const checkpointId = nextCheckpointId(sessionId, this.stateDir);

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

@@ -119,6 +119,17 @@ async function s38TurnEnd(h: ReturnType<typeof harness>, stopReason: string | un
 	await h.fire("turn_end", { type: "turn_end", turnIndex: 1, message }, lowCtx);
 }
 
+/** R3 helper: like s38TurnEnd but attaches a `usage` object so the classifier's
+ *  0-token poisoned-context signal is exercised (usage PRESENT with 0 tokens).
+ *  Pass `tokens` > 0 to simulate a turn that reached the model. */
+async function s38TurnEndUsage(h: ReturnType<typeof harness>, stopReason: string | undefined, text: string | undefined, tokens: number) {
+	const lowCtx = h.ctx({ isIdle: () => true, hasPendingMessages: () => false, getContextUsage: () => ({ tokens: 100, contextWindow: 200000, percent: 0 }) });
+	const message: any = { role: "assistant", usage: { inputTokens: tokens, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 } };
+	if (stopReason !== undefined) message.stopReason = stopReason;
+	if (text) message.content = text;
+	await h.fire("turn_end", { type: "turn_end", turnIndex: 1, message }, lowCtx);
+}
+
 // ---- classifier unit tests (no extension harness needed) ----
 
 test("S38: classifyError returns 'transient' for error stopReason", () => {
@@ -301,13 +312,20 @@ test("S38: compaction-noop does NOT fire pi.sendUserMessage (NOT retryable)", as
 	assert.ok(eventTypes(h.stateDir).includes("compaction_noop_diagnostic"));
 });
 
-test("S38: retry fires up to max (5) for transient errors, then stops", async () => {
+test("S38: R1 burst of immediate transient errors fires 1 nudge (dedup), rest suppressed by retryNudgePending", async () => {
+	// R1 redesign: a burst of immediate error turn_ends (no turn_start between)
+	// produces ONE nudge — the rest are suppressed by retryNudgePending because
+	// 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");
-	assert.equal(h.sendUserMessages.length, 5, "transient: 5 retry nudges (<= max 5)");
-	await s38TurnEnd(h, "error", "internal server error");
-	assert.equal(h.sendUserMessages.length, 5, "transient: exhausted -> no 6th nudge");
-	assert.ok(eventTypes(h.stateDir).includes("error_retry_exhausted"), "exhausted event logged");
+	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");
 });
 
 test("S38: retry fires 1x for permanent errors then stops", async () => {
@@ -320,18 +338,31 @@ test("S38: retry fires 1x for permanent errors then stops", async () => {
 });
 
 test("S38: successful turn (stop/toolUse) resets the retry counter", async () => {
-	const h = harness();
-	await s38TurnEnd(h, "error", "5xx server error");
-	assert.equal(h.sendUserMessages.length, 1, "first transient: 1 nudge");
-	await s38TurnEnd(h, "stop");
-	await s38TurnEnd(h, "error", "5xx server error");
-	assert.equal(h.sendUserMessages.length, 2, "success reset counter -> transient fires again from count=1");
+	// R1: backoff is now gating, so use a tiny backoff + small wait to let the
+	// second nudge fire after the success reset clears retryNudgePending (R4).
+	const prev = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	try {
+		const h = harness();
+		await s38TurnEnd(h, "error", "5xx server error 0");
+		assert.equal(h.sendUserMessages.length, 1, "first transient: 1 nudge");
+		await s38TurnEnd(h, "stop");
+		assert.equal(h.sendUserMessages.length, 1, "success: no nudge, resets pending (R4)");
+		await new Promise((r) => setTimeout(r, 5)); // let backoff elapse
+		await s38TurnEnd(h, "error", "5xx server error 1");
+		assert.equal(h.sendUserMessages.length, 2, "success reset -> transient fires again from count=1");
+	} finally {
+		if (prev === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prev;
+	}
 });
 
 test("S38: error_retry_exhausted event logged when max exceeded", async () => {
+	// R3: "malformed bad request" is now poisoned-context (not permanent), so
+	// use an auth-derived permanent error to exercise the per-burst exhausted path.
 	const h = harness();
-	await s38TurnEnd(h, "error", "malformed bad request");
-	await s38TurnEnd(h, "error", "malformed bad request");
+	await s38TurnEnd(h, "error", "unauthorized: invalid api key");
+	await s38TurnEnd(h, "error", "unauthorized: invalid api key");
 	assert.ok(eventTypes(h.stateDir).includes("error_retry_exhausted"), "error_retry_exhausted logged");
 });
 
@@ -414,10 +445,224 @@ 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");
+	// 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");
+});
+
+test("R3 classifier: ECONNRESET (0-token) → transient (network failures stay transient)", () => {
+	// R3: network failures must stay transient even with 0 tokens.
+	assert.equal(classifyErrorFn({ stopReason: "error", content: "ECONNRESET", usage: { inputTokens: 0, outputTokens: 0 } }), "transient");
+	assert.equal(classifyErrorFn({ stopReason: "error", content: "connection reset by peer", usage: { inputTokens: 0, outputTokens: 0 } }), "transient");
+	assert.equal(classifyErrorFn({ stopReason: "error", content: "timeout", usage: { inputTokens: 0, outputTokens: 0 } }), "transient");
+	assert.equal(classifyErrorFn({ stopReason: "error", content: "503 service unavailable", usage: { inputTokens: 0, outputTokens: 0 } }), "transient");
+});
+
+test("R3 classifier: 'request failed' generic (no transient marker) → poisoned-context", () => {
+	// The exact incident phrasing: "Request failed — please retry." with no
+	// specific transient cause → deterministic rejection.
+	assert.equal(classifyErrorFn({ stopReason: "error", content: "Request failed — please retry.", usage: { inputTokens: 0, outputTokens: 0 } }), "poisoned-context");
+	assert.equal(classifyErrorFn("request failed"), "poisoned-context");
+});
+
+test("R3 classifier: orphaned-tool-result 400 (non-overflow) → poisoned-context", () => {
+	// Provider request-validation 400 that is NOT context-overflow: orphaned
+	// tool result / malformed message structure. Previously 'permanent' (1
+	// retry), now 'poisoned-context' (retry re-submits the same malformed shape).
+	assert.equal(classifyErrorFn('{"type":"invalid_request_error","message":"orphaned tool result: tooluse ids mismatch"}'), "poisoned-context");
+	assert.equal(classifyErrorFn("invalid request: unexpected role ordering"), "poisoned-context");
+	assert.equal(classifyErrorFn("malformed message structure"), "poisoned-context");
+});
+
+test("R3 classifier: context-overflow phrasing still context-overflow (not poisoned)", () => {
+	// Regression guard: the context-overflow check runs BEFORE the poisoned
+	// signals, so a 400 "too long" stays context-overflow (forced re-compact),
+	// not poisoned (advise + compact).
+	assert.equal(
+		classifyErrorFn({ stopReason: "error", content: "Your conversation is too long for this model's context window even after compaction.", usage: { inputTokens: 0, outputTokens: 0 } }),
+		"context-overflow",
+	);
+	assert.equal(
+		classifyErrorFn('{"type":"invalid_request_error","message":"maximum context length is 200000 tokens. requires at least 201070 tokens."}'),
+		"context-overflow",
+	);
+});
+
+test("R3 classifier: auth/permission stays permanent (not poisoned)", () => {
+	// Auth errors are retryable-once (permanent), not poisoned — the user can
+	// fix the key and retry.
+	assert.equal(classifyErrorFn("unauthorized: invalid api key"), "permanent");
+	assert.equal(classifyErrorFn("permission denied"), "permanent");
+});
+
+// ---- R6 integration tests (retry redesign) ----
+
+test("R6(a): 10 consecutive identical 0-token transient failures produce at most errorRetrySessionMax nudges", async () => {
+	// Use TRANSIENT 0-token failures (network text so they're transient, not
+	// poisoned) + turn_start + tiny backoff between each so the nudge is
+	// consumed and the next turn can fire. sessionMax default = 3. Repeat
+	// threshold raised to disable the stateful poisoned upgrade so this
+	// 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;
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	process.env.MEGACOMPACT_POISONED_REPEAT_THRESHOLD = "999";
+	try {
+		const h = harness();
+		for (let i = 0; i < 10; i++) {
+			// 0-token transient: usage present with 0 tokens + "connection reset" (network marker).
+			await s38TurnEndUsage(h, "error", "connection reset", 0);
+			await h.fire("turn_start", { type: "turn_start", turnIndex: i + 2 }, h.ctx());
+			await new Promise((r) => setTimeout(r, 3));
+		}
+		assert.ok(h.sendUserMessages.length <= 3, `R6(a): at most sessionMax (3) nudges, got ${h.sendUserMessages.length}`);
+		assert.ok(eventTypes(h.stateDir).includes("error_retry_session_exhausted"), "session_exhausted event logged");
+	} finally {
+		if (prevBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		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;
+	}
+});
+
+test("R6(b): poisoned-context fires zero retry nudges and exactly one advise message", async () => {
+	// auto=false so the guarded compact attempt (R3c) is skipped — this test
+	// focuses on the advise + no-retry behavior. The compact path is the same
+	// race-guarded deferred mechanism already covered by the context-overflow tests.
+	const prevAuto = process.env.MEGACOMPACT_AUTO;
+	process.env.MEGACOMPACT_AUTO = "false";
+	try {
+		const h = harness();
+		// 0-token generic "request failed" (no transient marker) → poisoned.
+		await s38TurnEndUsage(h, "error", "Request failed — please retry.", 0);
+		assert.equal(h.sendUserMessages.length, 1, "poisoned: exactly one advise message");
+		assert.ok(
+			h.sendUserMessages[0].includes("/clear") || h.sendUserMessages[0].includes("/new"),
+			"advise mentions /clear or /new",
+		);
+		assert.ok(eventTypes(h.stateDir).includes("poisoned_context"), "poisoned_context event logged");
+		assert.ok(!eventTypes(h.stateDir).includes("error_retry"), "poisoned: zero retry nudges (no error_retry event)");
+		// Second poisoned turn: advise throttled to one per session.
+		await s38TurnEndUsage(h, "error", "Request failed — please retry.", 0);
+		assert.equal(h.sendUserMessages.length, 1, "poisoned: advise throttled (one per session)");
+		assert.ok(eventTypes(h.stateDir).filter((t) => t === "poisoned_context").length >= 2, "poisoned_context logged each turn");
+	} finally {
+		if (prevAuto === undefined) delete process.env.MEGACOMPACT_AUTO;
+		else process.env.MEGACOMPACT_AUTO = prevAuto;
+	}
+});
+
+test("R6(c): transient burst retries with backoff gating — second immediate nudge suppressed while one pending", async () => {
+	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;
+	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
+	try {
+		const h = harness();
+		// Turn 1: transient → nudge 1 fires (pending=true, backoff=1ms).
+		await s38TurnEnd(h, "error", "internal server error 0");
+		assert.equal(h.sendUserMessages.length, 1, "first transient: 1 nudge");
+		// Turn 2: immediate (no turn_start) → suppressed by retryNudgePending.
+		await s38TurnEnd(h, "error", "internal server error 1");
+		assert.equal(h.sendUserMessages.length, 1, "second immediate nudge suppressed (retryNudgePending)");
+		// turn_start consumes the pending nudge (resets pending + count).
+		await h.fire("turn_start", { type: "turn_start", turnIndex: 2 }, h.ctx());
+		await new Promise((r) => setTimeout(r, 5)); // let backoff elapse
+		// Turn 3: transient → nudge 2 fires (pending cleared, backoff elapsed).
+		await s38TurnEnd(h, "error", "internal server error 2");
+		assert.equal(h.sendUserMessages.length, 2, "after turn_start + backoff: nudge fires");
+	} finally {
+		if (prevBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
+		if (prevSession === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_SESSION_MAX;
+		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;
+	}
+});
+
+test("R6(d): user abort (stopReason aborted) never nudges, even across repeated aborts", async () => {
+	const h = harness();
+	await s38TurnEnd(h, "aborted", "Operation aborted");
+	assert.equal(h.sendUserMessages.length, 0, "aborted: no nudge");
+	await s38TurnEnd(h, "aborted", "Aborted after 3 retry attempts");
+	assert.equal(h.sendUserMessages.length, 0, "aborted: still no nudge after repeated aborts");
+	assert.ok(eventTypes(h.stateDir).includes("error_retry_cancelled"), "cancelled event logged");
+});
+
+test("R6(e): success resets retry-nudge-pending state", async () => {
+	const prevBackoff = process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+	process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = "1";
+	try {
+		const h = harness();
+		// Turn 1: transient → nudge fires, pending=true.
+		await s38TurnEnd(h, "error", "internal server error 0");
+		assert.equal(h.sendUserMessages.length, 1, "first transient: 1 nudge");
+		// Turn 2: immediate transient → suppressed by pending (no turn_start).
+		await s38TurnEnd(h, "error", "internal server error 1");
+		assert.equal(h.sendUserMessages.length, 1, "second immediate suppressed by pending");
+		// Turn 3: success (stop) → resets pending (R4), no nudge.
+		await s38TurnEnd(h, "stop");
+		assert.equal(h.sendUserMessages.length, 1, "success: no nudge, resets pending");
+		await new Promise((r) => setTimeout(r, 5)); // let backoff elapse
+		// Turn 4: transient → nudge fires again (pending was reset by success).
+		await s38TurnEnd(h, "error", "internal server error 2");
+		assert.equal(h.sendUserMessages.length, 2, "after success reset pending: transient nudge fires");
+	} finally {
+		if (prevBackoff === undefined) delete process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS;
+		else process.env.MEGACOMPACT_ERROR_RETRY_BACKOFF_MS = prevBackoff;
+	}
+});
+
+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.
+	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();
+		// Turns 1-2: transient (repeatCount 1, 2) → nudges fire.
+		await s38TurnEnd(h, "error", "5xx server error");
+		await h.fire("turn_start", { type: "turn_start", turnIndex: 2 }, h.ctx());
+		await new Promise((r) => setTimeout(r, 3));
+		await s38TurnEnd(h, "error", "5xx server error");
+		await h.fire("turn_start", { type: "turn_start", turnIndex: 3 }, h.ctx());
+		await new Promise((r) => setTimeout(r, 3));
+		// Turn 3: repeatCount=3 ≥ threshold → upgraded to poisoned. No nudge, advise fires.
+		await s38TurnEnd(h, "error", "5xx server error");
+		assert.ok(eventTypes(h.stateDir).includes("poisoned_context"), "repeat threshold reached: poisoned_context event logged");
+		assert.ok(h.sendUserMessages.some((m) => m.includes("/clear") || m.includes("/new")), "repeat threshold: advise message 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("cleanup", async () => {
 	// PGlite WASM close can hang; race with a timeout to prevent 40-min hangs.
 	try {
 		await Promise.race([closeVectorIndex(), new Promise((r) => setTimeout(r, 3000))]);
 	} catch { /* ignore */ }
 	rmSync(baseTmp, { recursive: true, force: true });
+	// 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.
+	process.exit(0);
 });

package/extensions/mega-compact.ts

@@ -52,6 +52,21 @@ export default function (pi: ExtensionAPI) {
     console.warn('[mega-compact] MEGACOMPACT_MAX_CONSECUTIVE_ERRORS must be >= 1; using default 10');
     config.maxConsecutiveErrors = 10;
   }
+  // R2: session-global cap validation — 0 disables (valid), negative is invalid.
+  if (config.errorRetrySessionMax < 0) {
+    console.warn('[mega-compact] MEGACOMPACT_ERROR_RETRY_SESSION_MAX must be >= 0; using default 3');
+    config.errorRetrySessionMax = 3;
+  }
+  // R1: backoff base must be >= 0 (0 means no gating, useful for tests).
+  if (config.errorRetryBackoffMs < 0) {
+    console.warn('[mega-compact] MEGACOMPACT_ERROR_RETRY_BACKOFF_MS must be >= 0; using default 5000');
+    config.errorRetryBackoffMs = 5000;
+  }
+  // R3: repeat threshold must be >= 1.
+  if (config.poisonedContextRepeatThreshold < 1) {
+    console.warn('[mega-compact] MEGACOMPACT_POISONED_REPEAT_THRESHOLD must be >= 1; using default 3');
+    config.poisonedContextRepeatThreshold = 3;
+  }
   const runtime = new MegaRuntime(config);
   registerEventHandlers(pi, runtime, config);
   registerCommands(pi, runtime, config);

package/extensions/mega-config.ts

@@ -89,6 +89,21 @@ export interface MegaConfig {
    *  Default false. Set via env to force S28-only behavior (length-stop continues
    *  only). */
   errorRetryHardStop: boolean;
+  /** R1 (retry redesign): base unit (ms) for errorRetryBackoffMs(count) pacing.
+   *  The schedule is base, 2*base, 4*base, 6*base (cap) — so the default 5000
+   *  yields 5s/10s/20s/30s. errorRetryUntil is now GATING (previously it was
+   *  documented as non-gating); a nudge cannot fire before errorRetryUntil
+   *  elapses. */
+  errorRetryBackoffMs: number;
+  /** R2: session-global cap on total S38 nudges across ALL bursts. Hitting it
+   *  is terminal for the session — the extension stops nudging entirely,
+   *  independent of the per-burst max and the circuit breaker. Default 3.
+   *  `0` disables (reverts to per-burst + circuit-breaker only). */
+  errorRetrySessionMax: number;
+  /** R3: consecutive identical error-text count at which a 'transient'
+   *  classification is upgraded to 'poisoned-context' (the stateful repeat
+   *  signal). Default 3. Raise to make the upgrade less aggressive. */
+  poisonedContextRepeatThreshold: number;
   /** S29: override the auto-compact fire point for tiered configs, as a
    *  fraction of the context window (e.g. 0.85). null = inherit the tier's
    *  tierPct (default; preserves existing fire points). The context-handler
@@ -262,6 +277,9 @@ export function loadConfig(): MegaConfig {
     raceGuardStrict: envBool("MEGACOMPACT_RACE_GUARD_STRICT", true),
     maxConsecutiveErrors: envFlag("MEGACOMPACT_MAX_CONSECUTIVE_ERRORS", 10),
     errorRetryHardStop: envBool("MEGACOMPACT_ERROR_RETRY_HARD_STOP", false),
+    errorRetryBackoffMs: envFlag("MEGACOMPACT_ERROR_RETRY_BACKOFF_MS", 5000),
+    errorRetrySessionMax: envFlag("MEGACOMPACT_ERROR_RETRY_SESSION_MAX", 3),
+    poisonedContextRepeatThreshold: envFlag("MEGACOMPACT_POISONED_REPEAT_THRESHOLD", 3),
     autoPctTrigger,
     autoInlineK: envFlag("MEGACOMPACT_AUTO_INLINE_K", 3),
     dedupSim: Number(process.env.MEGACOMPACT_DEDUP_SIM ?? "0.9"),