@matthewfl/pi-contemplator 0.0.1

package/src/commands/settings.ts

@@ -0,0 +1,257 @@
+import { DynamicBorder, getSelectListTheme } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Container, getKeybindings, Input, SelectList, Spacer, Text, fuzzyFilter, type Focusable, type SelectItem } from "@earendil-works/pi-tui";
+import type { ConfiguredModel } from "../config.js";
+import { OM_SETTINGS, type Runtime, type SessionSettings } from "../runtime.js";
+
+type ModelRegistryLike = {
+	refresh?(): Promise<void>;
+	getAvailable(): Array<{ provider: string; id: string }>;
+	getAll(): Array<{ provider: string; id: string }>;
+};
+type NumberSetting = "observeAfterTokens" | "reflectAfterTokens" | "compactAfterTokens" | "observerChunkMaxTokens" | "observationsPoolMaxTokens" | "observationsPoolTargetTokens" | "agentMaxTurns" | "contemplatorMinNewObservations" | "contemplatorMinNewReflections" | "contemplatorMinTurns";
+type BooleanSetting = "contemplatorEnabled" | "reviewerEnabled" | "compactionObserverEnabled" | "showWorkerNotifications" | "passive" | "debugLog";
+
+function modelLabel(model: ConfiguredModel | undefined): string {
+	return model ? `${model.provider}/${model.id}` : "current session model";
+}
+
+function branch(ctx: ExtensionContext): readonly unknown[] {
+	return ctx.sessionManager.getBranch() as readonly unknown[];
+}
+
+function appendSettings(pi: ExtensionAPI, runtime: Runtime, settings: SessionSettings): void {
+	runtime.setSessionSettings(settings);
+	pi.appendEntry(OM_SETTINGS, { version: 1, ...settings });
+}
+
+function hasOverride(settings: SessionSettings, key: string): boolean {
+	return  Object.hasOwn(settings, key);
+}
+
+function scalarLabel(runtime: Runtime, key: NumberSetting | BooleanSetting | "compactAfterTokensRatio"): string {
+	const current = runtime.config[key];
+	const defaultValue = runtime.getDefaultConfig()[key];
+	const renderedDefault = defaultValue === undefined ? "derived" : String(defaultValue);
+	return hasOverride(runtime.getSessionSettings(), key) ? String(current) : `default (${renderedDefault})`;
+}
+
+interface ModelOption extends SelectItem {
+	configuredModel: ConfiguredModel | null;
+}
+
+class FilterableModelSelector extends Container implements Focusable {
+	private readonly searchInput = new Input();
+	private readonly listContainer = new Container();
+	private readonly allItems: ModelOption[];
+	private readonly done: (value: ConfiguredModel | null | undefined) => void;
+	private list!: SelectList;
+	private _focused = false;
+
+	get focused(): boolean {
+		return this._focused;
+	}
+
+	set focused(value: boolean) {
+		this._focused = value;
+		this.searchInput.focused = value;
+	}
+
+	constructor(
+		title: string,
+		models: ConfiguredModel[],
+		current: ConfiguredModel | undefined,
+		done: (value: ConfiguredModel | null | undefined) => void,
+	) {
+		super();
+		this.done = done;
+		this.allItems = [
+			{ value: "", label: "Use current session model", description: current ? `(current: ${modelLabel(current)})` : "(current session model)", configuredModel: null },
+			...models.map((model) => ({
+				value: `${model.provider}/${model.id}`,
+				label: `${model.provider}/${model.id}`,
+				description: current && model.provider === current.provider && model.id === current.id ? "(current)" : undefined,
+				configuredModel: model,
+			})),
+		];
+		this.addChild(new DynamicBorder());
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(`${title} — type to filter; ↑/↓ to scroll; Enter to select`, 0, 0));
+		this.addChild(new Spacer(1));
+		this.addChild(this.searchInput);
+		this.addChild(new Spacer(1));
+		this.addChild(this.listContainer);
+		this.addChild(new Spacer(1));
+		this.addChild(new DynamicBorder());
+		this.searchInput.onSubmit = () => {
+			const selected = this.list.getSelectedItem();
+			if (selected) done((selected as ModelOption).configuredModel);
+		};
+		this.updateList();
+	}
+
+	private updateList(): void {
+		const query = this.searchInput.getValue();
+		const filtered = query ? fuzzyFilter(this.allItems, query, (item) => item.value || item.label) : this.allItems;
+		this.list = new SelectList(filtered, 5, getSelectListTheme());
+		this.list.onSelect = (item) => this.done((item as ModelOption).configuredModel);
+		this.list.onCancel = () => this.done(undefined);
+		this.listContainer.clear();
+		this.listContainer.addChild(this.list);
+	}
+
+	handleInput(keyData: string): void {
+		const kb = getKeybindings();
+		if (kb.matches(keyData, "tui.select.up") || kb.matches(keyData, "tui.select.down") || kb.matches(keyData, "tui.select.confirm") || kb.matches(keyData, "tui.select.cancel")) {
+			this.list.handleInput(keyData);
+			return;
+		}
+		this.searchInput.handleInput(keyData);
+		this.updateList();
+	}
+}
+
+async function chooseModel(ctx: ExtensionContext, current: ConfiguredModel | undefined, title: string): Promise<ConfiguredModel | null | undefined> {
+	const registry = ctx.modelRegistry as unknown as ModelRegistryLike;
+	await registry.refresh?.();
+	const available = registry.getAvailable();
+	const models = available.length > 0 ? available : registry.getAll();
+	if (models.length === 0) {
+		ctx.ui.notify("No configured models are available.", "warning");
+		return undefined;
+	}
+	return ctx.ui.custom((_tui, _theme, _keybindings, done) => new FilterableModelSelector(title, models, current, done));
+}
+
+async function editNumber(ctx: ExtensionContext, runtime: Runtime, key: NumberSetting, title: string): Promise<number | undefined> {
+	const value = await ctx.ui.input(`${title} (current: ${scalarLabel(runtime, key)})`, "positive integer; blank cancels");
+	if (value === undefined || value.trim() === "") return undefined;
+	const parsed = Number(value.trim());
+	if (!Number.isInteger(parsed) || parsed <= 0) {
+		ctx.ui.notify("Value must be a positive integer.", "warning");
+		return undefined;
+	}
+	return parsed;
+}
+
+function validObservationPoolOverride(ctx: ExtensionContext, runtime: Runtime, key: NumberSetting, value: number): boolean {
+	if (key === "observationsPoolMaxTokens" && value <= runtime.config.observationsPoolTargetTokens) {
+		ctx.ui.notify("Observation pool max must be greater than the current target. Lower the target first.", "warning");
+		return false;
+	}
+	if (key === "observationsPoolTargetTokens" && value >= runtime.config.observationsPoolMaxTokens) {
+		ctx.ui.notify("Observation pool target must be less than the current maximum.", "warning");
+		return false;
+	}
+	return true;
+}
+
+export function registerSettingsCommand(pi: ExtensionAPI, runtime: Runtime): void {
+	const restoreSettings = (_event: unknown, ctx: ExtensionContext) => {
+		runtime.ensureConfig(ctx.cwd);
+		runtime.restoreSessionSettings(branch(ctx));
+	};
+	pi.on("session_start", restoreSettings);
+	pi.on("session_tree", restoreSettings);
+
+	pi.registerCommand("om:settings", {
+		description: "Configure observational memory for this session",
+		handler: async (args, ctx) => {
+		runtime.ensureConfig(ctx.cwd);
+		runtime.restoreSessionSettings(branch(ctx));
+		const argument = typeof args === "string" ? args.trim().toLowerCase() : "";
+		if (argument === "on" || argument === "off") {
+			appendSettings(pi, runtime, { contemplatorEnabled: argument === "on" });
+			ctx.ui.notify(`Contemplation: ${argument === "on" ? "enabled" : "disabled"} for this session.`, "info");
+			return;
+		}
+		if (argument === "compaction on" || argument === "compaction off") {
+			appendSettings(pi, runtime, { compactionObserverEnabled: argument.endsWith("on") });
+			ctx.ui.notify(`Compaction observer: ${argument.endsWith("on") ? "enabled" : "disabled"} for this session.`, "info");
+			return;
+		}
+		if (argument === "reviewer on" || argument === "reviewer off") {
+			appendSettings(pi, runtime, { reviewerEnabled: argument.endsWith("on") });
+			ctx.ui.notify(`Structural reviewer: ${argument.endsWith("on") ? "enabled" : "disabled"} for this session.`, "info");
+			return;
+		}
+		if (argument) {
+			ctx.ui.notify("Usage: /om:settings [on|off|reviewer on|reviewer off|compaction on|compaction off]", "info");
+			return;
+		}
+
+		while (true) {
+			const settings = runtime.getSessionSettings();
+			const choice = await ctx.ui.select("Observational memory settings (session overrides)", [
+				`Contemplation: ${scalarLabel(runtime, "contemplatorEnabled")}`,
+				`Contemplation model: ${hasOverride(settings, "contemplatorModel") ? modelLabel(runtime.config.contemplatorModel) : `default (${modelLabel(runtime.getDefaultConfig().contemplatorModel)})`}`,
+				`Structural reviewer: ${scalarLabel(runtime, "reviewerEnabled")}`,
+				`Structural reviewer model: ${hasOverride(settings, "reviewerModel") ? modelLabel(runtime.config.reviewerModel) : `default (${modelLabel(runtime.getDefaultConfig().reviewerModel)})`}`,
+				`Compaction observer: ${scalarLabel(runtime, "compactionObserverEnabled")}`,
+				`Memory worker model: ${hasOverride(settings, "model") ? modelLabel(runtime.config.model) : `default (${modelLabel(runtime.getDefaultConfig().model)})`}`,
+				`Observation threshold: ${scalarLabel(runtime, "observeAfterTokens")}`,
+				`Reflection threshold: ${scalarLabel(runtime, "reflectAfterTokens")}`,
+				`Compaction threshold: ${scalarLabel(runtime, "compactAfterTokens")}`,
+				`Compaction mode: ${hasOverride(settings, "compactAfterTokensMode") ? runtime.config.compactAfterTokensMode : `default (${runtime.getDefaultConfig().compactAfterTokensMode})`}`,
+				`Compaction ratio: ${hasOverride(settings, "compactAfterTokensRatio") ? runtime.config.compactAfterTokensRatio : `default (${runtime.getDefaultConfig().compactAfterTokensRatio})`}`,
+				`Observer chunk limit: ${scalarLabel(runtime, "observerChunkMaxTokens")}`,
+				`Observation pool max: ${scalarLabel(runtime, "observationsPoolMaxTokens")}`,
+				`Observation pool target: ${scalarLabel(runtime, "observationsPoolTargetTokens")}`,
+				`Worker max turns: ${scalarLabel(runtime, "agentMaxTurns")}`,
+				`Contemplation observation trigger: ${scalarLabel(runtime, "contemplatorMinNewObservations")}`,
+				`Contemplation reflection trigger: ${scalarLabel(runtime, "contemplatorMinNewReflections")}`,
+				`Contemplation turn interval: ${scalarLabel(runtime, "contemplatorMinTurns")}`,
+				`Worker notifications: ${scalarLabel(runtime, "showWorkerNotifications")}`,
+				`Passive mode: ${scalarLabel(runtime, "passive")}`,
+				`Debug logging: ${scalarLabel(runtime, "debugLog")}`,
+				"Done",
+			]);
+			if (!choice || choice === "Done") return;
+			if (choice.startsWith("Contemplation:")) appendSettings(pi, runtime, { contemplatorEnabled: !runtime.config.contemplatorEnabled });
+			else if (choice.startsWith("Structural reviewer:")) appendSettings(pi, runtime, { reviewerEnabled: !runtime.config.reviewerEnabled });
+			else if (choice.startsWith("Compaction observer:")) appendSettings(pi, runtime, { compactionObserverEnabled: !runtime.config.compactionObserverEnabled });
+			else if (choice.startsWith("Worker notifications:")) appendSettings(pi, runtime, { showWorkerNotifications: !runtime.config.showWorkerNotifications });
+			else if (choice.startsWith("Passive mode:")) appendSettings(pi, runtime, { passive: !runtime.config.passive });
+			else if (choice.startsWith("Debug logging:")) appendSettings(pi, runtime, { debugLog: !runtime.config.debugLog });
+			else if (choice.startsWith("Contemplation model:")) {
+				const model = await chooseModel(ctx, runtime.config.contemplatorModel, "Contemplation model");
+				if (model !== undefined) appendSettings(pi, runtime, { contemplatorModel: model });
+			} else if (choice.startsWith("Structural reviewer model:")) {
+				const model = await chooseModel(ctx, runtime.config.reviewerModel, "Structural reviewer model");
+				if (model !== undefined) appendSettings(pi, runtime, { reviewerModel: model });
+			} else if (choice.startsWith("Memory worker model:")) {
+				const model = await chooseModel(ctx, runtime.config.model, "Memory worker model");
+				if (model !== undefined) appendSettings(pi, runtime, { model });
+			} else if (choice.startsWith("Compaction mode:")) {
+				const mode = await ctx.ui.select("Compaction threshold mode", ["calibrated", "ratio"]);
+				if (mode === "calibrated" || mode === "ratio") appendSettings(pi, runtime, { compactAfterTokensMode: mode });
+			} else if (choice.startsWith("Compaction ratio:")) {
+				const value = await ctx.ui.input(`Compaction ratio (current: ${scalarLabel(runtime, "compactAfterTokensRatio")})`, "decimal between 0 and 1");
+				const ratio = value === undefined ? undefined : Number(value.trim());
+				if (ratio !== undefined && Number.isFinite(ratio) && ratio > 0 && ratio < 1) appendSettings(pi, runtime, { compactAfterTokensRatio: ratio });
+				else if (value !== undefined) ctx.ui.notify("Ratio must be a number between 0 and 1.", "warning");
+			} else {
+				const numberChoice: Array<[string, NumberSetting, string]> = [
+					["Observation threshold:", "observeAfterTokens", "Observation threshold"],
+					["Reflection threshold:", "reflectAfterTokens", "Reflection threshold"],
+					["Compaction threshold:", "compactAfterTokens", "Compaction threshold"],
+					["Observer chunk limit:", "observerChunkMaxTokens", "Observer chunk limit"],
+					["Observation pool max:", "observationsPoolMaxTokens", "Observation pool max"],
+					["Observation pool target:", "observationsPoolTargetTokens", "Observation pool target"],
+					["Worker max turns:", "agentMaxTurns", "Worker max turns"],
+					["Contemplation observation trigger:", "contemplatorMinNewObservations", "Contemplation observation trigger"],
+					["Contemplation reflection trigger:", "contemplatorMinNewReflections", "Contemplation reflection trigger"],
+					["Contemplation turn interval:", "contemplatorMinTurns", "Contemplation turn interval"],
+				];
+				const selected = numberChoice.find(([prefix]) => choice.startsWith(prefix));
+				if (selected) {
+					const value = await editNumber(ctx, runtime, selected[1], selected[2]);
+					if (value !== undefined && validObservationPoolOverride(ctx, runtime, selected[1], value)) {
+						appendSettings(pi, runtime, { [selected[1]]: value } as SessionSettings);
+					}
+				}
+			}
+		}
+	},
+	});
+}

package/src/commands/status.ts

@@ -0,0 +1,176 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { observationPoolMetrics } from "../agents/dropper/pool.js";
+import { resolveCompactAfterTokens } from "../config.js";
+import type { Runtime } from "../runtime.js";
+import {
+	diffProjection,
+	foldLedger,
+	fullProjection,
+	rawTokensSinceLastCompaction,
+	rawTokensSinceObservationCoverage,
+	rawTokensSinceReflectionCoverage,
+	visibleProjection,
+	type Entry,
+} from "../session-ledger/index.js";
+
+const CONTEMPLATOR_SUGGESTION = "om.contemplator.suggestion";
+const REVIEWER_NOTICE = "om.reviewer.notice";
+
+function pct(current: number, total: number): number {
+	return total > 0 ? Math.round((current / total) * 100) : 0;
+}
+
+function formatTokens(n: number): string {
+	if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1).replace(/\.0$/, "")}M`;
+	if (n >= 1_000) return `${(n / 1_000).toFixed(1).replace(/\.0$/, "")}k`;
+	return String(n);
+}
+
+function truncateStatusText(value: string, limit = 1_000): string {
+	return value.length <= limit ? value : `${value.slice(0, limit - 1)}…`;
+}
+
+function tokenSum(items: { tokenCount: number }[]): number {
+	return items.reduce((sum, item) => sum + item.tokenCount, 0);
+}
+
+function addedSuffix(count: number): string | undefined {
+	return count > 0 ? `+${count.toLocaleString()}` : undefined;
+}
+
+function removedSuffix(count: number): string | undefined {
+	return count > 0 ? `-${count.toLocaleString()}` : undefined;
+}
+
+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;
+}
+
+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 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 contextWindow = typeof ctx.model?.contextWindow === "number" ? ctx.model.contextWindow : undefined;
+			const compactThreshold = resolveCompactAfterTokens(runtime.config, contextWindow);
+
+			const passiveLines = runtime.config.passive === true
+				? [
+					"── Mode ──",
+					"Passive: automatic memory workers and auto-compaction disabled; manual/Pi compaction, commands, and recall remain active",
+					"",
+				]
+				: [];
+
+			const lines = [
+				...passiveLines,
+				"── Memory ──",
+				observationLine,
+				reflectionLine,
+				"",
+				"── 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()} / ${compactThreshold.toLocaleString()} tokens (${pct(compactionProgress, compactThreshold)}%)`,
+				`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`,
+				`Compaction observer:     ${runtime.config.compactionObserverEnabled === false ? "disabled" : "enabled"}`,
+				`Contemplator:             ${runtime.config.contemplatorEnabled ? "enabled" : "disabled"}`,
+				`Contemplator model:      ${runtime.config.contemplatorModel ? `${runtime.config.contemplatorModel.provider}/${runtime.config.contemplatorModel.id}` : "current session model"}`,
+				`Structural reviewer:     ${runtime.config.reviewerEnabled === false ? "disabled" : "enabled"}`,
+				`Reviewer model:          ${runtime.config.reviewerModel ? `${runtime.config.reviewerModel.provider}/${runtime.config.reviewerModel.id}` : "current session model"}`,
+			];
+
+			if (runtime.agentUsage.runs > 0) {
+				const u = runtime.agentUsage;
+				lines.push(`Token usage:            ↑${formatTokens(u.input)} ↓${formatTokens(u.output)}${u.cacheRead ? ` R${formatTokens(u.cacheRead)}` : ""}${u.cacheWrite ? ` W${formatTokens(u.cacheWrite)}` : ""} $${u.cost.toFixed(3)} (${u.runs} call${u.runs === 1 ? "" : "s"})`);
+			}
+
+			// Probe stats come from the branch ledger (like /om:view contemplator):
+			// deduped by probeId so restore re-queues don't inflate the count, and
+			// entries without a probeId (sent before probe tracking existed) count
+			// individually. Survives reloads, unlike an in-memory counter.
+			const probeSuggestions: { suggestion: string }[] = [];
+			const probeIndexByProbeId = new Map<string, number>();
+			for (const entry of entries) {
+				if (entry.customType !== CONTEMPLATOR_SUGGESTION) continue;
+				const data = (entry.data ?? {}) as { suggestion?: unknown; probeId?: unknown };
+				if (typeof data.suggestion !== "string") continue;
+				if (typeof data.probeId !== "string") {
+					probeSuggestions.push({ suggestion: data.suggestion });
+					continue;
+				}
+				const existingIndex = probeIndexByProbeId.get(data.probeId);
+				if (existingIndex === undefined) {
+					probeIndexByProbeId.set(data.probeId, probeSuggestions.length);
+					probeSuggestions.push({ suggestion: data.suggestion });
+				} else {
+					probeSuggestions[existingIndex] = { suggestion: data.suggestion };
+				}
+			}
+			if (probeSuggestions.length > 0) {
+				lines.push(`Probes sent:            ${probeSuggestions.length}`);
+				lines.push(`Last probe:             ${probeSuggestions[probeSuggestions.length - 1].suggestion}`);
+			}
+
+			const latestReview = full.reviews?.at(-1);
+			if (latestReview) {
+				lines.push(`Last review:            [${latestReview.id}] ${latestReview.scope} ${latestReview.outcome}`);
+				if (latestReview.outcome === "proposal") lines.push(`Last review summary:    ${truncateStatusText(latestReview.summary)}`);
+				else lines.push(`Last review reason:     ${truncateStatusText(latestReview.reason)}`);
+			}
+			let latestNotice: string | undefined;
+			for (const entry of entries) {
+				if (entry.customType !== REVIEWER_NOTICE || !entry.data || typeof entry.data !== "object") continue;
+				const content = (entry.data as { content?: unknown }).content;
+				if (typeof content === "string") latestNotice = content;
+			}
+			if (latestNotice) lines.push(`Last reviewer notice:  ${truncateStatusText(latestNotice)}`);
+
+			if (runtime.consolidationInFlight || runtime.compactInFlight || runtime.compactHookInFlight || runtime.reviewInFlight) {
+				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.reviewInFlight) lines.push("Structural review: 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

@@ -0,0 +1,171 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { Runtime } from "../runtime.js";
+import { copyTextToClipboard } from "../clipboard.js";
+import { renderContemplator, stripAnsi } from "./contemplator-view.js";
+import { renderReviewer } from "./reviewer-view.js";
+import { executeRecall, formatRecallResultForTui } from "../tools/recall-observation.js";
+import {
+	fullProjection,
+	observationToSummaryLine,
+	reflectionToSummaryLine,
+	visibleProjection,
+	type Entry,
+	type Projection,
+} from "../session-ledger/index.js";
+
+function argAt(args: unknown, index: number): string | undefined {
+	if (Array.isArray(args)) return typeof args[index] === "string" ? args[index] : undefined;
+	if (typeof args === "string") return args.trim().split(/\s+/)[index];
+	if (args && typeof args === "object" && "mode" in args && index === 0) {
+		const mode = (args as { mode?: unknown }).mode;
+		return typeof mode === "string" ? mode : undefined;
+	}
+	return undefined;
+}
+
+function firstArg(args: unknown): string | undefined {
+	return argAt(args, 0);
+}
+
+function renderList<T>(
+	items: T[],
+	render: (item: T) => string,
+	empty: string,
+): string {
+	return items.length > 0 ? items.map(render).join("\n") : empty;
+}
+
+function reviewSummaryLine(review: NonNullable<Projection["reviews"]>[number]): string {
+	if (review.outcome === "proposal") return `[${review.id}] ${review.scope} proposal: ${review.title} — ${review.summary}`;
+	return `[${review.id}] ${review.scope} review concluded with no proposal — ${review.reason}`;
+}
+
+function renderContentOnlyProjection(
+	projection: Projection,
+	emptyScope: "visible" | "recorded",
+): string {
+	const lines = [
+		"── Reflections ──",
+		renderList(projection.reflections, reflectionToSummaryLine, `No ${emptyScope} reflections.`),
+		"",
+		"── Observations ──",
+		renderList(projection.observations, observationToSummaryLine, `No ${emptyScope} observations.`),
+	];
+	if (projection.reviews?.length) lines.push("", "── Advisory reviews ──", ...projection.reviews.map(reviewSummaryLine));
+	return lines.join("\n");
+}
+
+function hasMemory(projection: Projection): boolean {
+	return (
+		projection.reflections.length > 0 || projection.observations.length > 0 || (projection.reviews?.length ?? 0) > 0
+	);
+}
+
+interface ViewCommandOptions {
+	copyToClipboard?: (text: string) => Promise<boolean>;
+}
+
+export function registerViewCommand(
+	pi: ExtensionAPI,
+	runtime: Runtime,
+	options: ViewCommandOptions = {},
+): void {
+	const copyToClipboard = options.copyToClipboard ?? copyTextToClipboard;
+
+	pi.registerCommand("om:view", {
+		description:
+			"Print and copy observational memory content (visible, full, memory, contemplator, reviewer, or reviews)",
+		handler: async (args, ctx) => {
+			runtime.ensureConfig(ctx.cwd);
+			const entries = ctx.sessionManager.getBranch() as Entry[];
+			const mode = firstArg(args);
+
+			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",
+				);
+			};
+
+			if (mode === "memory") {
+				const memoryId = argAt(args, 1);
+				if (!memoryId) {
+					ctx.ui.notify("Usage: /om:view memory <12-character-memory-id>", "info");
+					return;
+				}
+				const recalled = executeRecall({ id: memoryId }, () => entries);
+				const output = recalled.details?.reviews.length
+					? recalled.content.filter((part): part is { type: "text"; text: string } => part.type === "text").map((part) => part.text).join("\n")
+					: formatRecallResultForTui(recalled, false);
+				await notifyWithCopy(output);
+				return;
+			}
+
+			if (mode === "contemplator") {
+				const output = renderContemplator(entries);
+				const copied = await copyToClipboard(stripAnsi(output)).catch(() => false);
+				ctx.ui.notify(
+					`${output}\n\n${copied ? "Copied /om:view contemplator output to clipboard." : "Warning: failed to copy /om:view contemplator output to clipboard."}`,
+					"info",
+				);
+				return;
+			}
+
+			if (mode === "reviewer") {
+				const output = renderReviewer(entries);
+				const copied = await copyToClipboard(stripAnsi(output)).catch(() => false);
+				ctx.ui.notify(
+					`${output}\n\n${copied ? "Copied /om:view reviewer output to clipboard." : "Warning: failed to copy /om:view reviewer output to clipboard."}`,
+					"info",
+				);
+				return;
+			}
+
+			if (mode === "reviews") {
+				const output = renderList(
+					fullProjection(entries).reviews ?? [],
+					reviewSummaryLine,
+					"No advisory reviews recorded.",
+				);
+				await notifyWithCopy(output);
+				return;
+			}
+
+			if (mode === "full") {
+				await notifyWithCopy(
+					renderContentOnlyProjection(fullProjection(entries), "recorded"),
+				);
+				return;
+			}
+
+			if (mode && mode !== "visible") {
+				ctx.ui.notify("Usage: /om:view [visible|full|memory <id>|contemplator|reviewer|reviews]", "info");
+				return;
+			}
+
+			const visible = visibleProjection(entries);
+			if (hasMemory(visible)) {
+				await notifyWithCopy(renderContentOnlyProjection(visible, "visible"));
+				return;
+			}
+
+			if (mode === "visible") {
+				await notifyWithCopy(renderContentOnlyProjection(visible, "visible"));
+				return;
+			}
+
+			const recorded = fullProjection(entries);
+			if (hasMemory(recorded)) {
+				await notifyWithCopy(
+					`No visible memory has been folded into a compaction yet; showing recorded memory.\n\n${renderContentOnlyProjection(recorded, "recorded")}`,
+				);
+				return;
+			}
+
+			await notifyWithCopy(renderContentOnlyProjection(visible, "visible"));
+		},
+	});
+}