pi-mega-compact 0.13.1 → 0.13.2

package/extensions/mega-events/agent-handlers/turnEndHandler/memoryReview.ts

@@ -0,0 +1,42 @@
+/**
+ * turnEndHandler/memoryReview.ts — S20+S24 memory auto-review.
+ *
+ * Extracted from turnEndHandler.ts (delegate-shell split) to keep every source
+ * file under the extensions limit. Auto-reviews the conversation and persists
+ * durable memories. Best-effort + non-fatal: a review failure must never break
+ * the agent loop. Debounced by the pressure-adjusted interval.
+ */
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { MegaRuntime } from "../../../mega-runtime.js";
+import { runMemoryReview } from "../../../mega-pipeline.js";
+import { memoryReviewCadence, type MegaConfig } from "../../../mega-config.js";
+
+/** S20+S24: auto-review the conversation and persist durable memories. */
+export async function memoryReview(
+	ctx: ExtensionContext,
+	runtime: MegaRuntime,
+	config: MegaConfig,
+): Promise<void> {
+	// S20+S24: auto-review the conversation and persist durable memories. The
+	// review cadence scales with pressure (memoryReviewCadence): as context
+	// fills, the conversation is reviewed more often so memories keep pace with
+	// faster churn. Best-effort + non-fatal: a review failure must never break
+	// the agent loop. Debounced by the pressure-adjusted interval.
+	if (config.memoryAutoReview && runtime.currentTurn > 0) {
+		const cadence = memoryReviewCadence(
+			runtime.pressureBand,
+			config.memoryReviewInterval,
+		);
+		if (runtime.currentTurn % cadence === 0) {
+			// S20+S24: review the conversation and persist durable memories. The
+			// cadence scales with pressure (memoryReviewCadence): as context fills,
+			// the conversation is reviewed more often so memories keep pace with
+			// faster churn. Shared runMemoryReview body (also used on compact).
+			const entries = ctx.sessionManager.getEntries();
+			const view = runtime.engineView(
+				entries.flatMap((e: any) => (e.message ? [e.message] : [])),
+			);
+			await runMemoryReview(runtime, view, "turn");
+		}
+	}
+}

package/extensions/mega-events/agent-handlers/turnEndHandler/recordTurnRow.ts

@@ -0,0 +1,61 @@
+/**
+ * turnEndHandler/recordTurnRow.ts — S43 per-turn tracking.
+ *
+ * Extracted from turnEndHandler.ts (delegate-shell split) to keep every source
+ * file under the extensions limit. Records one turn row with the cached metrics
+ * so the turn layer is queryable + forkable. Best-effort + non-fatal: a write
+ * failure never breaks the agent loop.
+ */
+import type { MegaRuntime } from "../../../mega-runtime.js";
+import type { MegaConfig } from "../../../mega-config.js";
+import { ensureConversationIdFor, recordTurnWrite } from "../../../mega-turn-store.js";
+import type { TurnEndEvent } from "./event.js";
+
+/** S43: record one turn row with the cached metrics. Best-effort + non-fatal. */
+export function recordTurnRow(
+	event: TurnEndEvent,
+	runtime: MegaRuntime,
+	config: MegaConfig,
+): void {
+	// S43 (per-turn tracking): record one turn row with the cached metrics so
+	// the turn layer is queryable + forkable. Best-effort + non-fatal: a write
+	// failure never breaks the agent loop. The catch logs the error (structured
+	// JSON line to events.log) so a recurring turn-write failure is diagnosable
+	// instead of silently producing a blank Turns tab.
+	try {
+		const convId = ensureConversationIdFor(
+			config,
+			runtime.rt.sessionId,
+			runtime.currentStateDir,
+		);
+		recordTurnWrite(
+			config,
+			{
+				conversationId: convId,
+				sessionId: runtime.rt.sessionId,
+				turnIndex: event.turnIndex,
+				role: (event as { role?: string }).role ?? "assistant",
+				endedAt: Date.now(),
+				startedAt: undefined,
+				ctxTokens: runtime.lastCtxTokens ?? undefined,
+				ctxPercent: runtime.lastCtxPercent ?? undefined,
+				pressureBand: runtime.pressureBand ?? undefined,
+				modelId: runtime.currentModel?.modelId ?? undefined,
+			},
+			runtime.currentStateDir,
+		);
+		runtime.dashboard.event("turn_written", {
+			turnIndex: event.turnIndex,
+			conversationId: convId,
+			pressureBand: runtime.pressureBand ?? null,
+			turnsDbEnabled: config.turnsDbEnabled,
+		});
+	} catch (e) {
+		runtime.dashboard.event("turn_write_failed", {
+			turnIndex: event.turnIndex,
+			turnsDbEnabled: config.turnsDbEnabled,
+			error: e instanceof Error ? e.message : String(e),
+			stack: e instanceof Error ? e.stack?.split("\n").slice(0, 3).join(" | ") : undefined,
+		});
+	}
+}

package/extensions/mega-events/agent-handlers/turnEndHandler.ts

@@ -0,0 +1,64 @@
+/**
+ * agent-handlers/turnEndHandler.ts — the pi `turn_end` handler body.
+ *
+ * Delegate-shell (extensions split): extracts each concern into a helper in
+ * ./turnEndHandler/* so every source file stays under the extensions limit.
+ * The heavy sections live in sibling files: recordTurnRow (S43 persistence),
+ * gameScoring (S33/S35), memoryReview (S20/S24), lengthStop (S28), errorRetry
+ * (S38/R1-R11 safety net), cacheStripe (P3.5), and contextHealth (v0.12).
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { MegaRuntime } from "../../mega-runtime.js";
+import type { MegaConfig } from "../../mega-config.js";
+import type { TurnEndEvent } from "./turnEndHandler/event.js";
+import { recordTurnRow } from "./turnEndHandler/recordTurnRow.js";
+import { gameScoring } from "./turnEndHandler/gameScoring.js";
+import { memoryReview } from "./turnEndHandler/memoryReview.js";
+import { lengthStop } from "./turnEndHandler/lengthStop.js";
+import { errorRetry } from "./turnEndHandler/errorRetry.js";
+import { cacheStripe } from "./turnEndHandler/cacheStripe.js";
+import { contextHealth } from "./turnEndHandler/contextHealth.js";
+
+/** Handle the `turn_end` pi event. Non-fatal end-to-end. */
+export async function handleTurnEnd(
+	event: TurnEndEvent,
+	ctx: ExtensionContext,
+	pi: ExtensionAPI,
+	runtime: MegaRuntime,
+	config: MegaConfig,
+): Promise<void> {
+	runtime.dashboard.event("turn_end", { turnIndex: event.turnIndex });
+	runtime.snapshot(ctx);
+	runtime.lastErrorCategory = null;
+
+	// S53: consume staged recall blocks ONLY if they were actually injected
+	// into a view this turn. If no context event fired (edge: turn ended
+	// before any LLM call), recallInjectedThisTurn stays false and the blocks
+	// remain staged for the next turn's first context event.
+	if (config.recallTailInject && runtime.rt.recallInjectedThisTurn) {
+		runtime.pendingRecallBlock = undefined;
+		runtime.pendingMemoryRecallBlock = undefined;
+		runtime.rt.recallInjectedThisTurn = false;
+	}
+
+	// S43 (per-turn tracking): record one turn row. Best-effort + non-fatal.
+	recordTurnRow(event, runtime, config);
+
+	// S33/S35: game-mode scoring + achievements. Best-effort + non-fatal (G6).
+	gameScoring(event, ctx, runtime);
+
+	// S20+S24: auto-review the conversation, persist durable memories.
+	await memoryReview(ctx, runtime, config);
+
+	// S28: detect max-output-token truncation, arm the agent_end nudge.
+	lengthStop(event, runtime, config);
+
+	// S38/R1-R11: broader error-retry safety net. Non-fatal end-to-end.
+	await errorRetry(event, ctx, pi, runtime, config);
+
+	// P3.5: topic-shift cache stripe refresh. Best-effort + non-fatal.
+	cacheStripe(event, runtime, config);
+
+	// v0.12: context-health score + mitigation. Non-fatal.
+	contextHealth(event, ctx, runtime, config);
+}