@aexol/spectral 0.9.15 → 0.9.17

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

@@ -1,12 +1,14 @@
 import { debugLog, withDebugLogContext } from "../debug-log.js";
 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}`;
 }
@@ -17,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`);
 }
@@ -60,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 };
         }
@@ -71,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);
@@ -85,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);
@@ -104,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);
@@ -116,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,
@@ -207,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,
@@ -222,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", {
@@ -238,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: {
@@ -249,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,
@@ -293,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");
                 }
@@ -340,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)
@@ -363,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;
@@ -383,5 +410,6 @@ export function registerCompactionHook(ext, runtime) {
             projectId,
             sessionId,
         });
+        relayProjectObservations(ctx.cwd, projectId, sessionId, projectObs, "reflection");
     }
 }

package/dist/memory/hooks/inter-agent-receiver.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionAPI } from "../../sdk/coding-agent/index.js";
+export declare function registerInterAgentReceiver(ext: ExtensionAPI): void;
+//# sourceMappingURL=inter-agent-receiver.d.ts.map

package/dist/memory/hooks/inter-agent-receiver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inter-agent-receiver.d.ts","sourceRoot":"","sources":["../../../src/memory/hooks/inter-agent-receiver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAoFpE,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI,CAgIlE"}

package/dist/memory/hooks/inter-agent-receiver.js

@@ -0,0 +1,183 @@
+import { getProjectObsStore } from "../project-observations-store.js";
+import { getInterAgentBroker } from "../inter-agent-broker-singleton.js";
+import { loadConfig } from "../config.js";
+import { debugLog } from "../debug-log.js";
+const DELIVERED_OBSERVATIONS_CUSTOM_TYPE = "om.inter-agent.delivered";
+function getSessionId(ctx) {
+    return ctx.sessionManager.getSessionId?.();
+}
+function isAlreadyDelivered(branch, memoryId) {
+    if (!Array.isArray(branch))
+        return false;
+    for (const entry of branch) {
+        if (typeof entry === "object" &&
+            entry !== null &&
+            entry.type === "custom_entry" &&
+            entry.customType === DELIVERED_OBSERVATIONS_CUSTOM_TYPE) {
+            const ids = entry.data?.ids;
+            if (Array.isArray(ids) && ids.includes(memoryId))
+                return true;
+        }
+    }
+    return false;
+}
+function formatObservationPrompt(observations) {
+    const lines = observations.map((o) => `- [${o.relevance}] ${o.content} (shared by ${o.sourceSessionId}, id: \`${o.memoryId}\`)`);
+    return [
+        "",
+        "---",
+        "SHARED PROJECT OBSERVATIONS from other active sessions:",
+        "The following observations were shared by other agents working on this project. " +
+            "Consider them when making decisions, but verify against current code.",
+        "",
+        ...lines,
+        "---",
+    ].join("\n");
+}
+function parseObservationPayload(msg) {
+    if (msg.kind !== "observation")
+        return null;
+    try {
+        const raw = JSON.parse(msg.payload);
+        if (typeof raw.memoryId !== "string" ||
+            typeof raw.content !== "string" ||
+            typeof raw.sourceSessionId !== "string" ||
+            typeof raw.timestamp !== "string") {
+            return null;
+        }
+        const relevance = ["low", "medium", "high", "critical"].includes(String(raw.relevance))
+            ? raw.relevance
+            : "medium";
+        const originType = raw.originType === "reflection" ? "reflection" : "observation";
+        return {
+            memoryId: raw.memoryId,
+            content: raw.content,
+            relevance,
+            sourceSessionId: raw.sourceSessionId,
+            originType,
+            timestamp: raw.timestamp,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function registerInterAgentReceiver(ext) {
+    const broker = getInterAgentBroker();
+    if (!broker) {
+        debugLog("inter_agent.receiver.disabled", { reason: "no_broker" });
+        return;
+    }
+    const receivers = new Map();
+    ext.on("session_start", (_event, ctx) => {
+        const store = getProjectObsStore();
+        if (!store)
+            return;
+        const projectId = store.getProjectByCwd(ctx.cwd);
+        const sessionId = getSessionId(ctx);
+        if (!projectId || !sessionId)
+            return;
+        const config = loadConfig(ctx.cwd);
+        if (config.interAgent?.autoReceive === false) {
+            debugLog("inter_agent.receiver.auto_disabled", { sessionId });
+            return;
+        }
+        // Rebuild delivered set from persisted custom entries so reloads don't
+        // re-inject the same observations.
+        const deliveredIds = new Set();
+        const branch = ctx.sessionManager.getBranch?.();
+        if (Array.isArray(branch)) {
+            for (const entry of branch) {
+                if (typeof entry === "object" &&
+                    entry !== null &&
+                    entry.type === "custom_entry" &&
+                    entry.customType === DELIVERED_OBSERVATIONS_CUSTOM_TYPE) {
+                    const ids = entry.data?.ids;
+                    if (Array.isArray(ids)) {
+                        for (const id of ids)
+                            deliveredIds.add(id);
+                    }
+                }
+            }
+        }
+        const state = {
+            sessionId,
+            projectId,
+            deliveredIds,
+            pending: [],
+        };
+        receivers.set(sessionId, state);
+        // Poll historical/undelivered messages.
+        const msgs = broker.poll({
+            projectId,
+            channel: "memory",
+            recipientSessionId: sessionId,
+            markDelivered: true,
+            limit: 50,
+        });
+        for (const msg of msgs) {
+            if (msg.senderSessionId === sessionId)
+                continue;
+            const obs = parseObservationPayload(msg);
+            if (!obs || deliveredIds.has(obs.memoryId))
+                continue;
+            state.pending.push(obs);
+            deliveredIds.add(obs.memoryId);
+        }
+        // Subscribe to live messages.
+        state.unsubscribe = broker.subscribe({
+            sessionId,
+            projectId,
+            channel: "memory",
+            handler: (msg) => {
+                if (msg.senderSessionId === sessionId)
+                    return;
+                const obs = parseObservationPayload(msg);
+                if (!obs || state.deliveredIds.has(obs.memoryId))
+                    return;
+                state.pending.push(obs);
+                state.deliveredIds.add(obs.memoryId);
+                if (ctx.hasUI && ctx.ui) {
+                    ctx.ui.notify(`Shared observation from ${msg.senderName ?? msg.senderSessionId}: ${obs.content.slice(0, 120)}`, "info");
+                }
+            },
+        });
+        if (state.pending.length > 0) {
+            debugLog("inter_agent.receiver.pending", {
+                sessionId,
+                count: state.pending.length,
+            });
+        }
+    });
+    ext.on("before_agent_start", (event, ctx) => {
+        const sessionId = getSessionId(ctx);
+        if (!sessionId)
+            return undefined;
+        const state = receivers.get(sessionId);
+        if (!state || state.pending.length === 0)
+            return undefined;
+        const observations = state.pending.splice(0, state.pending.length);
+        if (observations.length > 0) {
+            ext.appendEntry(DELIVERED_OBSERVATIONS_CUSTOM_TYPE, { ids: observations.map((o) => o.memoryId) });
+        }
+        const appendix = formatObservationPrompt(observations);
+        debugLog("inter_agent.receiver.inject", {
+            sessionId,
+            count: observations.length,
+            chars: appendix.length,
+        });
+        return {
+            systemPrompt: `${event.systemPrompt}\n${appendix}`,
+        };
+    });
+    ext.on("session_shutdown", (_event, ctx) => {
+        const sessionId = getSessionId(ctx);
+        if (!sessionId)
+            return;
+        const state = receivers.get(sessionId);
+        if (!state)
+            return;
+        state.unsubscribe?.();
+        receivers.delete(sessionId);
+    });
+}

package/dist/memory/hooks/observer-trigger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"observer-trigger.d.ts","sourceRoot":"","sources":["../../../src/memory/hooks/observer-trigger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAWpE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAK7C,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAyKjF"}
+{"version":3,"file":"observer-trigger.d.ts","sourceRoot":"","sources":["../../../src/memory/hooks/observer-trigger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAWpE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAO7C,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CA0KjF"}