pi-observational-memory 2.4.3 → 3.0.1

package/src/commands/status.ts

@@ -1,104 +1,105 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { SettingsManager } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { observationPoolMetrics } from "../agents/dropper/pool.js";
+import type { Runtime } from "../runtime.js";
 import {
-	getMemoryState,
-	rawTokensSinceLastBound,
+	diffProjection,
+	foldLedger,
+	fullProjection,
 	rawTokensSinceLastCompaction,
-} from "../branch.js";
-import { observationPoolTokens as estimateObservationPoolTokens } from "../compaction.js";
-import { countByRelevance, formatRelevanceHistogram } from "../relevance.js";
-import type { Runtime } from "../runtime.js";
-import { estimateStringTokens } from "../tokens.js";
-import { reflectionContent, type MemoryReflection } from "../types.js";
+	rawTokensSinceObservationCoverage,
+	rawTokensSinceReflectionCoverage,
+	visibleProjection,
+	type Entry,
+} from "../session-ledger/index.js";
 
-export function registerStatusCommand(pi: ExtensionAPI, runtime: Runtime): void {
-	pi.registerCommand("om-status", {
-		description: "Show observational memory status",
-		handler: async (_args, ctx) => {
-			runtime.ensureConfig(ctx.cwd);
-			const entries = ctx.sessionManager.getBranch() as Parameters<typeof rawTokensSinceLastBound>[0];
-			const sinceBound = rawTokensSinceLastBound(entries);
-			const sinceCompaction = rawTokensSinceLastCompaction(entries);
+function pct(current: number, total: number): number {
+	return total > 0 ? Math.min(100, Math.round((current / total) * 100)) : 0;
+}
 
-			const { reflections: committedRefs, committedObs, pendingObs } = getMemoryState(entries);
-			const committedRefItems = committedRefs as MemoryReflection[];
-			const committedObsTokens = estimateObservationPoolTokens(committedObs);
-			const committedObsCount = committedObs.length;
-			const committedRefsTokens = committedRefItems.reduce((s, r) => s + estimateStringTokens(reflectionContent(r)), 0);
-			const committedRefsCount = committedRefItems.length;
+function tokenSum(items: { tokenCount: number }[]): number {
+	return items.reduce((sum, item) => sum + item.tokenCount, 0);
+}
 
-			const pendingObsTokens = estimateObservationPoolTokens(pendingObs);
-			const pendingObsCount = pendingObs.length;
+function addedSuffix(count: number): string | undefined {
+	return count > 0 ? `+${count.toLocaleString()}` : undefined;
+}
 
-			const relevanceHistogram = countByRelevance([...committedObs, ...pendingObs]);
+function removedSuffix(count: number): string | undefined {
+	return count > 0 ? `-${count.toLocaleString()}` : undefined;
+}
 
-			const keepRecentTokens = SettingsManager.create(ctx.cwd).getCompactionKeepRecentTokens();
+function appendSuffixes(line: string, suffixes: (string | undefined)[]): string {
+	const rendered = suffixes.filter((suffix): suffix is string => suffix !== undefined);
+	return rendered.length > 0 ? `${line} ${rendered.join(" ")}` : line;
+}
 
-			const obsThreshold = runtime.config.observationThresholdTokens;
-			const compThreshold = runtime.config.compactionThresholdTokens;
-			const refThreshold = runtime.config.reflectionThresholdTokens;
-			// Approximation: the real compaction gate excludes pending obs whose coversFromId falls inside
-			// the new keep-recent tail (deferred to next cycle) and adds any sync-catch-up gap obs produced
-			// at compaction entry. We over-count by the tail slice and can't predict the gap obs here.
-			// Precise version would simulate the new firstKeptEntryId by walking back keepRecentTokens from
-			// the branch tail and split pending into pre-tail vs tail-covering.
-			const observationPoolTokens = estimateObservationPoolTokens([...committedObs, ...pendingObs]);
-			const obsPct = Math.min(100, Math.round((sinceBound / obsThreshold) * 100));
-			const compPct = Math.min(100, Math.round((sinceCompaction / compThreshold) * 100));
-			const refPct = Math.min(100, Math.round((observationPoolTokens / refThreshold) * 100));
+export function registerStatusCommand(pi: ExtensionAPI, runtime: Runtime): void {
+	pi.registerCommand("om-status", {
+		description: "Show observational memory status",
+		handler: async (_args, ctx) => {
+			runtime.ensureConfig(ctx.cwd);
+			const entries = ctx.sessionManager.getBranch() as Entry[];
+			const folded = foldLedger(entries);
+			const visible = visibleProjection(entries);
+			const full = fullProjection(entries);
+			const drift = diffProjection(visible, full);
 
-			const refLabel = committedRefsCount === 1 ? "entry" : "entries";
-			const cObsLabel = committedObsCount === 1 ? "observation" : "observations";
-			const pObsLabel = pendingObsCount === 1 ? "observation" : "observations";
+			const visibleObservationTokens = tokenSum(visible.observations);
+			const visibleReflectionTokens = tokenSum(visible.reflections);
+			const activeObservationPool = observationPoolMetrics(folded.activeObservations, runtime.config.observationsPoolTargetTokens);
+			const observationLine = appendSuffixes(
+				`Observations: ${folded.observations.length} recorded / ${folded.droppedObservationIds.size} dropped / ${folded.activeObservations.length} active / ${visible.observations.length} visible`,
+				[
+					addedSuffix(drift.observationsOnlyInFull.length),
+					removedSuffix(drift.droppedOnlyInFull.length),
+				],
+			);
+			const reflectionLine = appendSuffixes(
+				`Reflections:  ${folded.reflections.length} recorded / ${visible.reflections.length} visible`,
+				[addedSuffix(drift.reflectionsOnlyInFull.length)],
+			);
+			const obsProgress = rawTokensSinceObservationCoverage(entries);
+			const reflectionProgress = rawTokensSinceReflectionCoverage(entries);
+			const compactionProgress = rawTokensSinceLastCompaction(entries);
 
 			const passiveLines = runtime.config.passive === true
 				? [
 					"── Mode ──",
-					"Passive: proactive observation and compaction triggers disabled; compaction hook remains active",
+					"Passive: automatic memory workers and auto-compaction disabled; manual/Pi compaction, commands, and recall remain active",
 					"",
 				]
 				: [];
 
-			const activityLines = runtime.config.passive === true
-				? [
-					"── Activity ──",
-					`Observation trigger: passive (~${sinceBound.toLocaleString()} / ${obsThreshold.toLocaleString()} tokens, ${obsPct}%)`,
-					"  → proactive observation is disabled; manual/Pi compaction can still run sync catch-up observation",
-					`Compaction trigger:  passive (~${sinceCompaction.toLocaleString()} / ${compThreshold.toLocaleString()} tokens, ${compPct}%)`,
-					"  → proactive extension-triggered compaction is disabled; manual/Pi compaction still uses the custom hook",
-					`Next reflection:     ~${observationPoolTokens.toLocaleString()} / ${refThreshold.toLocaleString()} tokens (${refPct}%)`,
-					`  → if observations exceed ${refThreshold.toLocaleString()} tokens when compaction runs, reflections are`,
-					`    distilled from them and redundant observations are pruned away`,
-				]
-				: [
-					"── Activity ──",
-					`Next observation: ~${sinceBound.toLocaleString()} / ${obsThreshold.toLocaleString()} tokens (${obsPct}%)`,
-					`  → at ${obsThreshold.toLocaleString()} tokens, recent conversation is compressed into new observations`,
-					`Next compaction:  ~${sinceCompaction.toLocaleString()} / ${compThreshold.toLocaleString()} tokens (${compPct}%)`,
-					`  → at ${compThreshold.toLocaleString()} tokens, raw history is replaced by the updated reflections and`,
-					`    observations, keeping only the last ${keepRecentTokens.toLocaleString()} tokens of conversation verbatim`,
-					`Next reflection:  ~${observationPoolTokens.toLocaleString()} / ${refThreshold.toLocaleString()} tokens (${refPct}%)`,
-					`  → if observations exceed ${refThreshold.toLocaleString()} tokens when compaction runs, reflections are`,
-					`    distilled from them and redundant observations are pruned away`,
-				];
-
 			const lines = [
 				...passiveLines,
 				"── Memory ──",
-				`Reflections:   ~${committedRefsTokens.toLocaleString()} tokens (${committedRefsCount} ${refLabel})      — durable insights`,
-				`Observations:`,
-				`  committed    ~${committedObsTokens.toLocaleString()} tokens (${committedObsCount} ${cObsLabel}) — folded into last compaction`,
-				`  pending      ~${pendingObsTokens.toLocaleString()} tokens (${pendingObsCount} ${pObsLabel}) — waiting for next compaction`,
-				`  relevance    ${formatRelevanceHistogram(relevanceHistogram)}`,
+				observationLine,
+				reflectionLine,
 				"",
-				...activityLines,
+				"── Activity ──",
+				`Next observation: ~${obsProgress.toLocaleString()} / ${runtime.config.observeAfterTokens.toLocaleString()} tokens (${pct(obsProgress, runtime.config.observeAfterTokens)}%)`,
+				`Next reflection:  ~${reflectionProgress.toLocaleString()} / ${runtime.config.reflectAfterTokens.toLocaleString()} tokens (${pct(reflectionProgress, runtime.config.reflectAfterTokens)}%)`,
+				`Next compaction:  ~${compactionProgress.toLocaleString()} / ${runtime.config.compactAfterTokens.toLocaleString()} tokens (${pct(compactionProgress, runtime.config.compactAfterTokens)}%)`,
+				`Visible observation pool: ~${visibleObservationTokens.toLocaleString()} / ${runtime.config.observationsPoolMaxTokens.toLocaleString()} tokens (${pct(visibleObservationTokens, runtime.config.observationsPoolMaxTokens)}%)`,
+				`Active observation pool: ~${activeObservationPool.observationTokens.toLocaleString()} / ${runtime.config.observationsPoolTargetTokens.toLocaleString()} target tokens (${pct(activeObservationPool.observationTokens, runtime.config.observationsPoolTargetTokens)}%)`,
+				`Reflection pool:         ~${visibleReflectionTokens.toLocaleString()} tokens`,
 			];
 
-			if (runtime.observerInFlight || runtime.compactInFlight) {
-				lines.push("");
-				lines.push("── In flight ──");
-				if (runtime.observerInFlight) lines.push("Observer: running");
-				if (runtime.compactInFlight) lines.push("Compaction: running");
+			if (runtime.consolidationInFlight || runtime.compactInFlight || runtime.compactHookInFlight) {
+				lines.push("", "── In flight ──");
+				if (runtime.consolidationInFlight) {
+					const phase = runtime.consolidationPhase ? ` (${runtime.consolidationPhase})` : "";
+					lines.push(`Consolidation: running${phase}`);
+				}
+				if (runtime.compactInFlight) lines.push("Auto-compaction: running");
+				if (runtime.compactHookInFlight) lines.push("Compaction hook: running");
+			}
+
+			if (runtime.lastObserverError || runtime.lastReflectorError || runtime.lastDropperError) {
+				lines.push("", "── Last error ──");
+				if (runtime.lastObserverError) lines.push(`Observer: ${runtime.lastObserverError}`);
+				if (runtime.lastReflectorError) lines.push(`Reflector: ${runtime.lastReflectorError}`);
+				if (runtime.lastDropperError) lines.push(`Dropper: ${runtime.lastDropperError}`);
 			}
 
 			ctx.ui.notify(lines.join("\n"), "info");

package/src/commands/view.ts

@@ -1,82 +1,74 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { getMemoryState } from "../branch.js";
-import { observationPoolTokens as estimateObservationPoolTokens } from "../compaction.js";
-import { countByRelevance, formatRelevanceHistogram } from "../relevance.js";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { Runtime } from "../runtime.js";
-import { estimateStringTokens } from "../tokens.js";
-import { reflectionContent, reflectionToPromptLine, type MemoryReflection, type ObservationRecord } from "../types.js";
+import { copyTextToClipboard } from "../clipboard.js";
+import {
+	fullProjection,
+	observationToSummaryLine,
+	reflectionToSummaryLine,
+	visibleProjection,
+	type Entry,
+	type Projection,
+} from "../session-ledger/index.js";
 
-export function registerViewCommand(pi: ExtensionAPI, runtime: Runtime): void {
-	pi.registerCommand("om-view", {
-		description: "Print observational memory details (reflections + observations)",
-		handler: async (_args, ctx) => {
-			runtime.ensureConfig(ctx.cwd);
-			const entries = ctx.sessionManager.getBranch() as Parameters<typeof getMemoryState>[0];
-			const { reflections: committedRefs, committedObs, pendingObs } = getMemoryState(entries);
-			const committedRefItems = committedRefs as MemoryReflection[];
-
-			const committedRefTokens = committedRefItems.reduce((s, r) => s + estimateStringTokens(reflectionContent(r)), 0);
-			const committedRefCount = committedRefItems.length;
-
-			const committedObsTokens = estimateObservationPoolTokens(committedObs);
-			const committedObsCount = committedObs.length;
+function firstArg(args: unknown): string | undefined {
+	if (Array.isArray(args)) return typeof args[0] === "string" ? args[0] : undefined;
+	if (typeof args === "string") return args.trim().split(/\s+/)[0];
+	if (args && typeof args === "object" && "mode" in args) {
+		const mode = (args as { mode?: unknown }).mode;
+		return typeof mode === "string" ? mode : undefined;
+	}
+	return undefined;
+}
 
-			const pendingObsTokens = estimateObservationPoolTokens(pendingObs);
-			const pendingObsCount = pendingObs.length;
+function renderList<T>(items: T[], render: (item: T) => string, empty: string): string {
+	return items.length > 0 ? items.map(render).join("\n") : empty;
+}
 
-			const totalObsCount = committedObsCount + pendingObsCount;
-			const totalObsTokens = estimateObservationPoolTokens([...committedObs, ...pendingObs]);
-			const totalTokens = committedRefTokens + totalObsTokens;
-			const relevanceHistogram = countByRelevance([...committedObs, ...pendingObs]);
+function renderContentOnlyProjection(projection: Projection, emptyScope: "visible" | "recorded"): string {
+	return [
+		"── Reflections ──",
+		renderList(projection.reflections, reflectionToSummaryLine, `No ${emptyScope} reflections.`),
+		"",
+		"── Observations ──",
+		renderList(projection.observations, observationToSummaryLine, `No ${emptyScope} observations.`),
+	].join("\n");
+}
 
-			const plural = (n: number, singular: string, plural: string) => (n === 1 ? singular : plural);
-			const renderObs = (r: ObservationRecord) =>
-				`[${r.id}] ${r.timestamp} [${r.relevance}] ${r.content}`;
+interface ViewCommandOptions {
+	copyToClipboard?: (text: string) => Promise<boolean>;
+}
 
-			const sections: string[] = [];
+export function registerViewCommand(pi: ExtensionAPI, runtime: Runtime, options: ViewCommandOptions = {}): void {
+	const copyToClipboard = options.copyToClipboard ?? copyTextToClipboard;
 
-			sections.push(
-				`Memory: ${committedRefCount} ${plural(committedRefCount, "reflection", "reflections")} · ` +
-					`${totalObsCount} ${plural(totalObsCount, "observation", "observations")} ` +
-					`(${committedObsCount} committed, ${pendingObsCount} pending) · ` +
-					`~${totalTokens.toLocaleString()} tokens · ` +
-					`relevance ${formatRelevanceHistogram(relevanceHistogram)}`,
-			);
-			sections.push("");
+	pi.registerCommand("om-view", {
+		description: "Print and copy observational memory content (visible by default, full for recorded memory)",
+		handler: async (args, ctx) => {
+			runtime.ensureConfig(ctx.cwd);
+			const entries = ctx.sessionManager.getBranch() as Entry[];
+			const mode = firstArg(args);
 
-			sections.push(
-				`── Reflections (${committedRefCount} ${plural(committedRefCount, "entry", "entries")}, ~${committedRefTokens.toLocaleString()} tokens) ──`,
-			);
-			if (committedRefItems.length > 0) {
-				sections.push(committedRefItems.map(reflectionToPromptLine).join("\n\n"));
-			} else {
-				sections.push("(none)");
-			}
+			const notifyWithCopy = async (output: string) => {
+				const copied = await copyToClipboard(output).catch(() => false);
+				ctx.ui.notify(
+					copied
+						? `${output}\n\nCopied /om-view output to clipboard.`
+						: `${output}\n\nWarning: failed to copy /om-view output to clipboard.`,
+					"info",
+				);
+			};
 
-			sections.push("");
-			sections.push(
-				`── Observations — committed (${committedObsCount} ${plural(committedObsCount, "observation", "observations")}, ~${committedObsTokens.toLocaleString()} tokens) ──`,
-			);
-			if (committedObs.length > 0) {
-				sections.push(committedObs.map(renderObs).join("\n"));
-			} else {
-				sections.push("(none)");
+			if (mode === "full") {
+				await notifyWithCopy(renderContentOnlyProjection(fullProjection(entries), "recorded"));
+				return;
 			}
 
-			sections.push("");
-			sections.push(
-				`── Observations — pending (${pendingObsCount} ${plural(pendingObsCount, "observation", "observations")}, ~${pendingObsTokens.toLocaleString()} tokens) ──`,
-			);
-			if (pendingObs.length > 0) {
-				sections.push(pendingObs.map(renderObs).join("\n"));
-			} else {
-				sections.push("(none)");
+			if (mode && mode !== "visible") {
+				ctx.ui.notify("Usage: /om-view [full]", "info");
+				return;
 			}
 
-			sections.push("");
-			sections.push("Tip: use /tree to browse the raw messages still live in the session.");
-
-			ctx.ui.notify(sections.join("\n"), "info");
+			await notifyWithCopy(renderContentOnlyProjection(visibleProjection(entries), "visible"));
 		},
 	});
 }

package/src/config.ts

@@ -1,85 +1,96 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import type { ModelThinkingLevel } from "@mariozechner/pi-ai";
-import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import type { ModelThinkingLevel } from "@earendil-works/pi-ai";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+export interface ConfiguredModel {
+	provider: string;
+	id: string;
+	thinking?: ModelThinkingLevel;
+}
 
 export interface Config {
-	observationThresholdTokens: number;
-	compactionThresholdTokens: number;
-	reflectionThresholdTokens: number;
+	observeAfterTokens: number;
+	reflectAfterTokens: number;
+	compactAfterTokens: number;
+	observationsPoolMaxTokens: number;
+	observationsPoolTargetTokens: number;
+	agentMaxTurns: number;
+	model?: ConfiguredModel;
 	passive: boolean;
 	debugLog: boolean;
-	compactionModel?: { provider: string; id: string };
-	observerMaxTurnsPerRun?: number;
-	reflectorMaxTurnsPerPass?: number;
-	prunerMaxTurnsPerPass?: number;
-	thinkingLevel: ModelThinkingLevel;
-	/** @deprecated Use reflectorMaxTurnsPerPass and prunerMaxTurnsPerPass. */
-	compactionMaxToolCalls?: number;
-}
-
-export interface EffectiveTurnLimits {
-	observerMaxTurnsPerRun: number;
-	reflectorMaxTurnsPerPass: number;
-	prunerMaxTurnsPerPass: number;
 }
 
 export const DEFAULTS: Config = {
-	observationThresholdTokens: 1_000,
-	compactionThresholdTokens: 50_000,
-	reflectionThresholdTokens: 30_000,
+	observeAfterTokens: 10_000,
+	reflectAfterTokens: 20_000,
+	compactAfterTokens: 81_000,
+	observationsPoolMaxTokens: 20_000,
+	observationsPoolTargetTokens: 10_000,
+	agentMaxTurns: 16,
 	passive: false,
 	debugLog: false,
-	thinkingLevel: "low",
 };
 
 export const THINKING_LEVEL_VALUES: readonly ModelThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
 
 const SETTINGS_KEY = "observational-memory";
 const PASSIVE_ENV = "PI_OBSERVATIONAL_MEMORY_PASSIVE";
-const DEFAULT_MAX_TURNS = 16;
 
 function positiveIntegerOrUndefined(value: unknown): number | undefined {
 	return Number.isInteger(value) && typeof value === "number" && value > 0 ? value : undefined;
 }
 
-function normalizeTurnLimit<K extends keyof Config>(normalized: Partial<Config>, key: K): void {
-	if (!(key in normalized)) return;
-	const value = positiveIntegerOrUndefined(normalized[key]);
-	if (value === undefined) {
-		delete normalized[key];
-	} else {
-		(normalized as Record<K, number>)[key] = value;
-	}
+function validTargetOrUndefined(value: unknown, maxTokens: number): number | undefined {
+	const target = positiveIntegerOrUndefined(value);
+	return target !== undefined && target < maxTokens ? target : undefined;
+}
+
+function derivedObservationPoolTarget(maxTokens: number): number {
+	return Math.floor(maxTokens / 2);
 }
 
 function isThinkingLevel(value: unknown): value is ModelThinkingLevel {
 	return typeof value === "string" && (THINKING_LEVEL_VALUES as readonly string[]).includes(value);
 }
 
-function normalizeThinkingLevel(normalized: Partial<Config>): void {
-	if (!("thinkingLevel" in normalized)) return;
-	if (!isThinkingLevel(normalized.thinkingLevel)) delete normalized.thinkingLevel;
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
 }
 
-function normalizeSettingsConfig(value: Partial<Config>): Partial<Config> {
-	const normalized = { ...value };
-	if ("passive" in normalized && typeof normalized.passive !== "boolean") delete normalized.passive;
-	if ("debugLog" in normalized && typeof normalized.debugLog !== "boolean") delete normalized.debugLog;
-	normalizeTurnLimit(normalized, "observerMaxTurnsPerRun");
-	normalizeTurnLimit(normalized, "reflectorMaxTurnsPerPass");
-	normalizeTurnLimit(normalized, "prunerMaxTurnsPerPass");
-	normalizeTurnLimit(normalized, "compactionMaxToolCalls");
-	normalizeThinkingLevel(normalized);
-	return normalized;
+function nonEmptyString(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 
-export function resolveTurnLimits(config: Config): EffectiveTurnLimits {
-	return {
-		observerMaxTurnsPerRun: config.observerMaxTurnsPerRun ?? DEFAULT_MAX_TURNS,
-		reflectorMaxTurnsPerPass: config.reflectorMaxTurnsPerPass ?? config.compactionMaxToolCalls ?? DEFAULT_MAX_TURNS,
-		prunerMaxTurnsPerPass: config.prunerMaxTurnsPerPass ?? config.compactionMaxToolCalls ?? DEFAULT_MAX_TURNS,
-	};
+function normalizeModel(value: unknown): ConfiguredModel | undefined {
+	if (!isRecord(value)) return undefined;
+	const provider = nonEmptyString(value.provider);
+	const id = nonEmptyString(value.id);
+	if (!provider || !id) return undefined;
+	const model: ConfiguredModel = { provider, id };
+	if (isThinkingLevel(value.thinking)) model.thinking = value.thinking;
+	return model;
+}
+
+function normalizeSettingsConfig(value: Record<string, unknown>): Partial<Config> {
+	const normalized: Partial<Config> = {};
+	const numberKeys = [
+		"observeAfterTokens",
+		"reflectAfterTokens",
+		"compactAfterTokens",
+		"observationsPoolMaxTokens",
+		"observationsPoolTargetTokens",
+		"agentMaxTurns",
+	] as const;
+	for (const key of numberKeys) {
+		const normalizedValue = positiveIntegerOrUndefined(value[key]);
+		if (normalizedValue !== undefined) normalized[key] = normalizedValue;
+	}
+	if (typeof value.passive === "boolean") normalized.passive = value.passive;
+	if (typeof value.debugLog === "boolean") normalized.debugLog = value.debugLog;
+	const model = normalizeModel(value.model);
+	if (model) normalized.model = model;
+	return normalized;
 }
 
 export function readEnvConfig(env: NodeJS.ProcessEnv = process.env): Partial<Config> {
@@ -96,7 +107,7 @@ function readNamespacedConfig(path: string): Partial<Config> {
 	try {
 		const raw = JSON.parse(readFileSync(path, "utf-8")) as Record<string, unknown>;
 		const nested = raw[SETTINGS_KEY];
-		return nested && typeof nested === "object" ? normalizeSettingsConfig(nested as Partial<Config>) : {};
+		return isRecord(nested) ? normalizeSettingsConfig(nested) : {};
 	} catch {
 		return {};
 	}
@@ -105,11 +116,23 @@ function readNamespacedConfig(path: string): Partial<Config> {
 export function loadConfig(cwd: string, env: NodeJS.ProcessEnv = process.env): Config {
 	const globalPath = join(getAgentDir(), "settings.json");
 	const projectPath = join(cwd, ".pi", "settings.json");
+	const globalConfig = readNamespacedConfig(globalPath);
+	const projectConfig = readNamespacedConfig(projectPath);
+	const envConfig = readEnvConfig(env);
+	const merged = {
+		...DEFAULTS,
+		observationsPoolTargetTokens: undefined,
+		...globalConfig,
+		...projectConfig,
+		...envConfig,
+	};
+	const target = validTargetOrUndefined(
+		merged.observationsPoolTargetTokens,
+		merged.observationsPoolMaxTokens,
+	) ?? derivedObservationPoolTarget(merged.observationsPoolMaxTokens);
 
 	return {
-		...DEFAULTS,
-		...readNamespacedConfig(globalPath),
-		...readNamespacedConfig(projectPath),
-		...readEnvConfig(env),
+		...merged,
+		observationsPoolTargetTokens: target,
 	};
 }

package/src/debug-log.ts

@@ -1,14 +1,17 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { existsSync, mkdirSync, renameSync, statSync, unlinkSync, appendFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
 
 export const DEBUG_LOG_MAX_BYTES = 10 * 1024 * 1024;
 export const DEBUG_LOG_RELATIVE_PATH = join("observational-memory", "debug.ndjson");
+export const DEBUG_LOG_SESSION_DIR_RELATIVE_PATH = join("observational-memory", "debug");
 
-interface DebugLogContext {
+export interface DebugLogContext {
 	enabled: boolean;
 	cwd?: string;
+	sessionId?: string;
+	sessionFile?: string;
 	runId?: string;
 }
 
@@ -19,8 +22,22 @@ export function withDebugLogContext<T>(context: DebugLogContext, fn: () => T): T
 	return storage.run({ ...parent, ...context }, fn);
 }
 
-export function isDebugLogEnabled(): boolean {
-	return storage.getStore()?.enabled === true;
+export function safeDebugLogSessionId(sessionId: string | undefined): string | undefined {
+	const trimmed = sessionId?.trim();
+	if (!trimmed) return undefined;
+	const sanitized = trimmed
+		.replace(/[^A-Za-z0-9._-]+/g, "_")
+		.replace(/^_+|_+$/g, "")
+		.slice(0, 128);
+	if (!/[A-Za-z0-9]/.test(sanitized)) return undefined;
+	return sanitized;
+}
+
+export function debugLogRelativePath(context: Pick<DebugLogContext, "sessionId">): string {
+	const safeSessionId = safeDebugLogSessionId(context.sessionId);
+	return safeSessionId
+		? join(DEBUG_LOG_SESSION_DIR_RELATIVE_PATH, `${safeSessionId}.ndjson`)
+		: DEBUG_LOG_RELATIVE_PATH;
 }
 
 export function debugLog(event: string, data: Record<string, unknown> = {}): void {
@@ -28,13 +45,15 @@ export function debugLog(event: string, data: Record<string, unknown> = {}): voi
 	if (context?.enabled !== true) return;
 
 	try {
-		const path = join(getAgentDir(), DEBUG_LOG_RELATIVE_PATH);
+		const path = join(getAgentDir(), debugLogRelativePath(context));
 		mkdirSync(dirname(path), { recursive: true });
 		rotateIfNeeded(path);
 		const payload = {
 			ts: new Date().toISOString(),
 			event,
 			cwd: context.cwd,
+			sessionId: context.sessionId,
+			sessionFile: context.sessionFile,
 			runId: context.runId,
 			data,
 		};