@aexol/spectral 0.3.6 → 0.3.8

package/dist/cli.js

@@ -79,6 +79,10 @@ function resolvePiBin() {
 function resolveAexolExtensionPath() {
     return resolve(__dirname, "extensions", "aexol-mcp.js");
 }
+/** Absolute path to the bundled observational-memory extension, sitting next to this file in dist/. */
+function resolveObservationalMemoryPath() {
+    return resolve(__dirname, "memory", "index.js");
+}
 /** Absolute path to the bundled pi-mcp-adapter extension, sitting next to this file in dist/. */
 function resolveMcpExtensionPath() {
     return resolve(__dirname, "mcp", "index.js");
@@ -207,7 +211,14 @@ async function main() {
         process.stderr.write(`spectral: bundled MCP extension not found at ${mcpExtPath}. This is a packaging bug.\n`);
         process.exit(1);
     }
-    const extFlags = ["--extension", aexolExtPath, "--extension", mcpExtPath];
+    // Bundled observational memory extension for tiered agent memory
+    // (observer → reflector → pruner pipeline with /om-status, /om-view, recall tool).
+    const obsMemPath = resolveObservationalMemoryPath();
+    if (!existsSync(obsMemPath)) {
+        process.stderr.write(`spectral: bundled observational-memory extension not found at ${obsMemPath}. This is a packaging bug.\n`);
+        process.exit(1);
+    }
+    const extFlags = ["--extension", aexolExtPath, "--extension", mcpExtPath, "--extension", obsMemPath];
     const finalArgs = [...extFlags, ...args];
     delegateToPi(finalArgs);
 }

package/dist/memory/branch.js

@@ -0,0 +1,409 @@
+import { OBSERVATION_CUSTOM_TYPE, isObservationEntryData, isReflectionRecord, isSupportedMemoryDetails, } from "./types.js";
+import { estimateEntryTokens } from "./tokens.js";
+const RAW_TYPES = new Set(["message", "custom_message", "branch_summary"]);
+export function isSourceEntry(entry) {
+    return RAW_TYPES.has(entry.type);
+}
+function isObservationEntry(entry) {
+    return entry.type === "custom" && entry.customType === OBSERVATION_CUSTOM_TYPE;
+}
+export function findLastCompactionIndex(entries) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+        if (entries[i].type === "compaction")
+            return i;
+    }
+    return -1;
+}
+export function lastObservationCoverEndIdx(entries) {
+    const idToIdx = new Map();
+    for (let i = 0; i < entries.length; i++)
+        idToIdx.set(entries[i].id, i);
+    let maxIdx = -1;
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        if (!isObservationEntry(entry))
+            continue;
+        if (!isObservationEntryData(entry.data))
+            continue;
+        const coverIdx = idToIdx.get(entry.data.coversUpToId);
+        if (coverIdx !== undefined && coverIdx > maxIdx)
+            maxIdx = coverIdx;
+    }
+    return maxIdx;
+}
+function rawTokensFromIndex(entries, startIndex) {
+    let total = 0;
+    for (let i = Math.max(0, startIndex); i < entries.length; i++) {
+        if (RAW_TYPES.has(entries[i].type))
+            total += estimateEntryTokens(entries[i]);
+    }
+    return total;
+}
+export function rawTokensSinceLastBound(entries) {
+    return rawTokensFromIndex(entries, lastObservationCoverEndIdx(entries) + 1);
+}
+export function rawTokensSinceLastCompaction(entries) {
+    const compactionIdx = findLastCompactionIndex(entries);
+    if (compactionIdx === -1)
+        return rawTokensFromIndex(entries, 0);
+    return rawTokensFromIndex(entries, liveTailStartIndex(entries));
+}
+function liveTailStartIndex(entries) {
+    const compactionIdx = findLastCompactionIndex(entries);
+    if (compactionIdx === -1)
+        return 0;
+    const firstKept = entries[compactionIdx].firstKeptEntryId;
+    if (!firstKept)
+        throw new Error("compaction entry missing firstKeptEntryId");
+    const firstKeptIdx = entries.findIndex((e) => e.id === firstKept);
+    if (firstKeptIdx === -1)
+        throw new Error(`firstKeptEntryId "${firstKept}" not found in entries`);
+    return firstKeptIdx;
+}
+export function firstRawIdAfter(entries, afterIndex) {
+    for (let i = Math.max(0, afterIndex + 1); i < entries.length; i++) {
+        if (RAW_TYPES.has(entries[i].type))
+            return entries[i].id;
+    }
+    return undefined;
+}
+export function gapRawEntries(entries, newFirstKeptEntryId) {
+    const lastBoundIdx = lastObservationCoverEndIdx(entries);
+    const newKeptIdx = entries.findIndex((e) => e.id === newFirstKeptEntryId);
+    if (newKeptIdx === -1)
+        return [];
+    const result = [];
+    for (let i = lastBoundIdx + 1; i < newKeptIdx; i++) {
+        if (RAW_TYPES.has(entries[i].type))
+            result.push(entries[i]);
+    }
+    return result;
+}
+export function rawTailEntriesBetween(entries, fromId, untilId) {
+    const fromIdx = entries.findIndex((e) => e.id === fromId);
+    const untilIdx = entries.findIndex((e) => e.id === untilId);
+    if (fromIdx === -1 || untilIdx === -1 || untilIdx < fromIdx)
+        return [];
+    const result = [];
+    for (let i = fromIdx; i <= untilIdx; i++) {
+        if (isSourceEntry(entries[i]))
+            result.push(entries[i]);
+    }
+    return result;
+}
+function uniqueIds(ids) {
+    return Array.from(new Set(ids));
+}
+function collectIndexedObservations(entries) {
+    const observations = [];
+    for (let branchIndex = 0; branchIndex < entries.length; branchIndex++) {
+        const entry = entries[branchIndex];
+        if (!isObservationEntry(entry))
+            continue;
+        if (!isObservationEntryData(entry.data))
+            continue;
+        entry.data.records.forEach((observation, observationRecordIndex) => {
+            observations.push({ observation, observationEntryId: entry.id, observationRecordIndex, branchIndex });
+        });
+    }
+    return observations;
+}
+function observationKey(observation) {
+    return `${observation.observationEntryId}:${observation.observationRecordIndex}`;
+}
+function resolveSourceEntries(entries, sourceEntryIds) {
+    const requested = uniqueIds(sourceEntryIds);
+    const requestedSet = new Set(requested);
+    const entriesById = new Map(entries.map((entry) => [entry.id, entry]));
+    const missingSourceEntryIds = requested.filter((id) => !entriesById.has(id));
+    const nonSourceEntryIds = requested.filter((id) => {
+        const entry = entriesById.get(id);
+        return entry !== undefined && !isSourceEntry(entry);
+    });
+    if (missingSourceEntryIds.length > 0 || nonSourceEntryIds.length > 0) {
+        return {
+            status: "source_unavailable",
+            sourceEntryIds: requested,
+            sourceEntries: [],
+            missingSourceEntryIds,
+            nonSourceEntryIds,
+        };
+    }
+    const sourceEntries = entries.filter((entry) => requestedSet.has(entry.id));
+    return {
+        status: "ok",
+        sourceEntryIds: sourceEntries.map((entry) => entry.id),
+        sourceEntries,
+        missingSourceEntryIds: [],
+        nonSourceEntryIds: [],
+    };
+}
+function resolveSourceEntriesPartial(entries, sourceEntryIds) {
+    const requested = uniqueIds(sourceEntryIds);
+    const requestedSet = new Set(requested);
+    const entriesById = new Map(entries.map((entry) => [entry.id, entry]));
+    const missingSourceEntryIds = requested.filter((id) => !entriesById.has(id));
+    const nonSourceEntryIds = requested.filter((id) => {
+        const entry = entriesById.get(id);
+        return entry !== undefined && !isSourceEntry(entry);
+    });
+    const sourceEntries = entries.filter((entry) => requestedSet.has(entry.id) && isSourceEntry(entry));
+    return {
+        status: missingSourceEntryIds.length > 0 || nonSourceEntryIds.length > 0 ? "source_unavailable" : "ok",
+        sourceEntryIds: requested,
+        sourceEntries,
+        missingSourceEntryIds,
+        nonSourceEntryIds,
+    };
+}
+function memoryObservationFromIndexed(entries, indexed) {
+    const { observation, observationEntryId, observationRecordIndex } = indexed;
+    if (!observation.sourceEntryIds || observation.sourceEntryIds.length === 0) {
+        return { status: "no_source", observation, observationEntryId, observationRecordIndex };
+    }
+    const resolved = resolveSourceEntriesPartial(entries, observation.sourceEntryIds);
+    if (resolved.status === "source_unavailable") {
+        return {
+            status: "source_unavailable",
+            observation,
+            observationEntryId,
+            observationRecordIndex,
+            sourceEntryIds: resolved.sourceEntryIds,
+            sourceEntries: resolved.sourceEntries,
+            missingSourceEntryIds: resolved.missingSourceEntryIds,
+            nonSourceEntryIds: resolved.nonSourceEntryIds,
+        };
+    }
+    return {
+        status: "ok",
+        observation,
+        observationEntryId,
+        observationRecordIndex,
+        sourceEntryIds: resolved.sourceEntryIds,
+        sourceEntries: resolved.sourceEntries,
+    };
+}
+function uniqueSourceEntriesInBranchOrder(entries, observations) {
+    const requested = new Set();
+    for (const observation of observations) {
+        if (observation.status === "ok" || observation.status === "source_unavailable") {
+            for (const entry of observation.sourceEntries)
+                requested.add(entry.id);
+        }
+    }
+    return entries.filter((entry) => requested.has(entry.id) && isSourceEntry(entry));
+}
+function uniqueUnavailableSourceIds(observations, field) {
+    const ids = [];
+    for (const observation of observations) {
+        if (observation.status !== "source_unavailable")
+            continue;
+        ids.push(...observation[field]);
+    }
+    return uniqueIds(ids);
+}
+export function recallObservationSources(entries, observationId) {
+    const matches = [];
+    for (const entry of entries) {
+        if (!isObservationEntry(entry))
+            continue;
+        if (!isObservationEntryData(entry.data))
+            continue;
+        for (const observation of entry.data.records) {
+            if (observation.id !== observationId)
+                continue;
+            if (!observation.sourceEntryIds || observation.sourceEntryIds.length === 0) {
+                matches.push({ status: "no_source", observation, observationEntryId: entry.id });
+                continue;
+            }
+            const resolved = resolveSourceEntries(entries, observation.sourceEntryIds);
+            if (resolved.status === "source_unavailable") {
+                matches.push({
+                    status: "source_unavailable",
+                    observation,
+                    observationEntryId: entry.id,
+                    sourceEntryIds: resolved.sourceEntryIds,
+                    missingSourceEntryIds: resolved.missingSourceEntryIds,
+                    nonSourceEntryIds: resolved.nonSourceEntryIds,
+                });
+                continue;
+            }
+            matches.push({
+                status: "ok",
+                observation,
+                observationEntryId: entry.id,
+                sourceEntryIds: resolved.sourceEntryIds,
+                sourceEntries: resolved.sourceEntries,
+            });
+        }
+    }
+    if (matches.length === 0)
+        return { status: "not_found", observationId, matches: [], collision: false };
+    return { status: "found", observationId, matches, collision: matches.length > 1 };
+}
+function getPriorMemoryDetails(entries) {
+    const idx = findLastCompactionIndex(entries);
+    if (idx === -1)
+        return undefined;
+    const details = entries[idx].details;
+    return isSupportedMemoryDetails(details) ? details : undefined;
+}
+export function recallMemorySources(entries, memoryId) {
+    const indexedObservations = collectIndexedObservations(entries);
+    const observationsById = new Map();
+    for (const observation of indexedObservations) {
+        const matches = observationsById.get(observation.observation.id) ?? [];
+        matches.push(observation);
+        observationsById.set(observation.observation.id, matches);
+    }
+    const priorDetails = getPriorMemoryDetails(entries);
+    const reflectionMatches = [];
+    if (priorDetails) {
+        priorDetails.reflections.forEach((reflection, reflectionIndex) => {
+            if (!isReflectionRecord(reflection) || reflection.id !== memoryId)
+                return;
+            reflectionMatches.push({ reflection, reflectionIndex });
+        });
+    }
+    const directIndexedObservations = observationsById.get(memoryId) ?? [];
+    const observationsByKey = new Map();
+    for (const observation of directIndexedObservations) {
+        observationsByKey.set(observationKey(observation), observation);
+    }
+    const unavailableSupportingObservations = [];
+    const unavailableReflectionProvenance = [];
+    for (const reflectionMatch of reflectionMatches) {
+        if (reflectionMatch.reflection.legacy === true) {
+            unavailableReflectionProvenance.push({ ...reflectionMatch, reason: "legacy" });
+            continue;
+        }
+        for (const observationId of reflectionMatch.reflection.supportingObservationIds) {
+            const supportingObservations = observationsById.get(observationId);
+            if (!supportingObservations || supportingObservations.length === 0) {
+                unavailableSupportingObservations.push({ ...reflectionMatch, observationId });
+                continue;
+            }
+            for (const observation of supportingObservations) {
+                observationsByKey.set(observationKey(observation), observation);
+            }
+        }
+    }
+    const indexedObservationBag = Array.from(observationsByKey.values()).sort((a, b) => {
+        if (a.branchIndex !== b.branchIndex)
+            return a.branchIndex - b.branchIndex;
+        return a.observationRecordIndex - b.observationRecordIndex;
+    });
+    const observations = indexedObservationBag.map((observation) => memoryObservationFromIndexed(entries, observation));
+    const directObservationKeys = new Set(directIndexedObservations.map(observationKey));
+    const directObservationMatches = observations.filter((observation) => directObservationKeys.has(observationKey(observation)));
+    const sourceEntries = uniqueSourceEntriesInBranchOrder(entries, observations);
+    const missingSourceEntryIds = uniqueUnavailableSourceIds(observations, "missingSourceEntryIds");
+    const nonSourceEntryIds = uniqueUnavailableSourceIds(observations, "nonSourceEntryIds");
+    if (reflectionMatches.length === 0 && directObservationMatches.length === 0) {
+        return {
+            status: "not_found",
+            memoryId,
+            reflectionMatches: [],
+            directObservationMatches: [],
+            observations: [],
+            sourceEntries: [],
+            unavailableSupportingObservations: [],
+            unavailableReflectionProvenance: [],
+            missingSourceEntryIds: [],
+            nonSourceEntryIds: [],
+            collision: false,
+            partial: false,
+        };
+    }
+    const hasNoSourceObservationInMemoryRecall = reflectionMatches.length > 0 && observations.some((observation) => observation.status === "no_source");
+    return {
+        status: "found",
+        memoryId,
+        reflectionMatches,
+        directObservationMatches,
+        observations,
+        sourceEntries,
+        unavailableSupportingObservations,
+        unavailableReflectionProvenance,
+        missingSourceEntryIds,
+        nonSourceEntryIds,
+        collision: reflectionMatches.length + directObservationMatches.length > 1,
+        partial: unavailableReflectionProvenance.length > 0 ||
+            hasNoSourceObservationInMemoryRecall ||
+            unavailableSupportingObservations.length > 0 ||
+            missingSourceEntryIds.length > 0 ||
+            nonSourceEntryIds.length > 0,
+    };
+}
+export function collectObservationsByCoverage(entries, priorFirstKeptEntryId, newFirstKeptEntryId) {
+    const idToIdx = new Map();
+    for (let i = 0; i < entries.length; i++)
+        idToIdx.set(entries[i].id, i);
+    const newFKIIdx = idToIdx.get(newFirstKeptEntryId);
+    if (newFKIIdx === undefined)
+        return [];
+    let priorFKIIdx;
+    if (priorFirstKeptEntryId === undefined) {
+        priorFKIIdx = -1;
+    }
+    else {
+        const idx = idToIdx.get(priorFirstKeptEntryId);
+        if (idx === undefined)
+            throw new Error(`priorFirstKeptEntryId "${priorFirstKeptEntryId}" not found in entries`);
+        priorFKIIdx = idx;
+    }
+    const result = [];
+    for (const entry of entries) {
+        if (!isObservationEntry(entry))
+            continue;
+        if (!isObservationEntryData(entry.data))
+            continue;
+        const fromIdx = idToIdx.get(entry.data.coversFromId);
+        if (fromIdx === undefined)
+            continue;
+        if (fromIdx >= priorFKIIdx && fromIdx < newFKIIdx)
+            result.push(entry.data);
+    }
+    return result;
+}
+function collectObservationsPendingNextCompaction(entries) {
+    const idToIdx = new Map();
+    for (let i = 0; i < entries.length; i++)
+        idToIdx.set(entries[i].id, i);
+    const priorCompactionIdx = findLastCompactionIndex(entries);
+    let thresholdIdx;
+    if (priorCompactionIdx === -1) {
+        thresholdIdx = -1;
+    }
+    else {
+        const priorFirstKept = entries[priorCompactionIdx].firstKeptEntryId;
+        if (!priorFirstKept)
+            throw new Error("prior compaction entry missing firstKeptEntryId");
+        const idx = idToIdx.get(priorFirstKept);
+        if (idx === undefined)
+            throw new Error(`prior firstKeptEntryId "${priorFirstKept}" not found in entries`);
+        thresholdIdx = idx;
+    }
+    const result = [];
+    for (const entry of entries) {
+        if (!isObservationEntry(entry))
+            continue;
+        if (!isObservationEntryData(entry.data))
+            continue;
+        const fromIdx = idToIdx.get(entry.data.coversFromId);
+        if (fromIdx === undefined)
+            continue;
+        if (fromIdx >= thresholdIdx)
+            result.push(entry.data);
+    }
+    return result;
+}
+export function getMemoryState(entries) {
+    const priorDetails = getPriorMemoryDetails(entries);
+    const pendingData = collectObservationsPendingNextCompaction(entries);
+    return {
+        reflections: priorDetails?.reflections ?? [],
+        committedObs: priorDetails?.observations ?? [],
+        pendingObs: pendingData.flatMap((d) => d.records),
+    };
+}

package/dist/memory/commands/status.js

@@ -0,0 +1,91 @@
+import { SettingsManager } from "@mariozechner/pi-coding-agent";
+import { getMemoryState, rawTokensSinceLastBound, rawTokensSinceLastCompaction, } from "../branch.js";
+import { observationPoolTokens as estimateObservationPoolTokens } from "../compaction.js";
+import { countByRelevance, formatRelevanceHistogram } from "../relevance.js";
+import { estimateStringTokens } from "../tokens.js";
+import { reflectionContent } from "../types.js";
+export function registerStatusCommand(pi, runtime) {
+    pi.registerCommand("om-status", {
+        description: "Show observational memory status",
+        handler: async (_args, ctx) => {
+            runtime.ensureConfig(ctx.cwd);
+            const entries = ctx.sessionManager.getBranch();
+            const sinceBound = rawTokensSinceLastBound(entries);
+            const sinceCompaction = rawTokensSinceLastCompaction(entries);
+            const { reflections: committedRefs, committedObs, pendingObs } = getMemoryState(entries);
+            const committedRefItems = committedRefs;
+            const committedObsTokens = estimateObservationPoolTokens(committedObs);
+            const committedObsCount = committedObs.length;
+            const committedRefsTokens = committedRefItems.reduce((s, r) => s + estimateStringTokens(reflectionContent(r)), 0);
+            const committedRefsCount = committedRefItems.length;
+            const pendingObsTokens = estimateObservationPoolTokens(pendingObs);
+            const pendingObsCount = pendingObs.length;
+            const relevanceHistogram = countByRelevance([...committedObs, ...pendingObs]);
+            const keepRecentTokens = SettingsManager.create(ctx.cwd).getCompactionKeepRecentTokens();
+            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));
+            const refLabel = committedRefsCount === 1 ? "entry" : "entries";
+            const cObsLabel = committedObsCount === 1 ? "observation" : "observations";
+            const pObsLabel = pendingObsCount === 1 ? "observation" : "observations";
+            const passiveLines = runtime.config.passive === true
+                ? [
+                    "── Mode ──",
+                    "Passive: proactive observation and compaction triggers disabled; compaction hook remains 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)}`,
+                "",
+                ...activityLines,
+            ];
+            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");
+            }
+            ctx.ui.notify(lines.join("\n"), "info");
+        },
+    });
+}

package/dist/memory/commands/view.js

@@ -0,0 +1,61 @@
+import { getMemoryState } from "../branch.js";
+import { observationPoolTokens as estimateObservationPoolTokens } from "../compaction.js";
+import { countByRelevance, formatRelevanceHistogram } from "../relevance.js";
+import { estimateStringTokens } from "../tokens.js";
+import { reflectionContent, reflectionToPromptLine } from "../types.js";
+export function registerViewCommand(pi, runtime) {
+    pi.registerCommand("om-view", {
+        description: "Print observational memory details (reflections + observations)",
+        handler: async (_args, ctx) => {
+            runtime.ensureConfig(ctx.cwd);
+            const entries = ctx.sessionManager.getBranch();
+            const { reflections: committedRefs, committedObs, pendingObs } = getMemoryState(entries);
+            const committedRefItems = committedRefs;
+            const committedRefTokens = committedRefItems.reduce((s, r) => s + estimateStringTokens(reflectionContent(r)), 0);
+            const committedRefCount = committedRefItems.length;
+            const committedObsTokens = estimateObservationPoolTokens(committedObs);
+            const committedObsCount = committedObs.length;
+            const pendingObsTokens = estimateObservationPoolTokens(pendingObs);
+            const pendingObsCount = pendingObs.length;
+            const totalObsCount = committedObsCount + pendingObsCount;
+            const totalObsTokens = estimateObservationPoolTokens([...committedObs, ...pendingObs]);
+            const totalTokens = committedRefTokens + totalObsTokens;
+            const relevanceHistogram = countByRelevance([...committedObs, ...pendingObs]);
+            const plural = (n, singular, plural) => (n === 1 ? singular : plural);
+            const renderObs = (r) => `[${r.id}] ${r.timestamp} [${r.relevance}] ${r.content}`;
+            const sections = [];
+            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("");
+            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)");
+            }
+            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)");
+            }
+            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)");
+            }
+            sections.push("");
+            sections.push("Tip: use /tree to browse the raw messages still live in the session.");
+            ctx.ui.notify(sections.join("\n"), "info");
+        },
+    });
+}