@matthewfl/pi-contemplator 0.0.9 → 0.1.0

package/src/runtime.ts

@@ -6,7 +6,7 @@ export type ResolveResult =
 
 type NotifyLevel = "warning" | "info" | "error";
 type Notify = (message: string, type?: NotifyLevel) => void;
-export type ConsolidationPhase = "observer" | "reflector" | "dropper";
+export type ConsolidationPhase = "observer";
 
 export const OM_SETTINGS = "om.settings";
 
@@ -16,27 +16,18 @@ function isConfiguredModel(value: unknown): value is ConfiguredModel {
 	return typeof model.provider === "string" && model.provider.length > 0 && typeof model.id === "string" && model.id.length > 0;
 }
 
-function normalizeSessionSettings(settings: SessionSettings, baseConfig: Config): SessionSettings {
-	const normalized = { ...settings };
-	if (normalized.observationsPoolMaxTokens !== undefined && normalized.observationsPoolMaxTokens < 2) {
-		delete normalized.observationsPoolMaxTokens;
-	}
-	const maxTokens = normalized.observationsPoolMaxTokens ?? baseConfig.observationsPoolMaxTokens;
-	const targetTokens = normalized.observationsPoolTargetTokens ?? baseConfig.observationsPoolTargetTokens;
-	if (normalized.observationsPoolMaxTokens !== undefined && targetTokens >= maxTokens) {
-		normalized.observationsPoolTargetTokens = Math.floor(maxTokens / 2);
-	} else if (normalized.observationsPoolTargetTokens !== undefined && normalized.observationsPoolTargetTokens >= maxTokens) {
-		delete normalized.observationsPoolTargetTokens;
-	}
-	return normalized;
+function normalizeSessionSettings(settings: SessionSettings, _baseConfig: Config): SessionSettings {
+	return { ...settings };
 }
 
 export type SessionSettings = Partial<Pick<Config,
-	| "observeAfterTokens" | "reflectAfterTokens" | "observerChunkMaxTokens" | "compactAfterTokens"
+	| "observeAfterTokens" | "observerChunkMaxTokens" | "compactAfterTokens"
 	| "compactAfterTokensMode" | "compactAfterTokensRatio"
-	| "observationsPoolMaxTokens" | "observationsPoolTargetTokens" | "agentMaxTurns"
+	| "newMemoryPoolMaxTokens" | "oldMemoryPoolTargetTokens" | "agentMaxTurns"
 	| "showWorkerNotifications" | "passive" | "compactionObserverEnabled" | "contemplatorEnabled" | "showContemplatorMessages" | "reviewerEnabled"
-	| "contemplatorMinNewObservations" | "contemplatorMinNewReflections" | "contemplatorMinTurns" | "debugLog"
+	| "contemplatorMinNewObservations" | "contemplatorMinNewSummaries" | "contemplatorMinTurns"
+	| "summarizerEnabled" | "summarizerRetriggerTokens" | "summarizerSamplingThresholdTokens"
+	| "debugLog"
 >> & {
 	/** null explicitly means use the configured/session model. */
 	model?: ConfiguredModel | null;
@@ -63,6 +54,30 @@ export interface MemoryUpdateCtx extends LaunchCtx {
 	sessionManager: { getBranch(): readonly unknown[] };
 }
 
+export type SettingsUpdate = Partial<SessionSettings>;
+
+export interface SummarizerRunView {
+	startedAt: number;
+	completedAt?: number;
+	status: "running" | "completed" | "incomplete" | "failed";
+	messages: readonly unknown[];
+	summary?: string;
+	error?: string;
+}
+
+export interface ContemplatorRunState {
+	running: boolean;
+	pendingObservations: number;
+	pendingSummaries: number;
+	pendingReviews: number;
+	/** Completed primary-model responses since the previous contemplator run. */
+	responsesSinceRun: number;
+	waitingFor: "disabled" | "passive" | "memories" | "responses" | "ready" | "running" | "idle";
+	lastStartedAt?: number;
+	lastCompletedAt?: number;
+	lastError?: string;
+}
+
 export interface LlmUsageTotals {
 	input: number;
 	output: number;
@@ -108,12 +123,13 @@ export function computeSessionSettings(entries: readonly unknown[]): SessionSett
 		if (!source || typeof source !== "object") return;
 		const data = source as Record<string, unknown>;
 		const booleanKeys = [
-			"showWorkerNotifications", "passive", "compactionObserverEnabled", "contemplatorEnabled", "showContemplatorMessages", "reviewerEnabled", "debugLog",
+			"showWorkerNotifications", "passive", "compactionObserverEnabled", "contemplatorEnabled", "showContemplatorMessages", "reviewerEnabled", "summarizerEnabled", "debugLog",
 		] as const;
 		const numberKeys = [
-			"observeAfterTokens", "reflectAfterTokens", "observerChunkMaxTokens", "compactAfterTokens",
-			"observationsPoolMaxTokens", "observationsPoolTargetTokens", "agentMaxTurns",
-			"contemplatorMinNewObservations", "contemplatorMinNewReflections", "contemplatorMinTurns",
+			"observeAfterTokens", "observerChunkMaxTokens", "compactAfterTokens",
+			"newMemoryPoolMaxTokens", "oldMemoryPoolTargetTokens", "agentMaxTurns",
+			"contemplatorMinNewObservations", "contemplatorMinNewSummaries", "contemplatorMinTurns",
+			"summarizerRetriggerTokens", "summarizerSamplingThresholdTokens",
 		] as const;
 		for (const key of booleanKeys) if (typeof data[key] === "boolean") restored[key] = data[key];
 		for (const key of numberKeys) if (typeof data[key] === "number" && Number.isInteger(data[key]) && data[key] > 0) restored[key] = data[key];
@@ -140,25 +156,51 @@ export class Runtime {
 	consolidationPromise: Promise<void> | null = null;
 	reviewInFlight = false;
 	reviewPromise: Promise<void> | null = null;
+	/**
+	 * Process-local single-flight lock for this session runtime. Every launch path
+	 * must go through launchSummarizerTask; a second summarizer cannot start until
+	 * the tracked promise's finally handler releases this lock.
+	 */
+	summarizerInFlight = false;
+	summarizerPromise: Promise<void> | null = null;
+	/** Old-pool token threshold for the next pass; undefined means configured target. */
+	summarizerNextTriggerTokens: number | undefined;
 	private memoryUpdateListener: ((ctx: MemoryUpdateCtx) => void) | undefined;
+	private agentActivityListener: ((ctx: MemoryUpdateCtx) => void) | undefined;
+	private settingsUpdateListener: ((ctx: MemoryUpdateCtx, settings: SettingsUpdate) => void) | undefined;
 	private contextGeneration = 0;
 	consolidationPhase: ConsolidationPhase | undefined;
 	compactInFlight = false;
 	compactRequested = false;
 	/** Agent-authored instructions to deliver after an explicit compact_context request. */
 	compactContinuationPrompt: string | undefined;
-	compactOrigin: "proactive" | "agent-requested" | undefined;
+	compactOrigin: "proactive" | "agent-requested" | "length-stop" | undefined;
 	compactHookInFlight = false;
 	compactionResumePending = false;
 	compactionResumeGeneration = 0;
 	compactionResumeTimer: ReturnType<typeof setTimeout> | undefined;
 	resolveFailureNotified = false;
 	lastObserverError: string | undefined;
-	lastReflectorError: string | undefined;
-	lastDropperError: string | undefined;
+	lastSummarizerError: string | undefined;
+	/** Wall-clock worker boundaries for launch-local status diagnostics. */
+	lastObserverStartedAt: number | undefined;
+	lastObserverCompletedAt: number | undefined;
+	lastSummarizerStartedAt: number | undefined;
+	lastSummarizerCompletedAt: number | undefined;
+	/** Most recent summarizer transcript in this extension launch/session context. */
+	lastSummarizerRun: SummarizerRunView | undefined;
+	/** Launch-local liveness and trigger diagnostics published by the contemplator. */
+	contemplatorState: ContemplatorRunState = {
+		running: false,
+		pendingObservations: 0,
+		pendingSummaries: 0,
+		pendingReviews: 0,
+		responsesSinceRun: 0,
+		waitingFor: "idle",
+	};
 	agentUsage: LlmUsageTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, runs: 0 };
 
-	/** Accumulate usage from one background LLM call (contemplator flush/summary or observer/reflector/dropper run). */
+	/** Accumulate usage from one background LLM call. */
 	recordAgentUsage(usage: LlmUsageInput): void {
 		const totals = this.agentUsage;
 		totals.input += usage.input ?? 0;
@@ -220,6 +262,20 @@ export class Runtime {
 		this.compactionResumeGeneration += 1;
 		if (this.compactionResumeTimer !== undefined) clearTimeout(this.compactionResumeTimer);
 		this.compactionResumeTimer = undefined;
+		this.summarizerNextTriggerTokens = undefined;
+		this.lastObserverStartedAt = undefined;
+		this.lastObserverCompletedAt = undefined;
+		this.lastSummarizerStartedAt = undefined;
+		this.lastSummarizerCompletedAt = undefined;
+		this.lastSummarizerRun = undefined;
+		this.contemplatorState = {
+			running: false,
+			pendingObservations: 0,
+			pendingSummaries: 0,
+			pendingReviews: 0,
+			responsesSinceRun: 0,
+			waitingFor: "idle",
+		};
 	}
 
 	getContextGeneration(): number {
@@ -237,7 +293,7 @@ export class Runtime {
 				model = configured;
 			} else if (ctx.hasUI && ctx.ui) {
 				ctx.ui.notify(
-					`Observational memory: configured model ${configuredModel.provider}/${configuredModel.id} not found, using session model`,
+					`pi-contemplator: configured model ${configuredModel.provider}/${configuredModel.id} not found, using session model`,
 					"warning",
 				);
 			}
@@ -259,12 +315,26 @@ export class Runtime {
 		this.memoryUpdateListener?.(ctx);
 	}
 
+	setAgentActivityListener(listener: (ctx: MemoryUpdateCtx) => void): void {
+		this.agentActivityListener = listener;
+	}
+
+	notifyAgentActivity(ctx: MemoryUpdateCtx): void {
+		this.agentActivityListener?.(ctx);
+	}
+
+	setSettingsUpdateListener(listener: (ctx: MemoryUpdateCtx, settings: SettingsUpdate) => void): void {
+		this.settingsUpdateListener = listener;
+	}
+
+	notifySettingsUpdate(ctx: MemoryUpdateCtx, settings: SettingsUpdate): void {
+		this.settingsUpdateListener?.(ctx, settings);
+	}
+
 	launchConsolidationTask(ctx: LaunchCtx, work: () => Promise<void>): Promise<void> {
 		this.consolidationInFlight = true;
 		this.consolidationPhase = undefined;
 		this.lastObserverError = undefined;
-		this.lastReflectorError = undefined;
-		this.lastDropperError = undefined;
 		const promise = this.launchTrackedTask(ctx, "consolidation", work, () => {
 			this.consolidationInFlight = false;
 			this.consolidationPhase = undefined;
@@ -274,6 +344,21 @@ export class Runtime {
 		return promise;
 	}
 
+	launchSummarizerTask(ctx: LaunchCtx, work: () => Promise<void>): Promise<void> | undefined {
+		// This is the authoritative single-flight gate, not merely a UI flag.
+		// Keep it here even though callers also avoid redundant launch attempts.
+		if (this.summarizerInFlight) return undefined;
+		this.summarizerInFlight = true;
+		this.lastSummarizerError = undefined;
+		const promise = this.launchTrackedTask(ctx, "summarizer", work, (error) => {
+			this.summarizerInFlight = false;
+			this.lastSummarizerError = error;
+			if (this.summarizerPromise === promise) this.summarizerPromise = null;
+		});
+		this.summarizerPromise = promise;
+		return promise;
+	}
+
 	launchReviewTask(ctx: LaunchCtx, work: () => Promise<void>): Promise<void> | undefined {
 		// Structural reviews are intentionally serialized. Pending requests are
 		// persisted in the session ledger and resumed after the active task exits.
@@ -289,10 +374,8 @@ export class Runtime {
 
 	recordConsolidationStageError(ctx: LaunchCtx, phase: ConsolidationPhase, error: unknown): string {
 		const message = error instanceof Error ? error.message : String(error);
-		if (phase === "observer") this.lastObserverError = message;
-		if (phase === "reflector") this.lastReflectorError = message;
-		if (phase === "dropper") this.lastDropperError = message;
-		if (ctx.hasUI && ctx.ui) ctx.ui.notify(`Observational memory: ${phase} failed: ${message}`, "warning");
+		this.lastObserverError = message;
+		if (ctx.hasUI && ctx.ui) ctx.ui.notify(`pi-contemplator: ${phase} failed: ${message}`, "warning");
 		return message;
 	}
 
@@ -310,7 +393,7 @@ export class Runtime {
 				await work();
 			} catch (error) {
 				errorMessage = error instanceof Error ? error.message : String(error);
-				if (hasUI && ui) ui.notify(`Observational memory: ${label} failed: ${errorMessage}`, "warning");
+				if (hasUI && ui) ui.notify(`pi-contemplator: ${label} failed: ${errorMessage}`, "warning");
 			} finally {
 				onFinally(errorMessage);
 			}

package/src/session-ledger/fold.ts

@@ -1,16 +1,15 @@
 import {
-	isObservationsDroppedData,
+	isMemoryDetails,
 	isObservationsRecordedData,
-	isReflectionsRecordedData,
-	OM_OBSERVATIONS_DROPPED,
+	isReviewResultEntry,
+	isSummarizerCommitData,
 	OM_OBSERVATIONS_RECORDED,
-	OM_REFLECTIONS_RECORDED,
 	OM_REVIEW_RESULT,
-	isReviewResultEntry,
+	OM_SUMMARIZER_COMMIT,
 	type Entry,
 	type Observation,
-	type Reflection,
 	type ReviewResult,
+	type Summary,
 } from "./types.js";
 
 export type FoldLedgerOptions = {
@@ -19,19 +18,18 @@ export type FoldLedgerOptions = {
 };
 
 export type FoldedLedger = {
-	/** All first-valid observation records encountered through the fold boundary, including dropped observations. */
+	/** All first-valid durable observation records through the fold boundary. */
 	observations: Observation[];
-	/** Observation records not tombstoned by a folded drop entry. */
 	activeObservations: Observation[];
-	/** Tombstoned observation ids, including ids that may not have a corresponding folded observation. */
-	droppedObservationIds: Set<string>;
-	/** All first-valid reflection records encountered through the fold boundary. */
-	reflections: Reflection[];
-	/** All first-valid observation records by id, including dropped observations. */
+	/** All first-valid durable summary records through the fold boundary. */
+	summaries: Summary[];
+	activeSummaries: Summary[];
 	observationsById: Map<string, Observation>;
-	/** All first-valid reflection records by id. */
-	reflectionsById: Map<string, Reflection>;
-	/** All first-valid advisory review results by memory id. */
+	summariesById: Map<string, Summary>;
+	/** Source -> every summary that cites it, including non-consuming citations. */
+	citedBySummaryIds: Map<string, string[]>;
+	/** Source -> the first summary that removed it from automatic visibility. */
+	consumedBySummaryId: Map<string, string>;
 	reviews: ReviewResult[];
 	reviewsById: Map<string, ReviewResult>;
 };
@@ -46,70 +44,101 @@ function isCustomEntry(entry: Entry, customType: string): boolean {
 	return entry.type === "custom" && entry.customType === customType;
 }
 
+function appendUnique(map: Map<string, string[]>, key: string, value: string): void {
+	const existing = map.get(key);
+	if (!existing) {
+		map.set(key, [value]);
+		return;
+	}
+	if (!existing.includes(value)) existing.push(value);
+}
+
 /**
- * Fold valid V3 memory ledger entries from the branch root through the target entry.
+ * Fold the append-only memory graph through a branch boundary.
  *
- * Unknown custom entries, old V2 entries, invalid V3-shaped data, and compaction details are ignored.
- * Observations and reflections use first-valid-record-wins semantics. Drops are tombstones and are
- * retained even when the dropped id is unknown at the time of folding.
+ * Summary bodies occur once. Visibility and forward pointers are derived from
+ * their source/consumption edges. Compaction archives seed the same graph when
+ * older custom records are no longer present on the current branch.
  */
 export function foldLedger(entries: Entry[], options: FoldLedgerOptions = {}): FoldedLedger {
 	const observationsById = new Map<string, Observation>();
-	const reflectionsById = new Map<string, Reflection>();
+	const summariesById = new Map<string, Summary>();
 	const reviewsById = new Map<string, ReviewResult>();
-	const droppedObservationIds = new Set<string>();
+	const citedBySummaryIds = new Map<string, string[]>();
+	const consumedBySummaryId = new Map<string, string>();
 	const endIdx = foldEndIndex(entries, options.upToEntryId);
 
+	const registerObservation = (observation: Observation): void => {
+		if (!observationsById.has(observation.id)) observationsById.set(observation.id, observation);
+	};
+	const registerReview = (review: ReviewResult): void => {
+		if (!reviewsById.has(review.id)) reviewsById.set(review.id, review);
+	};
+	const registerSummaryNodes = (summaries: readonly Summary[]): Summary[] => {
+		const newlyRegistered: Summary[] = [];
+		for (const summary of summaries) {
+			if (summariesById.has(summary.id)) continue;
+			summariesById.set(summary.id, summary);
+			newlyRegistered.push(summary);
+		}
+		return newlyRegistered;
+	};
+	const registerSummaryEdges = (summaries: readonly Summary[]): void => {
+		for (const summary of summaries) {
+			for (const sourceId of summary.sourceMemoryIds) appendUnique(citedBySummaryIds, sourceId, summary.id);
+			for (const sourceId of summary.consumedMemoryIds) {
+				// Reviews are deliberately non-consumable. Unknown/corrupt edges also
+				// cannot hide a node. The first valid consumer wins.
+				if (!observationsById.has(sourceId) && !summariesById.has(sourceId)) continue;
+				if (!consumedBySummaryId.has(sourceId)) consumedBySummaryId.set(sourceId, summary.id);
+			}
+		}
+	};
+
 	for (let i = 0; i <= endIdx; i++) {
 		const entry = entries[i];
 		if (!entry) continue;
 
-		if (isCustomEntry(entry, OM_OBSERVATIONS_RECORDED)) {
-			if (!isObservationsRecordedData(entry.data)) continue;
-			for (const observation of entry.data.observations) {
-				if (!observationsById.has(observation.id)) {
-					observationsById.set(observation.id, observation);
-				}
-			}
+		if (entry.type === "compaction" && isMemoryDetails(entry.details)) {
+			const archivedObservations = entry.details.archive?.observations ?? entry.details.observations;
+			const archivedSummaries = entry.details.archive?.summaries ?? entry.details.summaries;
+			for (const observation of archivedObservations) registerObservation(observation);
+			for (const review of entry.details.reviews ?? []) registerReview(review);
+			const registered = registerSummaryNodes(archivedSummaries);
+			registerSummaryEdges(registered);
 			continue;
 		}
 
-		if (isCustomEntry(entry, OM_REFLECTIONS_RECORDED)) {
-			if (!isReflectionsRecordedData(entry.data)) continue;
-			for (const reflection of entry.data.reflections) {
-				if (!reflectionsById.has(reflection.id)) {
-					reflectionsById.set(reflection.id, reflection);
-				}
-			}
+		if (isCustomEntry(entry, OM_OBSERVATIONS_RECORDED)) {
+			if (!isObservationsRecordedData(entry.data)) continue;
+			for (const observation of entry.data.observations) registerObservation(observation);
 			continue;
 		}
 
-		if (isCustomEntry(entry, OM_OBSERVATIONS_DROPPED)) {
-			if (!isObservationsDroppedData(entry.data)) continue;
-			for (const observationId of entry.data.observationIds) {
-				droppedObservationIds.add(observationId);
-			}
+		if (isCustomEntry(entry, OM_SUMMARIZER_COMMIT)) {
+			if (!isSummarizerCommitData(entry.data)) continue;
+			// Register every node before edges so same-commit citation targets are
+			// addressable. The summarizer itself prevents consuming same-run nodes.
+			const registered = registerSummaryNodes(entry.data.summaries);
+			registerSummaryEdges(registered);
 			continue;
 		}
 
-		if (entry.customType === OM_REVIEW_RESULT && isReviewResultEntry(entry) && !reviewsById.has(entry.data.result.id)) {
-			reviewsById.set(entry.data.result.id, entry.data.result);
-		}
+		if (entry.customType === OM_REVIEW_RESULT && isReviewResultEntry(entry)) registerReview(entry.data.result);
 	}
 
 	const observations = Array.from(observationsById.values());
-	const activeObservations = observations.filter((observation) => !droppedObservationIds.has(observation.id));
-	const reflections = Array.from(reflectionsById.values());
-	const reviews = Array.from(reviewsById.values());
-
+	const summaries = Array.from(summariesById.values());
 	return {
 		observations,
-		activeObservations,
-		droppedObservationIds,
-		reflections,
-		reviews,
+		activeObservations: observations.filter((memory) => !consumedBySummaryId.has(memory.id)),
+		summaries,
+		activeSummaries: summaries.filter((memory) => !consumedBySummaryId.has(memory.id)),
 		observationsById,
-		reflectionsById,
+		summariesById,
+		citedBySummaryIds,
+		consumedBySummaryId,
+		reviews: Array.from(reviewsById.values()),
 		reviewsById,
 	};
 }

package/src/session-ledger/index.ts

@@ -2,6 +2,7 @@ export * from "./types.js";
 export * from "./progress.js";
 export * from "./fold.js";
 export * from "./projection.js";
+export * from "./pools.js";
 export * from "./recall.js";
 export * from "./search.js";
 export * from "./render-summary.js";

package/src/session-ledger/pools.ts

@@ -0,0 +1,77 @@
+import type { Observation, Summary } from "./types.js";
+
+export type ActiveMemory =
+	| { kind: "observation"; memory: Observation }
+	| { kind: "summary"; memory: Summary };
+
+export type MemoryPools = {
+	/** Older active memories eligible for summarization. */
+	old: ActiveMemory[];
+	/** Newest contiguous active-memory suffix protected from summarization. */
+	new: ActiveMemory[];
+	oldTokens: number;
+	newTokens: number;
+	totalTokens: number;
+};
+
+function parsedTimestamp(value: string): number {
+	const parsed = Date.parse(value);
+	return Number.isFinite(parsed) ? parsed : Number.NEGATIVE_INFINITY;
+}
+
+/** Sort observations and summaries together by their effective memory timestamp. */
+export function chronologicalMemories(observations: readonly Observation[], summaries: readonly Summary[]): ActiveMemory[] {
+	return [
+		...observations.map((memory) => ({ kind: "observation" as const, memory })),
+		...summaries.map((memory) => ({ kind: "summary" as const, memory })),
+	].sort((a, b) => parsedTimestamp(a.memory.timestamp) - parsedTimestamp(b.memory.timestamp) || a.memory.id.localeCompare(b.memory.id));
+}
+
+/**
+ * Derive accounting-only pools from active memory. Pool membership is not
+ * persisted: the newest whole-memory suffix fitting the configured token cap
+ * is protected, and every older record is summarizer-eligible. Because records
+ * are indivisible, the newest record is always protected even when it alone
+ * exceeds the cap.
+ */
+export function partitionMemoryPools(
+	observations: readonly Observation[],
+	summaries: readonly Summary[],
+	newPoolMaxTokens: number,
+): MemoryPools {
+	const memories = chronologicalMemories(observations, summaries);
+	const cap = Math.max(0, Math.floor(newPoolMaxTokens));
+	let boundary = memories.length;
+	let newTokens = 0;
+	for (let index = memories.length - 1; index >= 0; index--) {
+		const tokens = memories[index].memory.tokenCount;
+		const isNewest = index === memories.length - 1;
+		if (!isNewest && newTokens + tokens > cap) break;
+		newTokens += tokens;
+		boundary = index;
+	}
+	const old = memories.slice(0, boundary);
+	const recent = memories.slice(boundary);
+	const oldTokens = old.reduce((sum, item) => sum + item.memory.tokenCount, 0);
+	return {
+		old,
+		new: recent,
+		oldTokens,
+		newTokens,
+		totalTokens: oldTokens + newTokens,
+	};
+}
+
+/** Effective timestamp for a new summary: newest timestamp among its sources. */
+export function latestMemoryTimestamp(memories: readonly ActiveMemory[]): string | undefined {
+	let latest: string | undefined;
+	let latestMs = Number.NEGATIVE_INFINITY;
+	for (const item of memories) {
+		const ms = parsedTimestamp(item.memory.timestamp);
+		if (latest === undefined || ms > latestMs || (ms === latestMs && item.memory.timestamp > latest)) {
+			latest = item.memory.timestamp;
+			latestMs = ms;
+		}
+	}
+	return latest;
+}

package/src/session-ledger/progress.ts

@@ -1,11 +1,10 @@
 import { estimateEntryTokens } from "../tokens.js";
 import {
 	OM_AGENT_ACTIVITY,
-	OM_OBSERVATIONS_DROPPED,
 	OM_OBSERVATIONS_RECORDED,
-	OM_REFLECTIONS_RECORDED,
+	OM_SUMMARIZER_COMMIT,
 	type Entry,
-	type V3MemoryCustomType,
+	type MemoryCoverageCustomType,
 } from "./types.js";
 
 const SOURCE_ENTRY_TYPES = new Set(["message", "custom_message", "branch_summary"]);
@@ -72,16 +71,14 @@ function isNonEmptyArray(value: unknown): value is unknown[] {
 	return Array.isArray(value) && value.length > 0;
 }
 
-function isValidCoverageEntry(entry: Entry, customType: V3MemoryCustomType): entry is Entry & { data: { coversUpToId: string } } {
+function isValidCoverageEntry(entry: Entry, customType: MemoryCoverageCustomType): entry is Entry & { data: { coversUpToId: string } } {
 	if (entry.type !== "custom" || entry.customType !== customType) return false;
 	if (!isObject(entry.data) || typeof entry.data.coversUpToId !== "string") return false;
-
 	if (customType === OM_OBSERVATIONS_RECORDED) return isNonEmptyArray(entry.data.observations);
-	if (customType === OM_REFLECTIONS_RECORDED) return isNonEmptyArray(entry.data.reflections);
-	return isNonEmptyArray(entry.data.observationIds);
+	return customType === OM_SUMMARIZER_COMMIT && isNonEmptyArray(entry.data.summaries);
 }
 
-export function latestCoverageIndex(entries: Entry[], customType: V3MemoryCustomType): number {
+export function latestCoverageIndex(entries: Entry[], customType: MemoryCoverageCustomType): number {
 	const idToIndex = entryIndexById(entries);
 	let latest = -1;
 
@@ -95,7 +92,7 @@ export function latestCoverageIndex(entries: Entry[], customType: V3MemoryCustom
 	return latest;
 }
 
-export function latestCoverageMarkerId(entries: Entry[], customType: V3MemoryCustomType): string | undefined {
+export function latestCoverageMarkerId(entries: Entry[], customType: MemoryCoverageCustomType): string | undefined {
 	const idToIndex = entryIndexById(entries);
 	let latestIndex = -1;
 	let latestMarkerId: string | undefined;
@@ -133,7 +130,7 @@ export function rawTokensAfterIndex(entries: Entry[], index: number): number {
 	return total;
 }
 
-export function rawTokensSinceCoverage(entries: Entry[], customType: V3MemoryCustomType): number {
+export function rawTokensSinceCoverage(entries: Entry[], customType: MemoryCoverageCustomType): number {
 	return rawTokensAfterIndex(entries, latestCoverageIndex(entries, customType));
 }
 
@@ -141,14 +138,6 @@ export function rawTokensSinceObservationCoverage(entries: Entry[]): number {
 	return rawTokensSinceCoverage(entries, OM_OBSERVATIONS_RECORDED);
 }
 
-export function rawTokensSinceReflectionCoverage(entries: Entry[]): number {
-	return rawTokensSinceCoverage(entries, OM_REFLECTIONS_RECORDED);
-}
-
-export function rawTokensSinceDropCoverage(entries: Entry[]): number {
-	return rawTokensSinceCoverage(entries, OM_OBSERVATIONS_DROPPED);
-}
-
 export function findLastCompactionIndex(entries: Entry[]): number {
 	for (let i = entries.length - 1; i >= 0; i--) {
 		if (entries[i].type === "compaction") return i;