@aexol/spectral 0.9.16 → 0.9.19

package/dist/memory/hooks/compaction-hook.js

@@ -3,11 +3,12 @@ import { resolveTurnLimits } from "../config.js";
 import { getProjectObsStore } from "../project-observations-store.js";
 import { relayProjectObservations } from "../inter-agent-relay.js";
 import { collectObservationsByCoverage, findLastCompactionIndex, gapRawEntries, getMemoryState, } from "../branch.js";
-import { coverageTagCounts, migrateLegacyReflections, observationPoolTokens, renderSummary, runPruner, runReflector, } from "../compaction.js";
-import { observationsToPromptLines, runObserver } from "../observer.js";
+import { coverageTagCounts, migrateLegacyReflections, observationPoolTokens, renderSummary, runReflector, } from "../compaction.js";
 import { serializeSourceAddressedBranchEntries } from "../serialize.js";
 import { estimateStringTokens } from "../tokens.js";
-import { OBSERVATION_CUSTOM_TYPE, reflectionToPromptLine, } from "../types.js";
+import { OBSERVATION_CUSTOM_TYPE, } from "../types.js";
+import { deterministicPrune } from "../deterministic-pruner.js";
+import { generateUnifiedCompaction } from "../unified-compaction.js";
 function plural(count, singular, pluralForm = `${singular}s`) {
     return `${count.toLocaleString()} ${count === 1 ? singular : pluralForm}`;
 }
@@ -18,9 +19,6 @@ function formatReflectorStats(stats) {
     const failed = stats.failedPass === undefined ? "" : `, failed pass ${stats.failedPass}`;
     return `reflector ${plural(stats.toolCalls, "tool call")}, +${stats.added.toLocaleString()} added, ${stats.merged.toLocaleString()} merged, ${stats.promoted.toLocaleString()} promoted, ${stats.duplicates.toLocaleString()} duplicate/no-op, ${stats.unsupported.toLocaleString()} unsupported${failed}`;
 }
-function formatPrunerStats(result) {
-    return `pruner dropped ${plural(result.droppedIds.length, "observation")} in ${plural(result.passes.length, "pass", "passes")}, stop: ${result.stopReason}`;
-}
 function emitProgressLine(emitProgress, line) {
     emitProgress?.(`${line}\n`);
 }
@@ -61,8 +59,6 @@ function emitAgentLoopProgress(emitProgress, phase, event) {
 export function registerCompactionHook(ext, runtime) {
     ext.on("session_before_compact", async (event, ctx) => {
         if (runtime.compactHookInFlight) {
-            // Expected race: another compaction process reached the hook first.
-            // Let the in-flight compaction continue; this is not a user-facing error.
             debugLog("compaction.skip_duplicate", { reason: "hook already in flight" });
             return { cancel: true };
         }
@@ -72,11 +68,9 @@ export function registerCompactionHook(ext, runtime) {
             const runId = `compaction-${Date.now().toString(36)}-${Math.random().toString(16).slice(2, 8)}`;
             return await withDebugLogContext({ enabled: runtime.config.debugLog === true, cwd: ctx.cwd, runId }, async () => {
                 const { preparation, branchEntries, signal } = event;
-                const { firstKeptEntryId, tokensBefore } = preparation;
+                const { firstKeptEntryId, tokensBefore, messagesToSummarize, settings: compactSettings } = preparation;
                 const emitProgress = event.emitProgress;
                 emitProgressLine(emitProgress, `Observational memory compaction started on ~${tokensBefore.toLocaleString()} tokens.`);
-                // Capture ctx properties synchronously — after multiple awaits below,
-                // the extension ctx may become stale (e.g. after session replacement/reload).
                 const hasUI = ctx.hasUI;
                 const ui = ctx.ui;
                 const turnLimits = resolveTurnLimits(runtime.config);
@@ -86,7 +80,7 @@ export function registerCompactionHook(ext, runtime) {
                     branchEntryCount: branchEntries.length,
                     reflectionThresholdTokens: runtime.config.reflectionThresholdTokens,
                     turnLimits,
-                    legacyCompactionMaxToolCalls: runtime.config.compactionMaxToolCalls,
+                    messagesToSummarize: messagesToSummarize?.length ?? 0,
                 });
                 emitProgressLine(emitProgress, "Resolving memory model…");
                 const resolved = await runtime.resolveModel(ctx);
@@ -105,9 +99,7 @@ export function registerCompactionHook(ext, runtime) {
                     try {
                         await runtime.observerPromise;
                     }
-                    catch { /* already notified via launchObserverTask */ }
-                    // In-flight observer may have appended a new observation entry during the await;
-                    // refresh from sessionManager so gap computation and coverage collection see it
+                    catch { /* already notified */ }
                     entries = ctx.sessionManager.getBranch();
                 }
                 const memoryState = getMemoryState(entries);
@@ -117,88 +109,84 @@ export function registerCompactionHook(ext, runtime) {
                     reflections: memoryState.reflections.length,
                 });
                 emitProgressLine(emitProgress, `Loaded memory state: ${memoryState.committedObs.length} committed observations, ${memoryState.pendingObs.length} pending observations, ${memoryState.reflections.length} reflections.`);
+                // ================================================================
+                // UNIFIED COMPACTION: replaces core generateSummary() + sync
+                // catch-up observer with a single LLM call.
+                // ================================================================
                 let gapObservationData = null;
+                let unifiedNarrativeSummary;
+                let unifiedObservations = [];
                 const gap = gapRawEntries(entries, firstKeptEntryId);
-                if (gap.length > 0) {
-                    const { text: gapChunk, sourceEntryIds } = serializeSourceAddressedBranchEntries(gap);
-                    if (gapChunk.trim() && sourceEntryIds.length > 0) {
+                const gapChunk = gap.length > 0
+                    ? serializeSourceAddressedBranchEntries(gap)
+                    : { text: "", sourceEntryIds: [] };
+                const hasGapContent = gapChunk.text.trim() && gapChunk.sourceEntryIds.length > 0;
+                // Always run unified compaction — it replaces both the core narrative
+                // summary and, when gap exists, the sync catch-up observer.
+                emitProgressLine(emitProgress, "Running unified compaction (narrative + observations)…");
+                debugLog("compaction.unified.start", {
+                    messagesToSummarize: messagesToSummarize.length,
+                    hasGapContent,
+                    gapEntryCount: gap.length,
+                });
+                try {
+                    const unifiedResult = await generateUnifiedCompaction({
+                        messagesToSummarize,
+                        gapChunk: hasGapContent ? gapChunk.text : undefined,
+                        gapSourceEntryIds: hasGapContent ? gapChunk.sourceEntryIds : undefined,
+                        model: resolved.model,
+                        apiKey: resolved.apiKey,
+                        headers: resolved.headers,
+                        signal,
+                        previousSummary: preparation.previousSummary,
+                        customInstructions: event.customInstructions,
+                        thinkingLevel: undefined, // Use model default
+                        reserveTokens: compactSettings.reserveTokens,
+                    });
+                    unifiedNarrativeSummary = unifiedResult.narrativeSummary;
+                    unifiedObservations = unifiedResult.observations;
+                    // If gap entries produced observations, record them as an
+                    // observation entry so recall can resolve source provenance.
+                    if (hasGapContent && unifiedObservations.length > 0) {
                         const gapFromId = gap[0].id;
                         const gapUpToId = gap[gap.length - 1].id;
-                        const priorObservationLines = observationsToPromptLines([
-                            ...memoryState.committedObs,
-                            ...memoryState.pendingObs,
-                        ]);
-                        const gapTokenEstimate = estimateStringTokens(gapChunk);
-                        debugLog("compaction.sync_catchup.start", {
-                            gapEntryCount: gap.length,
-                            sourceEntryIds,
-                            gapFromId,
-                            gapUpToId,
-                            tokenEstimate: gapTokenEstimate,
-                        });
-                        if (hasUI)
-                            ui?.notify(`Observational memory: sync catch-up observer running on ~${gapTokenEstimate.toLocaleString()}-token gap`, "info");
-                        runtime.observerInFlight = true;
-                        const gapCall = runObserver({
-                            model: resolved.model,
-                            apiKey: resolved.apiKey,
-                            headers: resolved.headers,
-                            priorReflections: memoryState.reflections.map(reflectionToPromptLine),
-                            priorObservations: priorObservationLines,
-                            chunk: gapChunk,
-                            allowedSourceEntryIds: sourceEntryIds,
-                            signal,
-                            onEvent: (agentEvent) => emitAgentLoopProgress(emitProgress, "observer", agentEvent),
-                            maxTurns: turnLimits.observerMaxTurnsPerRun,
-                        });
-                        const gapPromise = gapCall.then(() => undefined, () => undefined);
-                        runtime.observerPromise = gapPromise;
-                        try {
-                            const records = await gapCall;
-                            if (records && records.length > 0) {
-                                const observationTokens = records.reduce((sum, r) => sum + estimateStringTokens(r.content), 0);
-                                gapObservationData = {
-                                    records,
-                                    coversFromId: gapFromId,
-                                    coversUpToId: gapUpToId,
-                                    tokenCount: observationTokens,
-                                };
-                                debugLog("compaction.sync_catchup.records", {
-                                    count: records.length,
-                                    observationTokens,
-                                    coversFromId: gapFromId,
-                                    coversUpToId: gapUpToId,
-                                    records,
-                                });
-                                ext.appendEntry(OBSERVATION_CUSTOM_TYPE, gapObservationData);
-                                emitProgressLine(emitProgress, `Sync catch-up recorded ${records.length} observation${records.length === 1 ? "" : "s"} (~${observationTokens.toLocaleString()} tokens).`);
-                                if (hasUI && ui)
-                                    ui.notify(`Observational memory: sync catch-up recorded ${records.length} observation${records.length === 1 ? "" : "s"} (~${observationTokens.toLocaleString()} tokens)`, "info");
-                            }
-                            else if (hasUI && ui) {
-                                debugLog("compaction.sync_catchup.empty", { gapEntryCount: gap.length });
-                                ui.notify("Observational memory: sync catch-up observer returned empty — proceeding with compaction", "warning");
-                            }
-                        }
-                        catch (error) {
-                            const msg = error instanceof Error ? error.message : String(error);
-                            debugLog("compaction.sync_catchup.error", { gapEntryCount: gap.length, errorMessage: msg });
-                            if (hasUI && ui)
-                                ui.notify(`Observational memory: sync catch-up observer failed: ${msg}. Cancelling compaction — ${gap.length} unobserved raw entries would be pruned without coverage. Try /compact again.`, "warning");
-                            return { cancel: true };
-                        }
-                        finally {
-                            runtime.observerInFlight = false;
-                            if (runtime.observerPromise === gapPromise)
-                                runtime.observerPromise = null;
-                        }
+                        const observationTokens = unifiedObservations.reduce((sum, r) => sum + estimateStringTokens(r.content), 0);
+                        gapObservationData = {
+                            records: unifiedObservations,
+                            coversFromId: gapFromId,
+                            coversUpToId: gapUpToId,
+                            tokenCount: observationTokens,
+                        };
+                        ext.appendEntry(OBSERVATION_CUSTOM_TYPE, gapObservationData);
+                        emitProgressLine(emitProgress, `Unified compaction recorded ${unifiedObservations.length} observation${unifiedObservations.length === 1 ? "" : "s"} from gap (~${observationTokens.toLocaleString()} tokens).`);
                     }
+                    debugLog("compaction.unified.result", {
+                        narrativeLength: unifiedNarrativeSummary?.length ?? 0,
+                        observationCount: unifiedObservations.length,
+                    });
+                    if (hasUI && ui) {
+                        ui.notify(`Observational memory: unified compaction produced ${unifiedObservations.length} observation${unifiedObservations.length === 1 ? "" : "s"} + narrative summary`, "info");
+                    }
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    debugLog("compaction.unified.error", { errorMessage: msg });
+                    if (hasUI && ui)
+                        ui.notify(`Observational memory: unified compaction failed: ${msg}. Cancelling compaction.`, "warning");
+                    return { cancel: true };
                 }
+                // ================================================================
+                // DELTA OBSERVATIONS: collect observer-trigger observations that
+                // fall within this compaction window (from prior FKI to new FKI).
+                // ================================================================
                 const priorCompactionIdx = findLastCompactionIndex(entries);
                 const priorFirstKeptEntryId = priorCompactionIdx >= 0 ? entries[priorCompactionIdx].firstKeptEntryId : undefined;
                 const deltaObservationData = collectObservationsByCoverage(entries, priorFirstKeptEntryId, firstKeptEntryId);
-                if (gapObservationData)
-                    deltaObservationData.push(gapObservationData);
+                // Gap observations were already appended via ext.appendEntry above,
+                // so collectObservationsByCoverage will pick them up. But to avoid
+                // double-counting (the unified observations are also in our local set),
+                // we build the working set from committed + delta, then merge unified
+                // observations (deduplicated by content hash).
                 const deltaObservationRecords = deltaObservationData.reduce((sum, data) => sum + data.records.length, 0);
                 debugLog("compaction.delta", {
                     priorFirstKeptEntryId,
@@ -208,10 +196,10 @@ export function registerCompactionHook(ext, runtime) {
                     gapObservationRecords: gapObservationData?.records.length ?? 0,
                 });
                 emitProgressLine(emitProgress, `Compaction delta contains ${deltaObservationRecords} observation${deltaObservationRecords === 1 ? "" : "s"}.`);
-                if (deltaObservationData.length === 0) {
-                    // No new observations since last compaction. If we have existing memory,
-                    // carry it forward in a no-op compaction so it survives spectral's compaction.
-                    // If there is truly nothing (no prior memory either), cancel.
+                // ================================================================
+                // NO-DELTA CASE: carry forward existing memory.
+                // ================================================================
+                if (deltaObservationData.length === 0 && unifiedObservations.length === 0) {
                     if (memoryState.committedObs.length === 0 && memoryState.reflections.length === 0) {
                         debugLog("compaction.no_delta_cancel", {
                             committedObservations: memoryState.committedObs.length,
@@ -223,7 +211,6 @@ export function registerCompactionHook(ext, runtime) {
                         }
                         return { cancel: true };
                     }
-                    // Carry forward existing memory without running reflector/pruner
                     emitProgressLine(emitProgress, "No new observations; carrying forward existing memory.");
                     const workingReflections = migrateLegacyReflections(memoryState.reflections);
                     debugLog("compaction.no_delta_carry_forward", {
@@ -239,7 +226,6 @@ export function registerCompactionHook(ext, runtime) {
                     };
                     if (hasUI)
                         ui?.notify(`Observational memory: no new observations — carrying forward ${memoryState.committedObs.length} observation${memoryState.committedObs.length === 1 ? "" : "s"}, ${workingReflections.length} reflection${workingReflections.length === 1 ? "" : "s"}`, "info");
-                    // Promote reflections as project observations (cross-session durable memory).
                     persistProjectObservations(ctx, workingReflections);
                     return {
                         compaction: {
@@ -250,32 +236,61 @@ export function registerCompactionHook(ext, runtime) {
                         },
                     };
                 }
+                // ================================================================
+                // BUILD WORKING SET: committed + delta (from observer triggers) +
+                // unified observations (from this compaction).
+                // Deduplicate by content hash.
+                // ================================================================
+                const seenObsIds = new Set();
+                const workingObservations = [];
+                // Add committed observations first (most stable)
+                for (const obs of memoryState.committedObs) {
+                    if (!seenObsIds.has(obs.id)) {
+                        seenObsIds.add(obs.id);
+                        workingObservations.push(obs);
+                    }
+                }
+                // Add delta observations (from observer triggers between compactions)
+                for (const data of deltaObservationData) {
+                    for (const obs of data.records) {
+                        if (!seenObsIds.has(obs.id)) {
+                            seenObsIds.add(obs.id);
+                            workingObservations.push(obs);
+                        }
+                    }
+                }
+                // Add unified observations (from this compaction's LLM call)
+                for (const obs of unifiedObservations) {
+                    if (!seenObsIds.has(obs.id)) {
+                        seenObsIds.add(obs.id);
+                        workingObservations.push(obs);
+                    }
+                }
                 const workingReflections = migrateLegacyReflections(memoryState.reflections);
-                const workingObservations = [
-                    ...memoryState.committedObs,
-                    ...deltaObservationData.flatMap((d) => d.records),
-                ];
                 const observationTokens = observationPoolTokens(workingObservations);
                 emitProgressLine(emitProgress, `Working set: ${workingObservations.length} observations, ${workingReflections.length} reflections, ~${observationTokens.toLocaleString()} observation tokens.`);
-                debugLog("compaction.reflect_prune.gate", {
+                debugLog("compaction.working_set", {
+                    observations: workingObservations.length,
+                    reflections: workingReflections.length,
                     observationTokens,
-                    reflectionThresholdTokens: runtime.config.reflectionThresholdTokens,
-                    willRun: observationTokens >= runtime.config.reflectionThresholdTokens,
-                    workingObservations: workingObservations.length,
-                    workingReflections: workingReflections.length,
                 });
+                // ================================================================
+                // REFLECTOR (1 pass): crystallize durable reflections from
+                // the observation pool. Preserves quality-critical iteration
+                // via agentLoop with record_reflections tool.
+                // ================================================================
                 let finalReflections = workingReflections;
                 let finalObservations = workingObservations;
                 if (observationTokens >= runtime.config.reflectionThresholdTokens) {
                     try {
-                        debugLog("compaction.reflect_prune.start", {
+                        debugLog("compaction.reflect.start", {
                             workingObservations: workingObservations.length,
                             workingReflections: workingReflections.length,
                             observationTokens,
                         });
                         if (hasUI)
-                            ui?.notify("Observational memory: running reflector + pruner...", "info");
-                        emitProgressLine(emitProgress, "Running reflector + pruner…");
+                            ui?.notify("Observational memory: running reflector (1 pass)...", "info");
+                        emitProgressLine(emitProgress, "Running reflector (1 pass)…");
                         const coverageBefore = coverageTagCounts(workingReflections, workingObservations);
                         const reflectorResult = await runReflector({
                             model: resolved.model,
@@ -294,39 +309,49 @@ export function registerCompactionHook(ext, runtime) {
                             beforeReflections: workingReflections.length,
                             afterReflections: finalReflections.length,
                         });
-                        const prunerResult = await runPruner({
-                            model: resolved.model,
-                            apiKey: resolved.apiKey,
-                            headers: resolved.headers,
-                            signal,
-                            onEvent: (agentEvent) => emitAgentLoopProgress(emitProgress, "pruner", agentEvent),
-                            maxTurns: turnLimits.prunerMaxTurnsPerPass,
-                        }, finalReflections, workingObservations, runtime.config.reflectionThresholdTokens, (pass, maxPasses) => emitProgressLine(emitProgress, `Pruner pass ${pass}/${maxPasses} started.`));
-                        finalObservations = prunerResult.observations;
-                        debugLog("compaction.pruner.result", {
-                            stopReason: prunerResult.stopReason,
-                            fellBack: prunerResult.fellBack,
-                            droppedIds: prunerResult.droppedIds,
-                            passes: prunerResult.passes,
-                            beforeObservations: workingObservations.length,
-                            afterObservations: finalObservations.length,
-                        });
                         if (hasUI) {
-                            ui?.notify(`Observational memory: diagnostics — ${formatReflectorStats(reflectorResult.stats)}; coverage ${formatCoverageCounts(coverageBefore)} → ${formatCoverageCounts(coverageAfter)}; ${formatPrunerStats(prunerResult)}`, "info");
-                        }
-                        if (prunerResult.fellBack && hasUI) {
-                            ui?.notify("Observational memory: pruner run failed; kept observation set unchanged", "warning");
+                            ui?.notify(`Observational memory: reflector — ${formatReflectorStats(reflectorResult.stats)}; coverage ${formatCoverageCounts(coverageBefore)} → ${formatCoverageCounts(coverageAfter)}`, "info");
                         }
                     }
                     catch (error) {
                         const msg = error instanceof Error ? error.message : String(error);
-                        debugLog("compaction.reflect_prune.error", { errorMessage: msg });
+                        debugLog("compaction.reflector.error", { errorMessage: msg });
                         if (hasUI)
-                            ui?.notify(`Observational memory: reflect/prune failed: ${msg}`, "warning");
+                            ui?.notify(`Observational memory: reflector failed: ${msg}`, "warning");
                     }
                 }
+                // ================================================================
+                // DETERMINISTIC PRUNER: sort-based dropping instead of LLM agent.
+                // Same logic as the LLM pruner (coverage → relevance → age)
+                // but zero-cost and deterministic.
+                // ================================================================
+                const prunerResult = deterministicPrune(finalObservations, finalReflections, runtime.config.reflectionThresholdTokens);
+                finalObservations = prunerResult.observations;
+                debugLog("compaction.pruner.result", {
+                    fellBack: prunerResult.fellBack,
+                    droppedIds: prunerResult.droppedIds,
+                    tokensBefore: prunerResult.tokensBefore,
+                    tokensAfter: prunerResult.tokensAfter,
+                    beforeObservations: workingObservations.length,
+                    afterObservations: finalObservations.length,
+                });
+                emitProgressLine(emitProgress, `Deterministic pruner dropped ${prunerResult.droppedIds.length} observation${prunerResult.droppedIds.length === 1 ? "" : "s"} (~${prunerResult.tokensBefore.toLocaleString()} → ~${prunerResult.tokensAfter.toLocaleString()} tokens).`);
+                if (prunerResult.fellBack && hasUI) {
+                    ui?.notify("Observational memory: pruner could not reach budget (too many protected observations)", "warning");
+                }
+                // ================================================================
+                // BUILD FINAL SUMMARY: narrative (from unified call) +
+                // observations/reflections markdown (from renderSummary).
+                // This gives the LLM BOTH narrative context AND factual memory.
+                // ================================================================
                 emitProgressLine(emitProgress, `Rendering final memory summary from ${finalObservations.length} observations and ${finalReflections.length} reflections…`);
-                const summary = renderSummary(finalReflections, finalObservations);
+                const memoryMarkdown = renderSummary(finalReflections, finalObservations);
+                // Combine: narrative summary first (what happened), then memory
+                // (what was learned). Previous compaction's narrative is already
+                // merged into the unified call's output via previousSummary.
+                const summary = unifiedNarrativeSummary
+                    ? `${unifiedNarrativeSummary}\n\n---\n\n${memoryMarkdown}`
+                    : memoryMarkdown;
                 if (finalObservations.length === 0) {
                     throw new Error("invariant violated: finalObservations empty after delta guard");
                 }
@@ -341,6 +366,7 @@ export function registerCompactionHook(ext, runtime) {
                     finalReflections: finalReflections.length,
                     firstKeptEntryId,
                     tokensBefore,
+                    hasNarrative: !!unifiedNarrativeSummary,
                 });
                 emitProgressLine(emitProgress, `Compaction assembled — ${finalObservations.length} observation${finalObservations.length === 1 ? "" : "s"}, ${finalReflections.length} reflection${finalReflections.length === 1 ? "" : "s"}.`);
                 if (hasUI)
@@ -364,10 +390,10 @@ export function registerCompactionHook(ext, runtime) {
     function persistProjectObservations(ctx, reflections) {
         const store = getProjectObsStore();
         if (!store)
-            return; // Not available in standalone spectral mode.
+            return;
         const projectId = store.getProjectByCwd(ctx.cwd);
         if (!projectId)
-            return; // No project registered for this cwd.
+            return;
         const sessionId = ctx.sessionManager.getSessionId?.();
         if (!sessionId)
             return;

package/dist/memory/prompts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../src/memory/prompts.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,+QAA+Q,CAAC;AAE1S,eAAO,MAAM,yBAAyB,6oHAmD+F,CAAC;AAEtI,eAAO,MAAM,0BAA0B,67CAkB+F,CAAC;AAEvI,eAAO,MAAM,gBAAgB,8+CAasI,CAAC;AAEpK,eAAO,MAAM,eAAe,knTAoC2G,CAAC;AAExI,eAAO,MAAM,gBAAgB,69UA0DwH,CAAC;AAEtJ,eAAO,MAAM,aAAa,u2cAgFuP,CAAC;AASlR,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAGlF;AASD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAG/E;AAED,eAAO,MAAM,0BAA0B,07BAOoS,CAAC"}
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../src/memory/prompts.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,+QAA+Q,CAAC;AAE1S,eAAO,MAAM,yBAAyB,6oHAmD+F,CAAC;AAEtI,eAAO,MAAM,0BAA0B,67CAkB+F,CAAC;AAEvI,eAAO,MAAM,gBAAgB,8+CAasI,CAAC;AAEpK,eAAO,MAAM,eAAe,knTAoC2G,CAAC;AAExI,eAAO,MAAM,gBAAgB,69UA0DwH,CAAC;AAEtJ,eAAO,MAAM,aAAa,u2cAgFuP,CAAC;AAiBlR,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAIlF;AASD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAG/E;AAED,eAAO,MAAM,0BAA0B,07BAOoS,CAAC"}

package/dist/memory/prompts.js

@@ -261,11 +261,20 @@ What you CANNOT do:
 It is valid to end a pass with zero drops if the pool genuinely has nothing more to cut — a follow-up pass will be skipped when a run returns zero drops. On late pressure passes, first re-check old [coverage: reinforced] and [coverage: cited] observations as active-memory redundancies before deciding there are no sound drops. Do not force drops you don't believe in.
 
 Remember: pruning is active-memory management, not source deletion. A drop that looks reasonable at "low" still becomes a mistake if the content was a user correction with a mis-labeled relevance and no reflection captures it with equivalent fidelity. Read before you cut.`;
+const REFLECTOR_UNIFIED_PASS = `Pass strategy — combined broad synthesis + atomic facts in a single pass.
+
+Phase 1 — Multi-observation synthesis: First crystallize broad durable patterns, repeated preferences, recurring constraints, stable work style, and project-level themes supported by multiple observations. Every reflection in this phase must cite at least 2 distinct supportingObservationIds whose durable meaning is captured by the reflection. If an existing reflection already captures the pattern, repeat the exact same content when adding support ids materially improves active-memory coverage.
+
+Phase 2 — Atomic durable facts + safety review: Then capture important durable facts that may be supported by a single authoritative observation: explicit user preferences, hard constraints, corrections, decisions, completed milestones, project facts, release or rollback caveats, important technical context, and other load-bearing facts future agents must not forget. Review high and critical observations against reflections created in phase 1, and catch durable information still missing. Strengthen existing or newly-created reflections by repeating exact reflection content with additional supportingObservationIds for high, critical, and old medium observations whose durable meaning is already captured by that reflection.
+
+Do not duplicate earlier reflections; repeat exact existing content only to add missing support or promote no-provenance legacy memory. Create new reflections only when durable meaning is still missing. Do not create low-quality reflections just for coverage, and do not attach observations whose unique exact detail or current task state is not captured with equivalent fidelity.`;
 const REFLECTOR_PASS_STRATEGIES = {
     1: `Pass strategy — multi-observation synthesis. Find broad durable patterns, repeated preferences, recurring constraints, stable work style, and project-level themes supported by multiple observations. Every reflection recorded in this pass must cite at least 2 distinct supportingObservationIds whose durable meaning is captured by the reflection. Do not create one-off event summaries; leave important single-observation facts, safety review, and coverage strengthening for the final reflector pass. If an existing reflection already captures the pattern, repeat the exact same content when adding support ids materially improves active-memory coverage.`,
     2: `Pass strategy — final atomic durable facts, safety review, and coverage strengthening. Capture important durable facts that may be supported by a single authoritative observation: explicit user preferences, hard constraints, corrections, decisions, completed milestones, project facts, release or rollback caveats, important technical context, and other load-bearing facts future agents must not forget. Review high and critical observations against current reflections, including reflections created in pass 1, and catch durable information still missing. Strengthen existing or newly-created reflections by repeating exact reflection content with additional supportingObservationIds for high, critical, and old medium observations whose durable meaning is already captured by that reflection. Do not duplicate earlier reflections; repeat exact existing content only to add missing support or promote no-provenance legacy memory. Create new reflections only when durable meaning is still missing. Do not create low-quality reflections just for coverage, and do not attach observations whose unique exact detail or current task state is not captured with equivalent fidelity.`,
 };
 export function buildReflectorPassGuidance(pass, maxPasses) {
+    if (maxPasses === 1)
+        return REFLECTOR_UNIFIED_PASS;
     const tier = Math.min(2, Math.max(1, pass));
     return `Pass ${pass} of up to ${maxPasses}. ${REFLECTOR_PASS_STRATEGIES[tier]}`;
 }

package/dist/memory/unified-compaction.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Unified Compaction — single LLM call replacing both:
+ *   1. Core spectral generateSummary() (narrative conversation summary)
+ *   2. Sync catch-up observer (observation extraction from gap entries)
+ *
+ * Uses a text-based delimited output format (compatible with any model
+ * without requiring native structured-output support):
+ *
+ *   ===NARRATIVE===
+ *   ## Goal
+ *   ...
+ *
+ *   ===OBSERVATIONS===
+ *   [YYYY-MM-DD HH:MM] [relevance] Content line
+ *   ...
+ */
+import type { AgentMessage, ThinkingLevel } from "../sdk/agent-core/index.js";
+import type { Model } from "../sdk/ai/index.js";
+import type { ObservationRecord } from "./types.js";
+export interface UnifiedCompactionInput {
+    /** Messages to summarize (from core compaction preparation) */
+    messagesToSummarize: AgentMessage[];
+    /** Serialized gap entries as text with source entry labels */
+    gapChunk?: string;
+    /** Source entry IDs from gap entries */
+    gapSourceEntryIds?: string[];
+    /** Model to use */
+    model: Model<any>;
+    /** API key */
+    apiKey: string;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Abort signal */
+    signal?: AbortSignal;
+    /** Previous compaction summary for iterative update */
+    previousSummary?: string;
+    /** Custom instructions for summarization focus */
+    customInstructions?: string;
+    /** Thinking level for reasoning models */
+    thinkingLevel?: ThinkingLevel;
+    /** Reserve tokens for prompt + output */
+    reserveTokens: number;
+}
+export interface UnifiedCompactionOutput {
+    /** Markdown narrative summary (for CompactionEntry.summary) */
+    narrativeSummary: string;
+    /** Observations extracted from the conversation */
+    observations: ObservationRecord[];
+    /** Files read */
+    readFiles: string[];
+    /** Files modified */
+    modifiedFiles: string[];
+}
+/**
+ * Generate a unified compaction result: narrative summary + observations
+ * in a single LLM call. Uses delimited text output for broad model compatibility.
+ */
+export declare function generateUnifiedCompaction(input: UnifiedCompactionInput): Promise<UnifiedCompactionOutput>;
+//# sourceMappingURL=unified-compaction.d.ts.map

package/dist/memory/unified-compaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unified-compaction.d.ts","sourceRoot":"","sources":["../../src/memory/unified-compaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAUhD,OAAO,KAAK,EAAE,iBAAiB,EAAa,MAAM,YAAY,CAAC;AAkO/D,MAAM,WAAW,sBAAsB;IACtC,+DAA+D;IAC/D,mBAAmB,EAAE,YAAY,EAAE,CAAC;IACpC,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wCAAwC;IACxC,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,mBAAmB;IACnB,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IAClB,cAAc;IACd,MAAM,EAAE,MAAM,CAAC;IACf,sBAAsB;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,mBAAmB;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,uDAAuD;IACvD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kDAAkD;IAClD,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,0CAA0C;IAC1C,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,yCAAyC;IACzC,aAAa,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,uBAAuB;IACvC,+DAA+D;IAC/D,gBAAgB,EAAE,MAAM,CAAC;IACzB,mDAAmD;IACnD,YAAY,EAAE,iBAAiB,EAAE,CAAC;IAClC,iBAAiB;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,qBAAqB;IACrB,aAAa,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAsB,yBAAyB,CAC9C,KAAK,EAAE,sBAAsB,GAC3B,OAAO,CAAC,uBAAuB,CAAC,CA0IlC"}