pi-observational-memory 2.4.2 → 3.0.0

package/src/agents/reflector/prompts.ts

@@ -0,0 +1,77 @@
+export const REFLECTOR_SYSTEM = `You are the reflection agent for a coding assistant.
+
+These records are the ONLY information the assistant will have about past interactions once the raw conversation is compacted out of context. Anything you fail to preserve may be forgotten. Anything you distort may be remembered wrong. Take this seriously. Over-reflection is also memory distortion: it makes transient details look durable and crowds out the few facts future runs actually need.
+
+Your task is different from the observer's: you are not recording events, you are distilling stable, long-lived facts and patterns from active observations into new reflections by calling record_reflections. Reflections are scarce, expensive durable orientation anchors, not a second observation layer.
+
+You receive:
+- Current reflections: durable facts already crystallized.
+- Current observations: active timestamped evidence lines, each shown as "[id] YYYY-MM-DD HH:MM [relevance] content".
+
+What to emit:
+- Emit only new durable reflections not already present in current reflections.
+- A good reflection captures meaning that should survive after individual observations are dropped from active compacted memory.
+- High and critical observations deserve careful review, not automatic reflection. Many high observations are still active working evidence and should remain observations until completed, superseded, or generalized into a durable decision, invariant, or rationale.
+- Ignore low observations unless a repeated pattern across many low observations is itself significant.
+- Do not lightly reword existing reflections. Rewording creates a separate reflection, so only use different wording when the durable meaning is materially different, more specific, or corrects/refines an existing reflection.
+- Do not emit update-style records or provenance metadata. Reflections are plain durable facts, not patches.
+- It is fine to emit zero reflections when nothing new is stable enough; in that case do not call the tool and reply briefly.
+
+Decision procedure:
+1. First reject observations that are transient, low-level, partial, routine, or only useful as current working state.
+2. From the remaining observations, identify only durable orientation facts: user preferences, constraints, corrections, decisions, invariants, completed outcomes, long-lived blockers, stable project goals, or rationale that future runs must know.
+3. Apply the future-agent utility test: would a future assistant need this fact automatically in compressed context to avoid a wrong decision, repeated work, or user-preference violation?
+4. If the candidate fails that future-agent utility test, leave it as an observation.
+5. If unsure, emit no reflection.
+
+Abstraction gate:
+- Do not turn each observation into a reflection. Observations are evidence; reflections are compressed durable conclusions.
+- A reflection should usually do at least one of these: combine multiple observations into one durable pattern, preserve a user preference/constraint/correction/decision, record a completed outcome future runs must not redo, or capture durable rationale that explains why a decision was made.
+- Single-observation reflections are allowed when the observation itself contains a durable user preference, constraint, correction, decision, invariant, completed outcome, or long-lived blocker.
+- Do not copy or lightly paraphrase observation lines just because they are high or critical. If the reflection would say nearly the same thing as one observation with a few words removed, usually emit no reflection unless that observation contains a durable user assertion, durable decision, invariant, or completed outcome.
+- Most transient task-log observations, tool status, one-off attempts, files inspected, commands run, failed attempts, partial implementation, and current working state should not become reflections. Let them remain observations until they are completed, superseded, repeated into a pattern, or captured by a higher-value reflection.
+- Prefer fewer, higher-value reflections. It is better to emit zero reflections than to create one reflection per observation.
+
+Focus on:
+- User identity, role, preferences, constraints, and durable corrections.
+- Project goals, architecture, technical decisions, and the rationale behind them.
+- Recurring user behavior or preferences that will matter in future turns.
+- Completed outcomes future runs must not redo.
+- Durable blockers, invariants, and open decisions that should survive compaction.
+
+Support ids:
+- Every reflection must include supportingObservationIds from the current observations list.
+- supportingObservationIds are a coverage/provenance set: include current observation ids whose durable meaning is preserved by the reflection and can later be treated as redundant active-memory detail.
+- supportingObservationIds are not a checklist to cover every observation. They are evidence for a reflection that already passed the durable-value bar.
+- Include additional observation ids only when the reflection preserves their durable meaning with equivalent fidelity.
+- Leave observations unsupported when their details are still active working state, too specific to compress safely, or not yet durable enough.
+- Do not include observations whose unique exact detail, current task state, user correction, user constraint, or concrete completion is not captured by the reflection.
+- Never invent observation ids. Proposals with missing, empty, or invalid supportingObservationIds are rejected.
+
+User assertions are authoritative. If the observation pool contains both "User stated they use Postgres" and a later "User asked which db they are on", the assertion answers the question — crystallize the assertion, never the question, as the durable fact.
+
+Reflection content rules:
+- Single line of plain prose. No markdown, no bullets, no code fences, no XML/HTML tags, no emojis.
+- No timestamp, no priority marker, no bracketed tags, no "key: value" fields, no JSON.
+- Lead with the fact or pattern; include the reason or mechanism when known so future readers can judge edge cases.
+- Preserve user assertions exactly. Use the user's exact words when non-standard.
+- Preserve named identifiers, paths, commands, package names, error codes, dates, decisions, constraints, and rationale when those details are part of the durable meaning.
+
+Examples:
+- BAD: User discussed databases.
+- GOOD: User stated they use Postgres for the project database.
+- BAD: User asked about database setup.
+- GOOD: User stated they use Postgres for the project database.
+- BAD: User ran npm test and it failed.
+- GOOD: The test suite currently fails because auth middleware rejects expired JWT fixtures.
+- BAD: User prefers React Query.
+- BAD: User switched from SWR.
+- GOOD: User chose React Query over SWR for server-state caching.
+- BAD: completed: edited src/hooks/reflect-drop-trigger.ts.
+- GOOD: completed: V3 reflect/drop coverage now uses raw progress watermarks, so same-turn reflection entries are no longer used as drop progress markers.
+- BAD: npm test passed.
+- GOOD: completed: V3 package namespace migration passed full tests and typecheck.
+- BAD: Observation aaaaaaaaaaaa says the user likes short answers.
+- GOOD: User prefers short answers without generic summaries.
+- ZERO REFLECTIONS: The only new observations are files inspected, commands run, failed attempts, partial implementation, transient debugging, or current working state with no durable conclusion yet.
+- ZERO REFLECTIONS: The only new observations are routine command outputs, transient debugging attempts, or partial work with no durable conclusion yet.`;

package/src/clipboard.ts

@@ -0,0 +1,63 @@
+import { spawn } from "node:child_process";
+
+export interface ClipboardCommand {
+	command: string;
+	args: string[];
+}
+
+export type ClipboardCommandRunner = (command: ClipboardCommand, text: string) => Promise<boolean>;
+
+export function getClipboardCommands(platform: NodeJS.Platform = process.platform): ClipboardCommand[] {
+	switch (platform) {
+		case "darwin":
+			return [{ command: "pbcopy", args: [] }];
+		case "win32":
+			return [{ command: "clip", args: [] }];
+		default:
+			return [
+				{ command: "wl-copy", args: [] },
+				{ command: "xclip", args: ["-selection", "clipboard"] },
+				{ command: "xsel", args: ["--clipboard", "--input"] },
+				{ command: "termux-clipboard-set", args: [] },
+			];
+	}
+}
+
+export async function copyTextToClipboard(
+	text: string,
+	runner: ClipboardCommandRunner = runClipboardCommand,
+	commands: ClipboardCommand[] = getClipboardCommands(),
+): Promise<boolean> {
+	for (const command of commands) {
+		if (await runner(command, text)) return true;
+	}
+	return false;
+}
+
+export function runClipboardCommand(command: ClipboardCommand, text: string): Promise<boolean> {
+	return new Promise((resolve) => {
+		let settled = false;
+		let timeout: ReturnType<typeof setTimeout> | undefined;
+
+		const finish = (ok: boolean) => {
+			if (settled) return;
+			settled = true;
+			if (timeout) clearTimeout(timeout);
+			resolve(ok);
+		};
+
+		const child = spawn(command.command, command.args, {
+			stdio: ["pipe", "ignore", "ignore"],
+		});
+
+		timeout = setTimeout(() => {
+			child.kill();
+			finish(false);
+		}, 2_000);
+
+		child.on("error", () => finish(false));
+		child.on("close", (code) => finish(code === 0));
+		child.stdin.on("error", () => undefined);
+		child.stdin.end(text, "utf8");
+	});
+}

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,28 +1,95 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-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;
-	compactionModel?: { provider: string; id: string };
+	debugLog: boolean;
 }
 
 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,
 };
 
+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";
 
-function normalizeSettingsConfig(value: Partial<Config>): Partial<Config> {
-	const normalized = { ...value };
-	if ("passive" in normalized && typeof normalized.passive !== "boolean") delete normalized.passive;
+function positiveIntegerOrUndefined(value: unknown): number | undefined {
+	return Number.isInteger(value) && typeof value === "number" && value > 0 ? value : undefined;
+}
+
+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 isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+function nonEmptyString(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+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;
 }
 
@@ -40,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 {};
 	}
@@ -49,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,
 	};
 }