pi-observational-memory 2.4.2 → 3.0.0

package/src/hooks/consolidation-trigger.ts

@@ -0,0 +1,331 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { runDropper } from "../agents/dropper/agent.js";
+import { observationPoolMetrics } from "../agents/dropper/pool.js";
+import { runObserver } from "../agents/observer/agent.js";
+import { runReflector } from "../agents/reflector/agent.js";
+import { debugLog, withDebugLogContext } from "../debug-log.js";
+import { type ResolveResult, type Runtime } from "../runtime.js";
+import { serializeSourceAddressedBranchEntries } from "../serialize.js";
+import {
+	OM_OBSERVATIONS_DROPPED,
+	OM_OBSERVATIONS_RECORDED,
+	OM_REFLECTIONS_RECORDED,
+	buildObservationsDroppedData,
+	buildObservationsRecordedData,
+	buildReflectionsRecordedData,
+	earlierCoverageMarkerId,
+	foldLedger,
+	fullProjection,
+	isSourceEntry,
+	latestCoverageIndex,
+	latestCoverageMarkerId,
+	observationToSummaryLine,
+	rawTokensSinceObservationCoverage,
+	rawTokensSinceReflectionCoverage,
+	reflectionToSummaryLine,
+	type Entry,
+	type Reflection,
+} from "../session-ledger/index.js";
+
+type ResolvedModel = Extract<ResolveResult, { ok: true }>;
+
+type ConsolidationCtx = {
+	cwd: string;
+	hasUI: boolean;
+	ui?: { notify: (message: string, type?: "warning" | "info" | "error") => void };
+	model: unknown;
+	modelRegistry: any;
+	sessionManager: { getBranch: () => unknown };
+};
+
+type StageOutcome = "continue" | "abort";
+
+type ReflectorStageResult = {
+	outcome: StageOutcome;
+	sameRunReflections: Reflection[];
+	effectiveReflectionCoverageId?: string;
+};
+
+function sourceEntriesAfter(entries: Entry[], index: number): Entry[] {
+	return entries.slice(index + 1).filter(isSourceEntry);
+}
+
+function appendEntry(pi: ExtensionAPI, customType: string, data: unknown): void {
+	pi.appendEntry(customType, data);
+}
+
+function mergeReflections(existing: Reflection[], additional: Reflection[]): Reflection[] {
+	const seen = new Set(existing.map((reflection) => reflection.id));
+	const merged = [...existing];
+	for (const reflection of additional) {
+		if (seen.has(reflection.id)) continue;
+		seen.add(reflection.id);
+		merged.push(reflection);
+	}
+	return merged;
+}
+
+function anyStageDue(entries: Entry[], runtime: Runtime): boolean {
+	return rawTokensSinceObservationCoverage(entries) >= runtime.config.observeAfterTokens
+		|| rawTokensSinceReflectionCoverage(entries) >= runtime.config.reflectAfterTokens;
+}
+
+function makeModelResolver(runtime: Runtime, ctx: ConsolidationCtx): (stage: "observer" | "reflector" | "dropper") => Promise<ResolvedModel | undefined> {
+	let cached: ResolveResult | undefined;
+	return async (stage) => {
+		cached ??= await runtime.resolveModel({
+			model: ctx.model,
+			modelRegistry: ctx.modelRegistry,
+			hasUI: ctx.hasUI,
+			ui: ctx.ui,
+		});
+		if (cached.ok) {
+			runtime.resolveFailureNotified = false;
+			return cached;
+		}
+		debugLog(`${stage}.model_unavailable`, { reason: cached.reason });
+		if (!runtime.resolveFailureNotified && ctx.hasUI && ctx.ui) {
+			ctx.ui.notify(`Observational memory: ${stage} skipped — ${cached.reason}`, "warning");
+			runtime.resolveFailureNotified = true;
+		}
+		return undefined;
+	};
+}
+
+export function registerConsolidationTrigger(pi: ExtensionAPI, runtime: Runtime): void {
+	const launch = (_event: unknown, ctx: ConsolidationCtx) => {
+		maybeLaunchConsolidation(pi, runtime, ctx);
+	};
+	pi.on("agent_start", launch);
+	pi.on("turn_end", launch);
+}
+
+function maybeLaunchConsolidation(pi: ExtensionAPI, runtime: Runtime, ctx: ConsolidationCtx): void {
+	runtime.ensureConfig(ctx.cwd);
+	if (runtime.config.passive === true) return;
+	if (runtime.consolidationInFlight) return;
+
+	const entries = ctx.sessionManager.getBranch() as Entry[];
+	if (!anyStageDue(entries, runtime)) return;
+
+	const runId = `consolidation-${Date.now().toString(36)}-${Math.random().toString(16).slice(2, 8)}`;
+	const consolidationCtx: ConsolidationCtx = {
+		cwd: ctx.cwd,
+		hasUI: ctx.hasUI,
+		ui: ctx.ui,
+		model: ctx.model,
+		modelRegistry: ctx.modelRegistry,
+		sessionManager: ctx.sessionManager,
+	};
+
+	void runtime.launchConsolidationTask(ctx, async () => withDebugLogContext({ enabled: runtime.config.debugLog === true, cwd: ctx.cwd, runId }, async () => {
+		await runConsolidationPipeline(pi, runtime, consolidationCtx);
+	}));
+}
+
+export async function runConsolidationPipeline(
+	pi: ExtensionAPI,
+	runtime: Runtime,
+	ctx: ConsolidationCtx,
+): Promise<void> {
+	const resolveModel = makeModelResolver(runtime, ctx);
+
+	runtime.consolidationPhase = "observer";
+	try {
+		const observerOutcome = await runObserverStage(pi, runtime, ctx, resolveModel);
+		if (observerOutcome === "abort") return;
+	} catch (error) {
+		debugLog("observer.error", { errorMessage: runtime.recordConsolidationStageError(ctx, "observer", error) });
+		return;
+	}
+
+	runtime.consolidationPhase = "reflector";
+	let reflectorResult: ReflectorStageResult;
+	try {
+		reflectorResult = await runReflectorStage(pi, runtime, ctx, resolveModel);
+		if (reflectorResult.outcome === "abort") return;
+	} catch (error) {
+		debugLog("reflector.error", { errorMessage: runtime.recordConsolidationStageError(ctx, "reflector", error) });
+		return;
+	}
+
+	runtime.consolidationPhase = "dropper";
+	try {
+		await runDropperStage(pi, runtime, ctx, resolveModel, reflectorResult.sameRunReflections, reflectorResult.effectiveReflectionCoverageId);
+	} catch (error) {
+		debugLog("dropper.error", { errorMessage: runtime.recordConsolidationStageError(ctx, "dropper", error) });
+	}
+}
+
+async function runObserverStage(
+	pi: ExtensionAPI,
+	runtime: Runtime,
+	ctx: ConsolidationCtx,
+	resolveModel: (stage: "observer") => Promise<ResolvedModel | undefined>,
+): Promise<StageOutcome> {
+	const entries = ctx.sessionManager.getBranch() as Entry[];
+	const tokens = rawTokensSinceObservationCoverage(entries);
+	if (tokens < runtime.config.observeAfterTokens) return "continue";
+
+	const lastCoverageIdx = latestCoverageIndex(entries, OM_OBSERVATIONS_RECORDED);
+	const chunkEntries = sourceEntriesAfter(entries, lastCoverageIdx);
+	const coversUpToId = chunkEntries.at(-1)?.id;
+	if (!coversUpToId) return "continue";
+
+	const { text: chunk, sourceEntryIds } = serializeSourceAddressedBranchEntries(chunkEntries);
+	if (!chunk.trim() || sourceEntryIds.length === 0) return "continue";
+
+	const memory = fullProjection(entries);
+	const priorReflections = memory.reflections.map(reflectionToSummaryLine);
+	const priorObservations = memory.observations.map(observationToSummaryLine);
+
+	if (ctx.hasUI) ctx.ui?.notify(
+		`Observational memory: observer running on ~${tokens.toLocaleString()}-token chunk`,
+		"info",
+	);
+	debugLog("observer.start", {
+		tokens,
+		coversUpToId,
+		sourceEntryIds,
+		sourceEntryCount: sourceEntryIds.length,
+		priorReflections: priorReflections.length,
+		priorObservations: priorObservations.length,
+	});
+
+	const resolved = await resolveModel("observer");
+	if (!resolved) return "abort";
+
+	const observations = await runObserver({
+		model: resolved.model as any,
+		apiKey: resolved.apiKey,
+		headers: resolved.headers,
+		priorReflections,
+		priorObservations,
+		chunk,
+		allowedSourceEntryIds: sourceEntryIds,
+		maxTurns: runtime.config.agentMaxTurns,
+		thinkingLevel: runtime.config.model?.thinking ?? "low",
+	});
+	if (!observations || observations.length === 0) {
+		debugLog("observer.empty", { coversUpToId });
+		if (ctx.hasUI) ctx.ui?.notify(
+			"Observational memory: observer returned no observations",
+			"warning",
+		);
+		return "continue";
+	}
+
+	const data = buildObservationsRecordedData(observations, coversUpToId);
+	if (!data) return "continue";
+	debugLog("observer.records", {
+		count: observations.length,
+		observationTokens: observations.reduce((sum, observation) => sum + observation.tokenCount, 0),
+		coversUpToId,
+		observations,
+	});
+	appendEntry(pi, OM_OBSERVATIONS_RECORDED, data);
+	debugLog("observer.appended", { count: observations.length, coversUpToId });
+	if (ctx.hasUI) ctx.ui?.notify(
+		`Observational memory: ${observations.length} observation${observations.length === 1 ? "" : "s"} recorded`,
+		"info",
+	);
+	return "continue";
+}
+
+async function runReflectorStage(
+	pi: ExtensionAPI,
+	runtime: Runtime,
+	ctx: ConsolidationCtx,
+	resolveModel: (stage: "reflector") => Promise<ResolvedModel | undefined>,
+): Promise<ReflectorStageResult> {
+	const entries = ctx.sessionManager.getBranch() as Entry[];
+	const reflectionTokens = rawTokensSinceReflectionCoverage(entries);
+	if (reflectionTokens < runtime.config.reflectAfterTokens) return { outcome: "continue", sameRunReflections: [] };
+
+	const observationCoverageId = latestCoverageMarkerId(entries, OM_OBSERVATIONS_RECORDED);
+	if (!observationCoverageId) return { outcome: "continue", sameRunReflections: [] };
+
+	if (ctx.hasUI) ctx.ui?.notify(
+		`Observational memory: reflector running (~${reflectionTokens.toLocaleString()} tokens)`,
+		"info",
+	);
+	const resolved = await resolveModel("reflector");
+	if (!resolved) return { outcome: "abort", sameRunReflections: [] };
+
+	const folded = foldLedger(entries);
+	const reflections = await runReflector({
+		model: resolved.model as any,
+		apiKey: resolved.apiKey,
+		headers: resolved.headers,
+		reflections: folded.reflections,
+		observations: folded.activeObservations,
+		maxTurns: runtime.config.agentMaxTurns,
+		thinkingLevel: runtime.config.model?.thinking ?? "low",
+	});
+	if (!reflections) return { outcome: "continue", sameRunReflections: [] };
+
+	const data = buildReflectionsRecordedData(reflections, observationCoverageId);
+	if (!data) return { outcome: "continue", sameRunReflections: [] };
+	appendEntry(pi, OM_REFLECTIONS_RECORDED, data);
+	return {
+		outcome: "continue",
+		sameRunReflections: reflections,
+		effectiveReflectionCoverageId: data.coversUpToId,
+	};
+}
+
+async function runDropperStage(
+	pi: ExtensionAPI,
+	runtime: Runtime,
+	ctx: ConsolidationCtx,
+	resolveModel: (stage: "dropper") => Promise<ResolvedModel | undefined>,
+	sameRunReflections: Reflection[],
+	sameRunReflectionCoverageId: string | undefined,
+): Promise<StageOutcome> {
+	if (!sameRunReflectionCoverageId || sameRunReflections.length === 0) {
+		debugLog("dropper.waiting_for_reflection", { sameRunReflections: sameRunReflections.length });
+		return "continue";
+	}
+
+	const entries = ctx.sessionManager.getBranch() as Entry[];
+	const observationCoverageId = latestCoverageMarkerId(entries, OM_OBSERVATIONS_RECORDED);
+	if (!observationCoverageId) return "continue";
+
+	const folded = foldLedger(entries);
+	const metrics = observationPoolMetrics(folded.activeObservations, runtime.config.observationsPoolTargetTokens);
+	if (!metrics.ready) {
+		debugLog("dropper.not_ready", {
+			observationTokens: metrics.observationTokens,
+			targetTokens: metrics.targetTokens,
+			tokensOverTarget: metrics.tokensOverTarget,
+			fullness: metrics.fullness,
+			activeObservationCount: metrics.activeObservationCount,
+			droppableCount: metrics.droppableCount,
+			maxDropsAllowed: metrics.maxDropsAllowed,
+		});
+		return "continue";
+	}
+
+	if (ctx.hasUI) ctx.ui?.notify(
+		`Observational memory: dropper running after reflection — active observation pool ~${metrics.observationTokens.toLocaleString()} / ${metrics.targetTokens.toLocaleString()} target tokens (${Math.round(metrics.fullness * 100).toLocaleString()}%)`,
+		"info",
+	);
+	const resolved = await resolveModel("dropper");
+	if (!resolved) return "abort";
+
+	const reflectionsForDropper = mergeReflections(folded.reflections, sameRunReflections);
+	const droppedIds = await runDropper({
+		model: resolved.model as any,
+		apiKey: resolved.apiKey,
+		headers: resolved.headers,
+		reflections: reflectionsForDropper,
+		observations: folded.activeObservations,
+		targetTokens: runtime.config.observationsPoolTargetTokens,
+		maxTurns: runtime.config.agentMaxTurns,
+		thinkingLevel: runtime.config.model?.thinking ?? "low",
+	});
+	const coversUpToId = earlierCoverageMarkerId(entries, observationCoverageId, sameRunReflectionCoverageId);
+	const data = coversUpToId && droppedIds ? buildObservationsDroppedData(droppedIds, coversUpToId) : undefined;
+	if (data) appendEntry(pi, OM_OBSERVATIONS_DROPPED, data);
+	return "continue";
+}

package/src/index.ts

@@ -1,16 +1,16 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerStatusCommand } from "./commands/status.js";
 import { registerViewCommand } from "./commands/view.js";
 import { registerCompactionHook } from "./hooks/compaction-hook.js";
 import { registerCompactionTrigger } from "./hooks/compaction-trigger.js";
-import { registerObserverTrigger } from "./hooks/observer-trigger.js";
+import { registerConsolidationTrigger } from "./hooks/consolidation-trigger.js";
 import { Runtime } from "./runtime.js";
 import { registerRecallTool } from "./tools/recall-observation.js";
 
 export default function observationalMemory(pi: ExtensionAPI) {
 	const runtime = new Runtime();
 
-	registerObserverTrigger(pi, runtime);
+	registerConsolidationTrigger(pi, runtime);
 	registerCompactionTrigger(pi, runtime);
 	registerCompactionHook(pi, runtime);
 

package/src/model-budget.ts

@@ -0,0 +1,9 @@
+import type { Model } from "@earendil-works/pi-ai";
+
+export const AGENT_LOOP_MAX_TOKENS = 32_000;
+
+export function boundedMaxTokens(model: Model<any>, requested: number = AGENT_LOOP_MAX_TOKENS): number {
+	return typeof model.maxTokens === "number" && model.maxTokens > 0
+		? Math.min(model.maxTokens, requested)
+		: requested;
+}

package/src/runtime.ts

@@ -6,6 +6,7 @@ export type ResolveResult =
 
 type NotifyLevel = "warning" | "info" | "error";
 type Notify = (message: string, type?: NotifyLevel) => void;
+export type ConsolidationPhase = "observer" | "reflector" | "dropper";
 
 export interface ResolveCtx {
 	model: unknown;
@@ -22,11 +23,15 @@ export interface LaunchCtx {
 export class Runtime {
 	config: Config = { ...DEFAULTS };
 	configLoaded = false;
-	observerInFlight = false;
-	observerPromise: Promise<void> | null = null;
+	consolidationInFlight = false;
+	consolidationPromise: Promise<void> | null = null;
+	consolidationPhase: ConsolidationPhase | undefined;
 	compactInFlight = false;
 	compactHookInFlight = false;
 	resolveFailureNotified = false;
+	lastObserverError: string | undefined;
+	lastReflectorError: string | undefined;
+	lastDropperError: string | undefined;
 
 	ensureConfig(cwd: string): void {
 		if (this.configLoaded) return;
@@ -36,18 +41,18 @@ export class Runtime {
 
 	async resolveModel(ctx: ResolveCtx): Promise<ResolveResult> {
 		let model = ctx.model;
-		if (this.config.compactionModel) {
-			const configured = ctx.modelRegistry.find(this.config.compactionModel.provider, this.config.compactionModel.id);
+		if (this.config.model) {
+			const configured = ctx.modelRegistry.find(this.config.model.provider, this.config.model.id);
 			if (configured) {
 				model = configured;
 			} else if (ctx.hasUI && ctx.ui) {
 				ctx.ui.notify(
-					`Observational memory: configured model ${this.config.compactionModel.provider}/${this.config.compactionModel.id} not found, using session model`,
+					`Observational memory: configured model ${this.config.model.provider}/${this.config.model.id} not found, using session model`,
 					"warning",
 				);
 			}
 		}
-		if (!model) return { ok: false, reason: "no model available (session has no model and no compactionModel configured)" };
+		if (!model) return { ok: false, reason: "no model available (session has no model and no observational-memory model configured)" };
 		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
 		if (!auth.ok || !auth.apiKey) {
 			const provider = (model as { provider?: string }).provider ?? "unknown";
@@ -56,26 +61,48 @@ export class Runtime {
 		return { ok: true, model, apiKey: auth.apiKey as string, headers: auth.headers as Record<string, string> | undefined };
 	}
 
-	launchObserverTask(ctx: LaunchCtx, label: string, work: () => Promise<void>): Promise<void> {
-		this.observerInFlight = true;
-		// Capture ctx properties synchronously — after `await work()` the extension ctx
-		// may be stale (e.g. after ctx.newSession/fork/switchSession/reload), and accessing
-		// ctx.hasUI or ctx.ui on a stale proxy throws.
+	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;
+			if (this.consolidationPromise === promise) this.consolidationPromise = null;
+		});
+		this.consolidationPromise = promise;
+		return promise;
+	}
+
+	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");
+		return message;
+	}
+
+	private launchTrackedTask(
+		ctx: LaunchCtx,
+		label: string,
+		work: () => Promise<void>,
+		onFinally: (error: string | undefined) => void,
+	): Promise<void> {
 		const hasUI = ctx.hasUI;
 		const ui = ctx.ui;
-		let promise!: Promise<void>;
-		promise = (async () => {
+		return (async () => {
+			let errorMessage: string | undefined;
 			try {
 				await work();
 			} catch (error) {
-				const msg = error instanceof Error ? error.message : String(error);
-				if (hasUI && ui) ui.notify(`Observational memory: ${label} failed: ${msg}`, "warning");
+				errorMessage = error instanceof Error ? error.message : String(error);
+				if (hasUI && ui) ui.notify(`Observational memory: ${label} failed: ${errorMessage}`, "warning");
 			} finally {
-				this.observerInFlight = false;
-				if (this.observerPromise === promise) this.observerPromise = null;
+				onFinally(errorMessage);
 			}
 		})();
-		this.observerPromise = promise;
-		return promise;
 	}
 }

package/src/serialize.ts

@@ -1,4 +1,4 @@
-import type { Message, TextContent, ToolResultMessage } from "@mariozechner/pi-ai";
+import type { Message, TextContent, ToolResultMessage } from "@earendil-works/pi-ai";
 
 function pad(n: number): string {
 	return n.toString().padStart(2, "0");

package/src/session-ledger/fold.ts

@@ -0,0 +1,100 @@
+import {
+	isObservationsDroppedData,
+	isObservationsRecordedData,
+	isReflectionsRecordedData,
+	OM_OBSERVATIONS_DROPPED,
+	OM_OBSERVATIONS_RECORDED,
+	OM_REFLECTIONS_RECORDED,
+	type Entry,
+	type Observation,
+	type Reflection,
+} from "./types.js";
+
+export type FoldLedgerOptions = {
+	/** Fold entries from branch root through this entry id, inclusive. Omit to fold through branch tip. */
+	upToEntryId?: string;
+};
+
+export type FoldedLedger = {
+	/** All first-valid observation records encountered through the fold boundary, including dropped observations. */
+	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. */
+	observationsById: Map<string, Observation>;
+	/** All first-valid reflection records by id. */
+	reflectionsById: Map<string, Reflection>;
+};
+
+function foldEndIndex(entries: Entry[], upToEntryId: string | undefined): number {
+	if (!upToEntryId) return entries.length - 1;
+	const idx = entries.findIndex((entry) => entry.id === upToEntryId);
+	return idx === -1 ? entries.length - 1 : idx;
+}
+
+function isCustomEntry(entry: Entry, customType: string): boolean {
+	return entry.type === "custom" && entry.customType === customType;
+}
+
+/**
+ * Fold valid V3 memory ledger entries from the branch root through the target entry.
+ *
+ * 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.
+ */
+export function foldLedger(entries: Entry[], options: FoldLedgerOptions = {}): FoldedLedger {
+	const observationsById = new Map<string, Observation>();
+	const reflectionsById = new Map<string, Reflection>();
+	const droppedObservationIds = new Set<string>();
+	const endIdx = foldEndIndex(entries, options.upToEntryId);
+
+	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);
+				}
+			}
+			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);
+				}
+			}
+			continue;
+		}
+
+		if (isCustomEntry(entry, OM_OBSERVATIONS_DROPPED)) {
+			if (!isObservationsDroppedData(entry.data)) continue;
+			for (const observationId of entry.data.observationIds) {
+				droppedObservationIds.add(observationId);
+			}
+		}
+	}
+
+	const observations = Array.from(observationsById.values());
+	const activeObservations = observations.filter((observation) => !droppedObservationIds.has(observation.id));
+	const reflections = Array.from(reflectionsById.values());
+
+	return {
+		observations,
+		activeObservations,
+		droppedObservationIds,
+		reflections,
+		observationsById,
+		reflectionsById,
+	};
+}

package/src/session-ledger/index.ts

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./progress.js";
+export * from "./fold.js";
+export * from "./projection.js";
+export * from "./recall.js";
+export * from "./render-summary.js";