pi-mega-compact 0.9.2 → 0.10.1

package/dist/extensions/mega-compact.js

@@ -35,35 +35,37 @@ import { registerDashboardCommands } from "./mega-dashboard-cmds.js";
 import { registerConflictCommands } from "./mega-conflict-cmds.js";
 import { registerDbCommands } from "./mega-db-cmds.js";
 import { registerGameCommands } from "./mega-game-cmds.js";
+import { registerMetricsCommands } from "./mega-metrics-cmds.js";
+import { registerTopicsCommands } from "./mega-topics-cmds.js";
 export default function (pi) {
     const config = loadConfig();
     // S38.9: preflight env validation — check for obviously invalid values at startup.
     // Non-fatal: log warnings and fall back to defaults.
     if (config.autoRetryTransientMax < 0) {
-        console.warn('[mega-compact] MEGACOMPACT_AUTO_RETRY_TRANSIENT_MAX must be >= 0; using default 5');
+        console.warn("[mega-compact] MEGACOMPACT_AUTO_RETRY_TRANSIENT_MAX must be >= 0; using default 5");
         config.autoRetryTransientMax = 5;
     }
     if (config.autoRetryPermanentMax < 0) {
-        console.warn('[mega-compact] MEGACOMPACT_AUTO_RETRY_PERMANENT_MAX must be >= 0; using default 1');
+        console.warn("[mega-compact] MEGACOMPACT_AUTO_RETRY_PERMANENT_MAX must be >= 0; using default 1");
         config.autoRetryPermanentMax = 1;
     }
     if (config.maxConsecutiveErrors < 1) {
-        console.warn('[mega-compact] MEGACOMPACT_MAX_CONSECUTIVE_ERRORS must be >= 1; using default 10');
+        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');
+        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');
+        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');
+        console.warn("[mega-compact] MEGACOMPACT_POISONED_REPEAT_THRESHOLD must be >= 1; using default 3");
         config.poisonedContextRepeatThreshold = 3;
     }
     const runtime = new MegaRuntime(config);
@@ -72,7 +74,9 @@ export default function (pi) {
     registerDashboardCommands(pi, runtime);
     registerConflictCommands(pi, runtime);
     registerDbCommands(pi, runtime);
+    registerMetricsCommands(pi, runtime, config);
     registerGameCommands(pi, runtime);
+    registerTopicsCommands(pi, runtime, config);
     // v0.8.5 (audit P3): release the fs.watch game-state watcher handle on
     // session teardown so it doesn't linger across reloads. pi exposes no
     // extension-unload event (the factory return value is ignored and there is no

package/dist/extensions/mega-config.js

@@ -154,6 +154,10 @@ export function loadConfig() {
         raptorEnabled: envBool("MEGACOMPACT_RAPTOR_ENABLED", true),
         legacyDurableTrim: envBool("MEGACOMPACT_LEGACY_DURABLE_TRIM", false),
         dbMirror: envBool("MEGACOMPACT_DB_MIRROR", false),
+        // S49: isolated per-turn store (turns.db). Default ON. OFF = legacy main-db
+        // turn path (S48 behavior). Mirrors src/config/turns.ts TURNS_DB_ENABLED.
+        turnsDbEnabled: envBool("MEGACOMPACT_TURNS_DB", true),
+        autoWikiEnabled: envBool("MEGACOMPACT_AUTO_WIKI", true),
         crossRepoEnabled: envBool("MEGACOMPACT_CROSSREPO_ENABLED", true),
         crossRepoCosine: Number(process.env.MEGACOMPACT_CROSSREPO_COSINE ?? "0.90"),
         memoryAutoReview: envBool("MEGACOMPACT_MEMORY_AUTO_REVIEW", true),

package/dist/extensions/mega-events/agent-handlers.js

@@ -1,11 +1,11 @@
-import { piCompactWouldNoop, runMemoryReview, } from "../mega-pipeline.js";
-import { memoryReviewCadence, } from "../mega-config.js";
-import { recordScore, recordTurn } from "../../src/store/sqlite.js";
+import { piCompactWouldNoop, runMemoryReview } from "../mega-pipeline.js";
+import { memoryReviewCadence } from "../mega-config.js";
+import { recordScore } from "../../src/store/sqlite.js";
 import { evaluateAndUnlockAchievements } from "../../src/store/sqlite/game-achievements.js";
-import { ensureConversationId } from "../../src/store/sqlite/turns.js";
+import { ensureConversationIdFor, recordTurnWrite, } from "../mega-turn-store.js";
 import { isMegaCache } from "../../src/game/scoring.js";
 import { resolveRepoRoot } from "../mega-config.js";
-import { classifyError, errorRetryBackoffMs, extractErrorSignature } from "./error-classifier.js";
+import { classifyError, errorRetryBackoffMs, extractErrorSignature, } from "./error-classifier.js";
 import { safeSendUserMessage } from "./send-safe.js";
 import { vectorStats } from "../../src/vectorStore.js";
 /** Register agent/turn tracking event handlers. */
@@ -36,7 +36,8 @@ export function registerAgentHandlers(pi, runtime, config) {
         // compaction AND there is queued work AND we haven't nudged recently, nudge
         // once so the agent continues (the live trim should make this rare). Guarded
         // to never busy-loop: one nudge per 30s, only when truly idle + queued.
-        if ((config.auto || config.autoContinueLengthStop) && runtime.activeAgents === 0) {
+        if ((config.auto || config.autoContinueLengthStop) &&
+            runtime.activeAgents === 0) {
             try {
                 const idle = ctx.isIdle?.() ?? true;
                 const queued = ctx.hasPendingMessages?.() ?? false;
@@ -51,7 +52,7 @@ export function registerAgentHandlers(pi, runtime, config) {
                 const liveUsage = ctx.getContextUsage?.();
                 const liveTokens = typeof liveUsage?.tokens === "number"
                     ? liveUsage.tokens
-                    : runtime.lastCtxTokens ?? 0;
+                    : (runtime.lastCtxTokens ?? 0);
                 // Keep the cache fresh for snapshot()/diag regardless of which source we use.
                 if (typeof liveUsage?.tokens === "number") {
                     runtime.lastCtxTokens = liveUsage.tokens;
@@ -104,7 +105,10 @@ export function registerAgentHandlers(pi, runtime, config) {
                 // most. Instead we DECOUPLE the nudge from `queued`: after a durable
                 // trim we ALWAYS nudge so the agent reliably restarts. Debounced 30s.
                 let didDurableTrim = false;
-                if (config.auto && idle && overThreshold && now >= runtime.debounceUntil) {
+                if (config.auto &&
+                    idle &&
+                    overThreshold &&
+                    now >= runtime.debounceUntil) {
                     // COMPACT-DEDUP FIX: skip the manual durable-trim trigger when pi's
                     // NATIVE auto-compaction just fired (or is in-flight). pi emits
                     // agent_end BEFORE its own _checkCompaction (per its docstring:
@@ -150,7 +154,8 @@ export function registerAgentHandlers(pi, runtime, config) {
                                     if (runtime.rt.sessionId !== liveSid)
                                         return; // session reset
                                     const since2 = now - (runtime.rt.lastNativeCompactAt ?? 0);
-                                    if (runtime.rt.lastNativeCompactAt !== stamp && since2 < cooldownMs)
+                                    if (runtime.rt.lastNativeCompactAt !== stamp &&
+                                        since2 < cooldownMs)
                                         return;
                                     if (piCompactWouldNoop(ctx))
                                         return;
@@ -179,7 +184,9 @@ export function registerAgentHandlers(pi, runtime, config) {
                     runtime.resumeNudgeUntil = now + 30_000;
                     if (runtime.rt.lengthStopPending) {
                         runtime.rt.lengthStopPending = false; // one-shot: never re-fire for same stop
-                        runtime.dashboard.event("length_stop_continue", { turnIndex: runtime.currentTurn });
+                        runtime.dashboard.event("length_stop_continue", {
+                            turnIndex: runtime.currentTurn,
+                        });
                         runtime.logger.info("length_stop_continue", {
                             sessionId: runtime.rt.sessionId,
                             didDurableTrim,
@@ -223,11 +230,12 @@ export function registerAgentHandlers(pi, runtime, config) {
         // the turn layer is queryable + forkable. Best-effort + non-fatal: a write
         // failure never breaks the agent loop.
         try {
-            const convId = ensureConversationId(runtime.rt.sessionId, runtime.currentStateDir);
-            recordTurn({
+            const convId = ensureConversationIdFor(config, runtime.rt.sessionId, runtime.currentStateDir);
+            recordTurnWrite(config, {
                 conversationId: convId,
                 sessionId: runtime.rt.sessionId,
                 turnIndex: event.turnIndex,
+                role: event.role ?? "assistant",
                 endedAt: Date.now(),
                 startedAt: undefined,
                 ctxTokens: runtime.lastCtxTokens ?? undefined,
@@ -319,8 +327,9 @@ export function registerAgentHandlers(pi, runtime, config) {
         // gating backoff, session-global cap, poisoned-context detection.
         try {
             // (1) S28 owns length — skip the classifier entirely for it.
-            const sr = event.message?.stopReason;
-            if (sr === 'length') {
+            const sr = event.message
+                ?.stopReason;
+            if (sr === "length") {
                 // S28 handles; nothing for S38 to do here.
             }
             else {
@@ -335,7 +344,7 @@ export function registerAgentHandlers(pi, runtime, config) {
                 // (a 'permanent' auth error repeating is still permanent).
                 let effectiveCategory = category;
                 const errSig = extractErrorSignature(event.message);
-                if (category === 'transient' || category === 'poisoned-context') {
+                if (category === "transient" || category === "poisoned-context") {
                     if (errSig) {
                         if (runtime.rt.lastErrorText === errSig) {
                             runtime.rt.errorTextRepeatCount++;
@@ -344,9 +353,10 @@ export function registerAgentHandlers(pi, runtime, config) {
                             runtime.rt.lastErrorText = errSig;
                             runtime.rt.errorTextRepeatCount = 1;
                         }
-                        if (runtime.rt.errorTextRepeatCount >= config.poisonedContextRepeatThreshold &&
-                            category === 'transient') {
-                            effectiveCategory = 'poisoned-context';
+                        if (runtime.rt.errorTextRepeatCount >=
+                            config.poisonedContextRepeatThreshold &&
+                            category === "transient") {
+                            effectiveCategory = "poisoned-context";
                         }
                     }
                 }
@@ -363,7 +373,7 @@ export function registerAgentHandlers(pi, runtime, config) {
                     // R4: a successful assistant turn consumes any queued nudge.
                     runtime.rt.retryNudgePending = false;
                 }
-                else if (effectiveCategory === 'compaction-noop') {
+                else if (effectiveCategory === "compaction-noop") {
                     // (4) pi race / manual compact catch — NOT retryable. The compaction
                     // already succeeded via pi's native path; retrying would race again
                     // (FAIL-2026071701). Log a diagnostic, reset the counter, and surface
@@ -371,16 +381,16 @@ export function registerAgentHandlers(pi, runtime, config) {
                     runtime.rt.errorRetryCount = 0;
                     runtime.rt.consecutiveErrors = 0; // S38.6: circuit-breaker reset
                     runtime.rt.retryNudgePending = false; // R4: terminal for this burst
-                    runtime.dashboard.event('compaction_noop_diagnostic', {
+                    runtime.dashboard.event("compaction_noop_diagnostic", {
                         turnIndex: event.turnIndex,
                         sessionId: runtime.rt.sessionId,
                     });
-                    runtime.logger.info('compaction-noop-diagnostic', {
+                    runtime.logger.info("compaction-noop-diagnostic", {
                         sessionId: runtime.rt.sessionId,
                         turnIndex: event.turnIndex,
                     });
                 }
-                else if (effectiveCategory === 'cancelled') {
+                else if (effectiveCategory === "cancelled") {
                     // (4c) User ESC / Ctrl-C — stopReason === 'aborted'. NOT retryable:
                     // nudging would restart a task the user explicitly stopped.
                     // Reset both counters (a cancel is not an error for circuit-breaker
@@ -388,16 +398,16 @@ export function registerAgentHandlers(pi, runtime, config) {
                     runtime.rt.errorRetryCount = 0;
                     runtime.rt.consecutiveErrors = 0;
                     runtime.rt.retryNudgePending = false; // R4: terminal for this burst
-                    runtime.dashboard.event('error_retry_cancelled', {
+                    runtime.dashboard.event("error_retry_cancelled", {
                         turnIndex: event.turnIndex,
                         sessionId: runtime.rt.sessionId,
                     });
-                    runtime.logger.info('error-retry-cancelled', {
+                    runtime.logger.info("error-retry-cancelled", {
                         sessionId: runtime.rt.sessionId,
                         turnIndex: event.turnIndex,
                     });
                 }
-                else if (effectiveCategory === 'context-overflow') {
+                else if (effectiveCategory === "context-overflow") {
                     // (4b) context-window overflow 400 ("too long... even after compaction").
                     // NOT a blind retry: re-submitting the same oversized prompt would just
                     // re-400 and busy-loop. Reset the counters (this turn is terminal, not
@@ -411,11 +421,11 @@ export function registerAgentHandlers(pi, runtime, config) {
                     runtime.rt.errorRetryCount = 0;
                     runtime.rt.consecutiveErrors = 0;
                     runtime.rt.retryNudgePending = false; // R4: terminal for this burst
-                    runtime.dashboard.event('context_overflow', {
+                    runtime.dashboard.event("context_overflow", {
                         turnIndex: event.turnIndex,
                         sessionId: runtime.rt.sessionId,
                     });
-                    runtime.logger.warn('context-overflow', {
+                    runtime.logger.warn("context-overflow", {
                         sessionId: runtime.rt.sessionId,
                         turnIndex: event.turnIndex,
                     });
@@ -432,7 +442,8 @@ export function registerAgentHandlers(pi, runtime, config) {
                                     if (runtime.rt.sessionId !== liveSid2)
                                         return; // session reset
                                     const since3 = Date.now() - (runtime.rt.lastNativeCompactAt ?? 0);
-                                    if (runtime.rt.lastNativeCompactAt !== stamp2 && since3 < cooldownMs2)
+                                    if (runtime.rt.lastNativeCompactAt !== stamp2 &&
+                                        since3 < cooldownMs2)
                                         return;
                                     if (piCompactWouldNoop(ctx))
                                         return;
@@ -445,7 +456,7 @@ export function registerAgentHandlers(pi, runtime, config) {
                         }
                     }
                 }
-                else if (effectiveCategory === 'poisoned-context') {
+                else if (effectiveCategory === "poisoned-context") {
                     // R3: poisoned context — a DETERMINISTIC request-rejection that
                     // retrying cannot fix (0-token 'error', generic "request failed",
                     // 400 non-overflow, or repeated identical error text). NO blind
@@ -459,15 +470,15 @@ export function registerAgentHandlers(pi, runtime, config) {
                     runtime.rt.errorRetryCount = 0; // poisoned is terminal for this burst
                     runtime.rt.consecutiveErrors++; // still counts toward the circuit breaker
                     runtime.rt.poisonedCount++; // R7: dashboard counter
-                    const sig = errSig || 'unknown';
+                    const sig = errSig || "unknown";
                     // (a) dashboard + log
-                    runtime.dashboard.event('poisoned_context', {
+                    runtime.dashboard.event("poisoned_context", {
                         signature: sig,
                         repeatCount: runtime.rt.errorTextRepeatCount,
                         turnIndex: event.turnIndex,
                         sessionId: runtime.rt.sessionId,
                     });
-                    runtime.logger.warn('poisoned-context', {
+                    runtime.logger.warn("poisoned-context", {
                         sessionId: runtime.rt.sessionId,
                         turnIndex: event.turnIndex,
                         signature: sig,
@@ -477,7 +488,7 @@ export function registerAgentHandlers(pi, runtime, config) {
                     if (!runtime.rt.poisonedAdviseSent) {
                         runtime.rt.poisonedAdviseSent = true;
                         // PREVENT-PI-003: user-role sendUserMessage only.
-                        await safeSendUserMessage(pi, '[mega-compact] this session\'s context may be poisoned (the provider is rejecting every request). Run /clear or /new to start a fresh context.');
+                        await safeSendUserMessage(pi, "[mega-compact] this session's context may be poisoned (the provider is rejecting every request). Run /clear or /new to start a fresh context.");
                     }
                     // (c) one guarded compact per error signature (attempt to remove
                     // the poisoned region). Race-guarded + deferred, mirroring the
@@ -497,7 +508,8 @@ export function registerAgentHandlers(pi, runtime, config) {
                                     if (runtime.rt.sessionId !== liveSidP)
                                         return; // session reset
                                     const sinceP = Date.now() - (runtime.rt.lastNativeCompactAt ?? 0);
-                                    if (runtime.rt.lastNativeCompactAt !== stampP && sinceP < cooldownMsP)
+                                    if (runtime.rt.lastNativeCompactAt !== stampP &&
+                                        sinceP < cooldownMsP)
                                         return;
                                     if (piCompactWouldNoop(ctx))
                                         return;
@@ -515,29 +527,29 @@ export function registerAgentHandlers(pi, runtime, config) {
                     // S38.7: hard-stop switch — bypass ALL retry logic when set.
                     if (config.errorRetryHardStop) {
                         runtime.rt.errorRetryCount = 0;
-                        runtime.dashboard.event('error_retry_disabled', {
+                        runtime.dashboard.event("error_retry_disabled", {
                             category: effectiveCategory,
                             turnIndex: event.turnIndex,
-                            reason: 'hard-stop',
+                            reason: "hard-stop",
                         });
                         return; // early exit — no retry
                     }
                     // S38.6: circuit-breaker — stop retrying after too many consecutive errors.
                     runtime.rt.consecutiveErrors++;
                     if (runtime.rt.consecutiveErrors > config.maxConsecutiveErrors) {
-                        runtime.dashboard.event('error_retry_circuit_open', {
+                        runtime.dashboard.event("error_retry_circuit_open", {
                             consecutive: runtime.rt.consecutiveErrors,
                             max: config.maxConsecutiveErrors,
                             turnIndex: event.turnIndex,
                         });
-                        runtime.logger.warn('error-retry-circuit-open', {
+                        runtime.logger.warn("error-retry-circuit-open", {
                             sessionId: runtime.rt.sessionId,
                             consecutive: runtime.rt.consecutiveErrors,
                             max: config.maxConsecutiveErrors,
                         });
                         return; // early exit — circuit breaker tripped
                     }
-                    const max = effectiveCategory === 'transient'
+                    const max = effectiveCategory === "transient"
                         ? config.autoRetryTransientMax
                         : config.autoRetryPermanentMax;
                     // max === 0 disables the category entirely (revert to S28-only).
@@ -548,13 +560,13 @@ export function registerAgentHandlers(pi, runtime, config) {
                         runtime.rt.errorRetryCount++;
                         if (runtime.rt.errorRetryCount > max) {
                             // Exhausted — surface the error, reset for the next burst.
-                            runtime.dashboard.event('error_retry_exhausted', {
+                            runtime.dashboard.event("error_retry_exhausted", {
                                 category: effectiveCategory,
                                 count: runtime.rt.errorRetryCount,
                                 max,
                                 turnIndex: event.turnIndex,
                             });
-                            runtime.logger.info('error-retry-exhausted', {
+                            runtime.logger.info("error-retry-exhausted", {
                                 sessionId: runtime.rt.sessionId,
                                 category: effectiveCategory,
                                 count: runtime.rt.errorRetryCount,
@@ -570,13 +582,13 @@ export function registerAgentHandlers(pi, runtime, config) {
                             // per-burst + circuit-breaker only).
                             if (config.errorRetrySessionMax > 0 &&
                                 runtime.rt.errorRetrySessionCount >= config.errorRetrySessionMax) {
-                                runtime.dashboard.event('error_retry_session_exhausted', {
+                                runtime.dashboard.event("error_retry_session_exhausted", {
                                     count: runtime.rt.errorRetrySessionCount,
                                     max: config.errorRetrySessionMax,
                                     category: effectiveCategory,
                                     turnIndex: event.turnIndex,
                                 });
-                                runtime.logger.warn('error-retry-session-exhausted', {
+                                runtime.logger.warn("error-retry-session-exhausted", {
                                     sessionId: runtime.rt.sessionId,
                                     count: runtime.rt.errorRetrySessionCount,
                                     max: config.errorRetrySessionMax,
@@ -595,7 +607,7 @@ export function registerAgentHandlers(pi, runtime, config) {
                             // (this IS an error turn), so the per-burst max + circuit
                             // breaker still bound the burst.
                             if (runtime.rt.retryNudgePending) {
-                                runtime.dashboard.event('error_retry_dedup_skip', {
+                                runtime.dashboard.event("error_retry_dedup_skip", {
                                     category: effectiveCategory,
                                     count: runtime.rt.errorRetryCount,
                                     max,
@@ -610,7 +622,7 @@ export function registerAgentHandlers(pi, runtime, config) {
                             // doesn't slam N nudges in <1s.
                             const now = Date.now();
                             if (now < runtime.rt.errorRetryUntil) {
-                                runtime.dashboard.event('error_retry_backoff_skip', {
+                                runtime.dashboard.event("error_retry_backoff_skip", {
                                     category: effectiveCategory,
                                     count: runtime.rt.errorRetryCount,
                                     max,
@@ -624,22 +636,23 @@ export function registerAgentHandlers(pi, runtime, config) {
                             runtime.rt.retryNudgePending = true;
                             runtime.rt.lastErrorRetryAt = now;
                             runtime.rt.errorRetryUntil =
-                                now + errorRetryBackoffMs(runtime.rt.errorRetryCount, config.errorRetryBackoffMs);
+                                now +
+                                    errorRetryBackoffMs(runtime.rt.errorRetryCount, config.errorRetryBackoffMs);
                             runtime.rt.errorRetrySessionCount++;
-                            runtime.dashboard.event('error_retry', {
+                            runtime.dashboard.event("error_retry", {
                                 category: effectiveCategory,
                                 count: runtime.rt.errorRetryCount,
                                 max,
                                 turnIndex: event.turnIndex,
                             });
-                            runtime.logger.info('error-retry', {
+                            runtime.logger.info("error-retry", {
                                 sessionId: runtime.rt.sessionId,
                                 category: effectiveCategory,
                                 count: runtime.rt.errorRetryCount,
                                 max,
                             });
                             // PREVENT-PI-003: user-role sendUserMessage only (queued + catch-guarded).
-                            await safeSendUserMessage(pi, '[mega-compact] the last turn ended with an error; please retry.');
+                            await safeSendUserMessage(pi, "[mega-compact] the last turn ended with an error; please retry.");
                         }
                     }
                 }

package/dist/extensions/mega-events/context-handler.js

@@ -3,6 +3,10 @@ import { epochIdFor } from "../../src/mirror/epoch.js";
 import { autoCompactCheck } from "../../src/compact.js";
 import { estimateSessionTokens } from "../../src/tokens.js";
 import { runCompact, piCompactWouldNoop } from "../mega-pipeline.js";
+import { stampTurnsEpochFor } from "../mega-turn-store.js";
+import { TurnsConfig } from "../../src/config/turns.js";
+import { openTurnStore } from "../../src/store/turns/connection.js";
+import { buildTopicModel, createTopicStore, bumpWikiCompactCounter, } from "../../src/topics/index.js";
 import { computeLiveTrimCut, liveTrimSummaryMessage } from "../mega-trim.js";
 import { pressureFromPct, pressureRatio, } from "../mega-config.js";
 import { computeContentDigest } from "../../src/dedup/digest.js";
@@ -44,7 +48,7 @@ function canonicalize(value) {
  * whitespace/case-variant content. F5 fix: recursive canonicalize replaces the
  * broken shallow-sorted JSON.stringify replacer.
  */
-function toRawTranscriptRow(msg, sessionId, epochId) {
+function toRawTranscriptRow(msg, sessionId, epochId, currentTurn) {
     // Narrow to Message union (has content + timestamp).
     const m = msg;
     const content = m.content;
@@ -69,6 +73,9 @@ function toRawTranscriptRow(msg, sessionId, epochId) {
         toolName: m.toolName ?? null,
         messageTimestamp: m.timestamp ?? null,
         checkpointEpoch: epochId,
+        // S50: label the row with the turn that produced it (per-turn dedup /
+        // compression-by-turn metrics). Null when the writer omits it (back-compat).
+        turnIndex: currentTurn ?? null,
     };
 }
 /** Register the context event handler (live-trim auto-trigger). */
@@ -122,7 +129,7 @@ export function registerContextHandler(pi, runtime, config) {
                 const db = openStore(runtime.currentStateDir);
                 const epochId = epochIdFor(runtime.rt.sessionId);
                 for (const msg of messages) {
-                    const raw = toRawTranscriptRow(msg, runtime.rt.sessionId, epochId);
+                    const raw = toRawTranscriptRow(msg, runtime.rt.sessionId, epochId, runtime.currentTurn);
                     if (raw)
                         appendRawTranscript(db, raw);
                 }
@@ -233,6 +240,45 @@ export function registerContextHandler(pi, runtime, config) {
                     createdAt: Date.now(),
                 };
                 writeCheckpointEpoch(db, epoch);
+                // S50B: link this session's turns to the epoch that just compacted
+                // them (compression-by-conversation-epoch metrics). Isolated-store
+                // only; best-effort + non-fatal.
+                try {
+                    stampTurnsEpochFor(config, runtime.rt.sessionId, epoch.epochId, runtime.currentStateDir);
+                }
+                catch {
+                    /* non-fatal: epoch stamping never breaks compaction */
+                }
+                // S51B: auto-categorizing wiki rebuild — every Nth compaction, derived
+                // from real context_chunks embeddings. Isolated-store only, gated on
+                // AUTO_WIKI_ENABLED; best-effort + non-fatal (never breaks compaction).
+                try {
+                    if (config.autoWikiEnabled && config.turnsDbEnabled) {
+                        const every = Math.max(1, TurnsConfig.WIKI_REBUILD_EVERY_N_COMPACTS);
+                        const tdb = openTurnStore(runtime.currentStateDir);
+                        const n = bumpWikiCompactCounter(tdb);
+                        if (n % every === 0) {
+                            const model = buildTopicModel(db, {
+                                kRange: [TurnsConfig.WIKI_K_MIN, TurnsConfig.WIKI_K_MAX],
+                                labelTopTerms: TurnsConfig.WIKI_LABEL_TOP_TERMS,
+                                restarts: 5,
+                                seed: 0x9e3779b9,
+                            });
+                            createTopicStore(runtime.currentStateDir).replaceTopicModel(model);
+                            runtime.logger.info("wiki_rebuild", {
+                                clusterCount: model.k,
+                                totalChunks: model.totalChunks,
+                                method: "kmeans+tfidf",
+                                criterion: model.criterion,
+                                silhouetteScore: model.silhouetteScore,
+                                uncalibrated: false,
+                            });
+                        }
+                    }
+                }
+                catch (wikiErr) {
+                    runtime.logger.warn("wiki_rebuild_failed", { error: String(wikiErr) });
+                }
                 // S27 Task 6: Fire-and-forget dedup pipeline.
                 // Deduplicates raw_transcript rows for the compacted range.
                 try {

package/dist/extensions/mega-events/session-handlers.js

@@ -4,6 +4,8 @@ import { recentUserQuery, WIDGET_KEY, } from "../mega-runtime.js";
 import { doRecall, doRecallAsync, } from "../mega-pipeline.js";
 import { recallMemoriesAndInline } from "../../src/recall.js";
 import { vectorStats } from "../../src/vectorStore.js";
+import { openTurnStore } from "../../src/store/turns/connection.js";
+import { openIntentQueue } from "../../src/intent.js";
 /** Register session lifecycle event handlers. */
 export function registerSessionHandlers(pi, runtime, config) {
     // Capture model/provider whenever it changes (drives real cost estimation).
@@ -125,6 +127,28 @@ export function registerSessionHandlers(pi, runtime, config) {
     // ---- Auto-inline injection point: prepend staged recall to systemPrompt ----
     pi.on("before_agent_start", async (event, ctx) => {
         runtime.captureModel(ctx); // most reliable point ctx.model is populated
+        // S52A: consume any pending rewind intents the dashboard queued. The host
+        // polls the intent queue here (the only safe lifecycle point) and marks each
+        // consumed. Best-effort + non-fatal — the store never calls back into the
+        // host (ledger protocol). A real rewind (reloading pi's conversation to turn
+        // N) is host-specific; this consumes the intent so the round-trip completes.
+        try {
+            if (config.turnsDbEnabled) {
+                const tdb = openTurnStore(runtime.currentStateDir);
+                const q = openIntentQueue(tdb);
+                const pending = q.pendingIntents();
+                for (const intent of pending) {
+                    q.consumeIntent(intent.id);
+                    runtime.dashboard.event("rewind_intent_consumed", {
+                        conversationId: intent.conversationId,
+                        targetTurnIndex: intent.targetTurnIndex,
+                    });
+                }
+            }
+        }
+        catch {
+            /* non-fatal: intent polling never breaks the agent loop */
+        }
         const cpBlock = runtime.pendingRecallBlock;
         const memBlock = runtime.pendingMemoryRecallBlock;
         if (!cpBlock && !memBlock)

package/dist/extensions/mega-metrics-cmds.js

@@ -0,0 +1,90 @@
+/**
+ * mega-metrics-cmds.ts — S50C per-turn memory-quality /commands.
+ *
+ * Registers /mega-metrics and /mega-fork, backed by the pi-agnostic
+ * src/metrics/turns.ts rollups and src/fork.ts primitive over the isolated
+ * S49 turns.db. Read-only (PREVENT-PI-001/002 — these never mutate memory,
+ * drop ranges, or compaction); local SQLite only (PREVENT-PI-004);
+ * parameterized queries (PREVENT-002). Both require turnsDbEnabled (the
+ * isolated store); they no-op with guidance on the legacy main-db path.
+ */
+import { turnStoreFor, mainDbFor } from "./mega-turn-store.js";
+import { turnMetrics, conversationMetrics } from "../src/metrics/index.js";
+import { forkFromConversation, ForkError } from "../src/fork.js";
+import { ensureConversationIdFor } from "./mega-turn-store.js";
+function pct(r) {
+    return `${(r * 100).toFixed(1)}%`;
+}
+/** Register the /mega-metrics + /mega-fork commands. */
+export function registerMetricsCommands(pi, runtime, config) {
+    pi.registerCommand("mega-metrics", {
+        description: "Show per-turn + per-conversation memory-quality metrics (recall reuse, dedup ratio, compression ratio). Usage: /mega-metrics [conversationId]",
+        handler: async (args, ctx) => {
+            try {
+                runtime.bindRepo(ctx.cwd);
+                const stateDir = runtime.currentStateDir;
+                const store = turnStoreFor(config, stateDir);
+                if (!store) {
+                    ctx.ui.notify("[mega-compact] /mega-metrics requires the isolated turns.db (set turnsDbEnabled on).");
+                    return;
+                }
+                const conv = args.trim() ||
+                    ensureConversationIdFor(config, runtime.rt.sessionId, stateDir);
+                const mainDb = mainDbFor(stateDir);
+                const perTurn = turnMetrics(store, mainDb, conv);
+                if (perTurn.length === 0) {
+                    ctx.ui.notify(`[mega-compact] no turns recorded for conversation ${conv}.`);
+                    return;
+                }
+                const agg = conversationMetrics(store, mainDb, conv);
+                ctx.ui.notify(`[mega-compact] conversation ${conv} — ${agg.turnCount} turns, ${agg.epochCount} epoch(s), total recall ${agg.totalRecall}, total raw msgs ${agg.totalRawMessages}`);
+                ctx.ui.notify(`  avg dedup unique ratio ${pct(agg.avgDedupUniqueRatio)} · avg compression ratio ${pct(agg.avgCompressionRatio)}`);
+                for (const t of perTurn) {
+                    ctx.ui.notify(`  turn ${t.turnIndex} (epoch ${t.epochId ?? "—"}): recall ${t.recallCount}, raw ${t.rawMessageCount}, dedup ${pct(t.dedupUniqueRatio)}, compress ${pct(t.compressionRatio)}`);
+                }
+            }
+            catch (e) {
+                ctx.ui.notify(`[mega-compact] /mega-metrics failed: ${String(e)}`);
+            }
+        },
+    });
+    pi.registerCommand("mega-fork", {
+        description: "Fork the current conversation at turn N into a new child conversation, rehydrating that turn's injected checkpoints (recall-to-point, not window replay). Usage: /mega-fork <turnIndex> [conversationId]",
+        handler: async (args, ctx) => {
+            try {
+                runtime.bindRepo(ctx.cwd);
+                const stateDir = runtime.currentStateDir;
+                const store = turnStoreFor(config, stateDir);
+                if (!store) {
+                    ctx.ui.notify("[mega-compact] /mega-fork requires the isolated turns.db (set turnsDbEnabled on).");
+                    return;
+                }
+                const parts = args.trim().split(/\s+/).filter(Boolean);
+                const turnIndex = Number.parseInt(parts[0] ?? "", 10);
+                if (!Number.isFinite(turnIndex)) {
+                    ctx.ui.notify("[mega-compact] /mega-fork needs a turn index, e.g. /mega-fork 3");
+                    return;
+                }
+                const conv = parts[1] ||
+                    ensureConversationIdFor(config, runtime.rt.sessionId, stateDir);
+                const out = forkFromConversation(store, conv, turnIndex);
+                runtime.logger.info("fork", {
+                    parent: conv,
+                    child: out.childConversationId,
+                    turnIndex,
+                    checkpoints: out.checkpointIds,
+                });
+                ctx.ui.notify(`[mega-compact] forked ${conv} @ turn ${turnIndex} → ${out.childConversationId}\n` +
+                    `  replay set (${out.checkpointIds.length} checkpoint(s)): ${out.checkpointIds.join(", ")}`);
+            }
+            catch (e) {
+                if (e instanceof ForkError) {
+                    ctx.ui.notify(`[mega-compact] /mega-fork: ${e.message}`);
+                }
+                else {
+                    ctx.ui.notify(`[mega-compact] /mega-fork failed: ${String(e)}`);
+                }
+            }
+        },
+    });
+}