opencode-graphiti 0.2.4 → 0.2.5-canary.2b67949.20260521183008

package/esm/src/handlers/chat.js

@@ -34,7 +34,7 @@ export function createChatHandler(deps) {
             if (prepared) {
                 state.injectedMemories = true;
             }
-            logger.info("Prepared local session memory for chat transform", {
+            logger.info("Prepared local memory for chat transform", {
                 sessionID: canonicalSessionId,
                 sourceSessionID: sessionID,
                 hotTierReady: state.hotTierReady,
@@ -48,7 +48,7 @@ export function createChatHandler(deps) {
             }
         }
         catch (error) {
-            logger.warn("Unable to prepare local session memory for chat transform", {
+            logger.warn("Unable to prepare local memory for chat transform", {
                 sessionID,
                 error,
             });

package/esm/src/handlers/compacting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compacting.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/compacting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,KAAK,cAAc,GAAG,WAAW,CAAC,KAAK,CAAC,iCAAiC,CAAC,CAAC,CAAC;AAI5E,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,cAAc,CAAC;CAChC;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,qBAAqB,GAC1B,cAAc,CAmChB"}
+{"version":3,"file":"compacting.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/compacting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,KAAK,cAAc,GAAG,WAAW,CAAC,KAAK,CAAC,iCAAiC,CAAC,CAAC,CAAC;AAI5E,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,cAAc,CAAC;CAChC;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,qBAAqB,GAC1B,cAAc,CAqChB"}

package/esm/src/handlers/compacting.js

@@ -9,19 +9,19 @@ export function createCompactingHandler(deps) {
             if (!state?.isMain)
                 return;
             sessionManager.markResolvedSessionActive(sessionID, canonicalSessionId);
-            const prepared = await sessionManager.prepareInjection(canonicalSessionId);
+            const prepared = await sessionManager.prepareInjection(canonicalSessionId, undefined, { forCompaction: true });
             if (!prepared?.envelope)
                 return;
             output.context.push(prepared.envelope);
             sessionManager.clearPendingInjection(state, prepared);
-            logger.info("Injected local session_memory into compaction context", {
+            logger.info("Injected local memory into compaction context", {
                 sessionID: canonicalSessionId,
                 sourceSessionID: sessionID,
                 hotTierReady: state.hotTierReady,
             });
         }
         catch (error) {
-            logger.warn("Unable to prepare local session memory for compaction", {
+            logger.warn("Unable to prepare local memory for compaction", {
                 sessionID,
                 error,
             });

package/esm/src/handlers/messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAQjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,KAAK,qBAAqB,GAAG,WAAW,CACtC,KAAK,CAAC,sCAAsC,CAAC,CAC9C,CAAC;AAIF,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,cAAc,CAAC;CAChC;AAyFD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,mBAAmB,GACxB,qBAAqB,CAmEvB"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAQjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,KAAK,qBAAqB,GAAG,WAAW,CACtC,KAAK,CAAC,sCAAsC,CAAC,CAC9C,CAAC;AAIF,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,cAAc,CAAC;CAChC;AAuGD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,mBAAmB,GACxB,qBAAqB,CAmEvB"}

package/esm/src/handlers/messages.js

@@ -9,16 +9,24 @@ const getTransformMessage = (input) => {
     return typeof message === "string" ? message : undefined;
 };
 const LEADING_SESSION_MEMORY_BLOCK = /^<session_memory\b[^>]*>[\s\S]*?<\/session_memory>(?:\r?\n){0,2}/;
-const LEADING_INJECTED_LEGACY_MEMORY_BLOCK_WITH_UUIDS = /^<memory\b(?=[^>]*\bdata-uuids=(["'])(?:[^"']*)\1)[^>]*>[\s\S]*?<\/memory>(?:\r?\n){0,2}/;
-const LEADING_INJECTED_EMPTY_LEGACY_MEMORY_BLOCK = /^<memory\b(?![^>]*\bdata-uuids=)[^>]*>\s*<\/memory>(?:\r?\n){0,2}/;
+const LEADING_MEMORY_BLOCK = /^<memory\b[^>]*>[\s\S]*?<\/memory>(?:\r?\n){0,2}/;
 const LEADING_PERSISTENT_MEMORY_BLOCK = /^<persistent_memory\b[^>]*>[\s\S]*?<\/persistent_memory>(?:\r?\n){0,2}/;
 const SESSION_MEMORY_SOURCE_ATTR_PATTERN = /<session_memory\b[^>]*\bsource=(['"])[^'"]+\1/i;
 const SESSION_MEMORY_GENERATED_SECTION_PATTERN = /<(?:session_snapshot|persistent_memory)\b/i;
+const MEMORY_VERSION_ATTR_PATTERN = /<memory\b[^>]*\bversion=(['"])2\1/i;
+const LEGACY_MEMORY_UUID_ATTR_PATTERN = /<memory\b[^>]*\bdata-uuids=(['"])(?:[^'"]*)\1/i;
+const EMPTY_MEMORY_BLOCK_PATTERN = /^<memory\b[^>]*>\s*<\/memory>$/i;
+const MEMORY_GENERATED_SECTION_PATTERN = /<(?:session_snapshot|persistent_memory)\b/i;
 const PERSISTENT_MEMORY_GENERATED_CONTENT_PATTERN = /<(?:node|fact|episode)\b/i;
 const USER_MEMORY_ENVELOPE_TAG_PATTERN = /<\/?(?:session_memory|memory|persistent_memory)\b[^>]*>/gi;
 const looksLikeInjectedSessionMemoryBlock = (block, allowAttrlessFollowup) => SESSION_MEMORY_SOURCE_ATTR_PATTERN.test(block) ||
     SESSION_MEMORY_GENERATED_SECTION_PATTERN.test(block) ||
     allowAttrlessFollowup;
+const looksLikeInjectedMemoryBlock = (block, allowAttrlessFollowup) => MEMORY_VERSION_ATTR_PATTERN.test(block) ||
+    LEGACY_MEMORY_UUID_ATTR_PATTERN.test(block) ||
+    EMPTY_MEMORY_BLOCK_PATTERN.test(block) ||
+    MEMORY_GENERATED_SECTION_PATTERN.test(block) ||
+    allowAttrlessFollowup;
 const looksLikeInjectedPersistentMemoryBlock = (block) => PERSISTENT_MEMORY_GENERATED_CONTENT_PATTERN.test(block);
 const scrubPromptMemoryText = (text) => {
     let scrubbed = text;
@@ -33,11 +41,10 @@ const scrubPromptMemoryText = (text) => {
             scrubbedInjectedPrefix = true;
             continue;
         }
-        const next = scrubbed
-            .replace(LEADING_INJECTED_LEGACY_MEMORY_BLOCK_WITH_UUIDS, "")
-            .replace(LEADING_INJECTED_EMPTY_LEGACY_MEMORY_BLOCK, "");
-        if (next !== scrubbed) {
-            scrubbed = next;
+        const leadingMemory = scrubbed.match(LEADING_MEMORY_BLOCK)?.[0];
+        if (leadingMemory &&
+            looksLikeInjectedMemoryBlock(leadingMemory, scrubbedInjectedPrefix)) {
+            scrubbed = scrubbed.slice(leadingMemory.length);
             scrubbedInjectedPrefix = true;
             continue;
         }
@@ -83,7 +90,7 @@ export function createMessagesHandler(deps) {
                 return;
             }
             textPart.text = `${prepared.envelope}\n\n${effectiveUserText}`;
-            logger.info("Injected canonical session_memory block", {
+            logger.info("Injected canonical memory block", {
                 sessionID: canonicalSessionId,
                 sourceSessionID,
                 rewroteExistingMemory: scrubbedUserText !== latestUserText,

package/esm/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAsE/D,eAAO,MAAM,gCAAgC,GAC3C,WAAW,OAAO,EAClB,UAAU,MAAM,KACf,IAOF,CAAC;AAEF,eAAO,MAAM,6BAA6B,GACxC,WAAW,OAAO,EAClB,UAAU,MAAM,KACf,IAOF,CAAC;AA+BF,eAAO,MAAM,QAAQ,EAAE,MA0OtB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,MAAM,EAAe,MAAM,qBAAqB,CAAC;AA6GtE,eAAO,MAAM,gCAAgC,GAC3C,WAAW,OAAO,EAClB,UAAU,MAAM,KACf,IAOF,CAAC;AAEF,eAAO,MAAM,6BAA6B,GACxC,WAAW,OAAO,EAClB,UAAU,MAAM,KACf,IAOF,CAAC;AAmCF,eAAO,MAAM,QAAQ,EAAE,MAkTtB,CAAC"}

package/esm/src/index.js

@@ -11,18 +11,32 @@ import { GraphitiConnectionManager } from "./services/connection-manager.js";
 import { GraphitiAsyncService } from "./services/graphiti-async.js";
 import { GraphitiMcpClient } from "./services/graphiti-mcp.js";
 import { redactEndpointUserInfo } from "./services/endpoint-redaction.js";
-import { notifyGraphitiAvailabilityIssue, setOpenCodeClient, } from "./services/opencode-warning.js";
+import { notifyDreamShutdownDelay, notifyGraphitiAvailabilityIssue, setOpenCodeClient, } from "./services/opencode-warning.js";
 import { RedisCacheService } from "./services/redis-cache.js";
 import { RedisClient } from "./services/redis-client.js";
 import { RedisEventsService } from "./services/redis-events.js";
+import { DreamStore } from "./services/dream-store.js";
 import { logger } from "./services/logger.js";
+import { SessionNotesService } from "./services/session-notes.js";
 import { RedisSnapshotService } from "./services/redis-snapshot.js";
 import { registerRuntimeTeardown } from "./services/runtime-teardown.js";
 import { createSessionExecutor } from "./services/session-executor.js";
-import { createSessionMcpRuntime } from "./services/session-mcp-runtime.js";
+import { createSessionMcpRuntime, SESSION_SEARCH_STRENGTHENED_DESCRIPTION, } from "./services/session-mcp-runtime.js";
 import { ToolGuidanceCache } from "./services/tool-guidance-cache.js";
 import { ToolRoutingOutcomeCache } from "./services/tool-routing-outcome-cache.js";
 import { makeGroupId, makeUserGroupId } from "./utils.js";
+const getTrackedRootSessionIds = (sessionManager) => {
+    const manager = sessionManager;
+    const tracked = manager.getTrackedRootSessionIds;
+    if (typeof tracked === "function") {
+        return tracked.call(sessionManager);
+    }
+    if (!(manager.sessions instanceof Map))
+        return [];
+    return [...manager.sessions.entries()]
+        .filter(([, state]) => state?.isMain)
+        .map(([sessionId]) => sessionId);
+};
 let activeRuntimeTeardown = null;
 let runtimeInitialization = Promise.resolve();
 export const warnOnGraphitiStartupUnavailable = (connected, endpoint) => {
@@ -40,6 +54,7 @@ export const warnOnRedisStartupUnavailable = (connected, endpoint) => {
 const defaultGraphitiDependencies = {
     loadConfig,
     setOpenCodeClient,
+    notifyDreamShutdownDelay,
     warnOnGraphitiStartupUnavailable,
     warnOnRedisStartupUnavailable,
     GraphitiConnectionManager,
@@ -49,6 +64,8 @@ const defaultGraphitiDependencies = {
     RedisEventsService,
     RedisSnapshotService,
     RedisCacheService,
+    DreamStore,
+    SessionNotesService,
     BatchDrainService,
     GraphitiAsyncService,
     createSessionExecutor,
@@ -64,6 +81,7 @@ const defaultGraphitiDependencies = {
     ToolRoutingOutcomeCache,
     makeGroupId,
     makeUserGroupId,
+    now: () => new Date().toISOString(),
 };
 export const graphiti = (input, dependencies = defaultGraphitiDependencies) => {
     const setup = runtimeInitialization.then(async () => {
@@ -137,13 +155,17 @@ export const graphiti = (input, dependencies = defaultGraphitiDependencies) => {
                 ttlSeconds: config.redis.cacheTtlSeconds,
                 driftThreshold: config.graphiti.driftThreshold,
             });
+            const dreamStore = new dependencies.DreamStore(redisClient);
+            const defaultGroupId = dependencies.makeGroupId(config.graphiti.groupIdPrefix, input.directory);
+            const defaultUserGroupId = dependencies.makeUserGroupId(config.graphiti.groupIdPrefix, input.directory);
+            const notesService = new dependencies.SessionNotesService(redisClient, {
+                groupId: defaultGroupId,
+            });
             const batchDrain = new dependencies.BatchDrainService(redisClient, redisEvents, {
                 batchSize: config.redis.batchSize,
                 batchMaxBytes: config.redis.batchMaxBytes,
                 drainRetryMax: config.redis.drainRetryMax,
             });
-            const defaultGroupId = dependencies.makeGroupId(config.graphiti.groupIdPrefix, input.directory);
-            const defaultUserGroupId = dependencies.makeUserGroupId(config.graphiti.groupIdPrefix, input.directory);
             const graphitiAsync = new dependencies.GraphitiAsyncService(graphitiClient, redisCache, batchDrain);
             startupCleanupTasks.unshift({
                 name: "graphiti-async",
@@ -153,6 +175,7 @@ export const graphiti = (input, dependencies = defaultGraphitiDependencies) => {
             const sessionMcpRuntime = dependencies.createSessionMcpRuntime({
                 redisClient,
                 graphitiCache: redisCache,
+                notesService,
                 sessionTtlSeconds: config.redis.sessionTtlSeconds,
                 groupId: defaultGroupId,
                 sessionExecutor,
@@ -164,12 +187,37 @@ export const graphiti = (input, dependencies = defaultGraphitiDependencies) => {
             });
             const sessionManager = new dependencies.SessionManager(defaultGroupId, defaultUserGroupId, input.client, redisEvents, redisSnapshot, redisCache, {
                 idleRetentionMs: config.redis.sessionTtlSeconds * 1000,
+                notesService,
                 runtimeStateMigrator: sessionMcpRuntime,
             });
             sessionMcpRuntime.setSessionCanonicalizer(sessionManager);
             const toolGuidanceCache = new dependencies.ToolGuidanceCache();
             const toolRoutingOutcomes = new dependencies.ToolRoutingOutcomeCache();
+            const sessionBiasState = new Map();
+            const chatHandler = dependencies.createChatHandler({
+                sessionManager,
+                redisEvents,
+                graphitiAsync,
+                drainTriggerSize: config.redis.batchSize,
+            });
+            const compactingHandler = dependencies
+                .createCompactingHandler({
+                sessionManager,
+            });
             startupTeardown = dependencies.registerRuntimeTeardown([
+                {
+                    name: "dream-shutdown-warning",
+                    run: async () => {
+                        const targetWatermark = dependencies.now();
+                        for (const rootSessionId of getTrackedRootSessionIds(sessionManager)) {
+                            const watermark = await dreamStore.getWatermark(rootSessionId);
+                            if (watermark === null || watermark < targetWatermark) {
+                                dependencies.notifyDreamShutdownDelay();
+                                return;
+                            }
+                        }
+                    },
+                },
                 {
                     name: "graphiti-drain-flush",
                     run: () => graphitiAsync.flushPendingGroups(sessionManager.getTrackedGroupIds()),
@@ -204,21 +252,45 @@ export const graphiti = (input, dependencies = defaultGraphitiDependencies) => {
                     sdkClient: input.client,
                     directory: input.directory,
                 }),
-                "chat.message": dependencies.createChatHandler({
-                    sessionManager,
-                    redisEvents,
-                    graphitiAsync,
-                    drainTriggerSize: config.redis.batchSize,
-                }),
-                "experimental.session.compacting": dependencies
-                    .createCompactingHandler({
-                    sessionManager,
-                }),
+                "chat.message": async (hookInput, output) => {
+                    const canonicalSessionId = sessionManager.getCachedCanonicalSessionId(hookInput.sessionID) ??
+                        await sessionManager.resolveCanonicalSessionId(hookInput.sessionID);
+                    if (canonicalSessionId && !sessionBiasState.has(canonicalSessionId)) {
+                        const priorEvents = await redisEvents.getRecentSessionEvents(canonicalSessionId, 1, false);
+                        if (priorEvents.length === 0) {
+                            sessionBiasState.set(canonicalSessionId, "new-session");
+                        }
+                    }
+                    await chatHandler(hookInput, output);
+                },
+                "experimental.session.compacting": async (hookInput, output) => {
+                    const canonicalSessionId = sessionManager.getCachedCanonicalSessionId(hookInput.sessionID) ??
+                        await sessionManager.resolveCanonicalSessionId(hookInput.sessionID);
+                    if (canonicalSessionId) {
+                        sessionBiasState.set(canonicalSessionId, "post-compaction");
+                    }
+                    await compactingHandler(hookInput, output);
+                },
                 "experimental.chat.messages.transform": dependencies
                     .createMessagesHandler({
                     sessionManager,
                 }),
                 tool: sessionMcpRuntime.tools,
+                "tool.definition": (hookInput, output) => {
+                    if (hookInput.toolID !== "session_search")
+                        return Promise.resolve();
+                    let anyBiased = false;
+                    for (const [sessionId, state] of sessionBiasState) {
+                        if (state === "normal")
+                            continue;
+                        anyBiased = true;
+                        sessionBiasState.delete(sessionId);
+                    }
+                    if (anyBiased) {
+                        output.description = SESSION_SEARCH_STRENGTHENED_DESCRIPTION;
+                    }
+                    return Promise.resolve();
+                },
                 "tool.execute.before": dependencies.createToolBeforeHandler({
                     sessionCanonicalizer: sessionManager,
                     guidanceThrottle: toolGuidanceCache,

package/esm/src/services/dream-store.d.ts

@@ -0,0 +1,21 @@
+import type { NormalizedMemoryResult } from "../types/index.js";
+import type { RedisClient } from "./redis-client.js";
+export type DreamSummaryRecord = {
+    rootSessionId: string;
+    granularity: string;
+    created_at: string;
+    body: string;
+};
+export declare class DreamStore {
+    private readonly redis;
+    constructor(redis: RedisClient);
+    putSummary(record: DreamSummaryRecord): Promise<void>;
+    getSummariesAround(input: {
+        rootSessionId: string;
+        when: string;
+        query?: string;
+    }): Promise<NormalizedMemoryResult[]>;
+    getWatermark(rootSessionId: string): Promise<string | null>;
+    setWatermark(rootSessionId: string, value: string): Promise<void>;
+}
+//# sourceMappingURL=dream-store.d.ts.map

package/esm/src/services/dream-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dream-store.d.ts","sourceRoot":"","sources":["../../../src/src/services/dream-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAgEF,qBAAa,UAAU;IACT,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAAL,KAAK,EAAE,WAAW;IAEzC,UAAU,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAYrD,kBAAkB,CAAC,KAAK,EAAE;QAC9B,aAAa,EAAE,MAAM,CAAC;QACtB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,GAAG,OAAO,CAAC,sBAAsB,EAAE,CAAC;IA8C/B,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAI3D,YAAY,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAGxE"}

package/esm/src/services/dream-store.js

@@ -0,0 +1,96 @@
+const dreamSummariesKey = (rootSessionId) => `session:${rootSessionId}:dream:summaries`;
+const dreamSummaryField = (record) => `${record.granularity}:${record.created_at}`;
+const dreamWatermarkKey = (rootSessionId) => `session:${rootSessionId}:dream:watermark`;
+const normalizeText = (value) => value.trim().replace(/\s+/g, " ");
+const tokenize = (value) => normalizeText(value).toLowerCase().match(/[a-z0-9]{2,}/g) ?? [];
+const parseStoredRecord = (value) => {
+    try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed.granularity !== "string" ||
+            typeof parsed.created_at !== "string" ||
+            typeof parsed.body !== "string") {
+            return null;
+        }
+        return {
+            granularity: parsed.granularity,
+            created_at: parsed.created_at,
+            body: parsed.body,
+        };
+    }
+    catch {
+        return null;
+    }
+};
+const scoreSummary = (record, query) => {
+    const normalizedQuery = normalizeText(query ?? "").toLowerCase();
+    if (!normalizedQuery)
+        return 1;
+    const body = normalizeText(record.body).toLowerCase();
+    if (body === normalizedQuery)
+        return 1;
+    if (body.includes(normalizedQuery))
+        return 0.95;
+    const queryTokens = [...new Set(tokenize(normalizedQuery))];
+    if (queryTokens.length === 0)
+        return 0;
+    const matched = queryTokens.filter((token) => body.includes(token));
+    if (matched.length === 0)
+        return 0;
+    return Number((matched.length / queryTokens.length).toFixed(6));
+};
+export class DreamStore {
+    constructor(redis) {
+        Object.defineProperty(this, "redis", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: redis
+        });
+    }
+    async putSummary(record) {
+        await this.redis.setHashFields(dreamSummariesKey(record.rootSessionId), {
+            [dreamSummaryField(record)]: JSON.stringify({
+                granularity: record.granularity,
+                created_at: record.created_at,
+                body: record.body,
+            }),
+        });
+    }
+    async getSummariesAround(input) {
+        const summaries = Object.values(await this.redis.getHashAll(dreamSummariesKey(input.rootSessionId)))
+            .map(parseStoredRecord)
+            .filter((record) => record !== null)
+            .map((record) => ({
+            record,
+            score: scoreSummary(record, input.query),
+        }))
+            .filter(({ score }) => score > 0)
+            .sort((left, right) => left.record.created_at.localeCompare(right.record.created_at));
+        const before = summaries.filter(({ record }) => record.created_at < input.when);
+        const exact = summaries.filter(({ record }) => record.created_at === input.when);
+        const after = summaries.filter(({ record }) => record.created_at > input.when);
+        const selected = [
+            ...before.slice(-1),
+            ...exact,
+            ...after.slice(0, 1),
+        ];
+        return selected.map(({ record, score }) => ({
+            type: "summary",
+            ref: `session:${input.rootSessionId}:summary:dream:${record.granularity}:${record.created_at}`,
+            snippet: record.body,
+            score,
+            id: `${record.granularity}:${record.created_at}`,
+            root_session_id: input.rootSessionId,
+            scope: "session",
+            granularity: record.granularity,
+            created_at: record.created_at,
+            source: "dream",
+        }));
+    }
+    async getWatermark(rootSessionId) {
+        return await this.redis.getString(dreamWatermarkKey(rootSessionId));
+    }
+    async setWatermark(rootSessionId, value) {
+        await this.redis.setString(dreamWatermarkKey(rootSessionId), value);
+    }
+}

package/esm/src/services/exact-history.d.ts

@@ -0,0 +1,10 @@
+import type { NormalizedMemoryResult } from "../types/index.js";
+export type ExactHistoryAdapter = {
+    search(input: {
+        rootSessionId: string;
+        query: string;
+        when: string;
+    }): Promise<NormalizedMemoryResult[]>;
+};
+export declare const createExactHistoryAdapter: () => ExactHistoryAdapter;
+//# sourceMappingURL=exact-history.d.ts.map

package/esm/src/services/exact-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exact-history.d.ts","sourceRoot":"","sources":["../../../src/src/services/exact-history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEhE,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,CAAC,KAAK,EAAE;QACZ,aAAa,EAAE,MAAM,CAAC;QACtB,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;KACd,GAAG,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,yBAAyB,QAAO,mBAE3C,CAAC"}

package/esm/src/services/exact-history.js

@@ -0,0 +1,3 @@
+export const createExactHistoryAdapter = () => ({
+    search: () => Promise.resolve([]),
+});

package/esm/src/services/memory-results.d.ts

@@ -0,0 +1,6 @@
+import type { NormalizedMemoryResult } from "../types/index.js";
+export declare const compareWeightedResults: (left: NormalizedMemoryResult, right: NormalizedMemoryResult) => number;
+export declare const orderMemoryResults: (results: NormalizedMemoryResult[], options: {
+    mode: "query" | "reflection";
+}) => NormalizedMemoryResult[];
+//# sourceMappingURL=memory-results.d.ts.map

package/esm/src/services/memory-results.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-results.d.ts","sourceRoot":"","sources":["../../../src/src/services/memory-results.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEhE,eAAO,MAAM,sBAAsB,GACjC,MAAM,sBAAsB,EAC5B,OAAO,sBAAsB,KAC5B,MAQF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,SAAS,sBAAsB,EAAE,EACjC,SAAS;IAAE,IAAI,EAAE,OAAO,GAAG,YAAY,CAAA;CAAE,KACxC,sBAAsB,EAexB,CAAC"}

package/esm/src/services/memory-results.js

@@ -0,0 +1,23 @@
+export const compareWeightedResults = (left, right) => {
+    if (right.score !== left.score) {
+        return right.score - left.score;
+    }
+    if (right.created_at !== left.created_at) {
+        return right.created_at.localeCompare(left.created_at);
+    }
+    return left.ref.localeCompare(right.ref);
+};
+export const orderMemoryResults = (results, options) => {
+    if (options.mode === "reflection") {
+        return results
+            .filter((result) => result.type === "summary")
+            .sort((left, right) => left.created_at.localeCompare(right.created_at));
+    }
+    const primary = results
+        .filter((result) => result.type === "entry" || result.type === "note")
+        .sort(compareWeightedResults);
+    const summaries = results
+        .filter((result) => result.type === "summary")
+        .sort(compareWeightedResults);
+    return [...primary, ...summaries];
+};

package/esm/src/services/memory-search.d.ts

@@ -0,0 +1,29 @@
+import type { NormalizedMemoryResult } from "../types/index.js";
+import type { ExactHistoryAdapter } from "./exact-history.js";
+import type { SessionMcpResponseMap } from "./session-mcp-types.js";
+import type { SessionNotesService } from "./session-notes.js";
+export type SummarySearchAdapter = {
+    search(input: {
+        rootSessionId: string;
+        query: string;
+        when: string;
+    }): Promise<NormalizedMemoryResult[]>;
+};
+export type MemorySearchService = {
+    search(input: {
+        rootSessionId: string;
+        query: string;
+        when: string;
+    }): Promise<SessionMcpResponseMap["session_search"]>;
+};
+type MemorySearchServiceOptions = {
+    exactHistoryAdapter: ExactHistoryAdapter;
+    notesService: Pick<SessionNotesService, "searchNotes">;
+    summarySearchAdapter: SummarySearchAdapter;
+    groupId: string;
+    resultLimit?: number;
+};
+export declare const createSummarySearchAdapter: () => SummarySearchAdapter;
+export declare const createMemorySearchService: (options: MemorySearchServiceOptions) => MemorySearchService;
+export {};
+//# sourceMappingURL=memory-search.d.ts.map

package/esm/src/services/memory-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-search.d.ts","sourceRoot":"","sources":["../../../src/src/services/memory-search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,CAAC,KAAK,EAAE;QACZ,aAAa,EAAE,MAAM,CAAC;QACtB,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;KACd,GAAG,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,CAAC,KAAK,EAAE;QACZ,aAAa,EAAE,MAAM,CAAC;QACtB,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;KACd,GAAG,OAAO,CAAC,qBAAqB,CAAC,gBAAgB,CAAC,CAAC,CAAC;CACtD,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,YAAY,EAAE,IAAI,CAAC,mBAAmB,EAAE,aAAa,CAAC,CAAC;IACvD,oBAAoB,EAAE,oBAAoB,CAAC;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,0BAA0B,QAAO,oBAE5C,CAAC;AAMH,eAAO,MAAM,yBAAyB,GACpC,SAAS,0BAA0B,KAClC,mBAqDF,CAAC"}

package/esm/src/services/memory-search.js

@@ -0,0 +1,53 @@
+import { orderMemoryResults } from "./memory-results.js";
+export const createSummarySearchAdapter = () => ({
+    search: () => Promise.resolve([]),
+});
+const uniqueRefs = (results) => [
+    ...new Set(results.map((result) => result.ref)),
+];
+export const createMemorySearchService = (options) => {
+    const resultLimit = options.resultLimit ?? Number.POSITIVE_INFINITY;
+    return {
+        async search(input) {
+            const summaries = await options.summarySearchAdapter.search(input);
+            if (input.query === "") {
+                const ordered = orderMemoryResults(summaries, { mode: "reflection" });
+                const results = ordered.slice(0, resultLimit);
+                return {
+                    status: "ok",
+                    results,
+                    refs: uniqueRefs(results),
+                    truncated: ordered.length > results.length,
+                };
+            }
+            const [entries, notes] = await Promise.all([
+                options.exactHistoryAdapter.search(input),
+                options.notesService.searchNotes(input.rootSessionId, input.query),
+            ]);
+            const normalizedNotes = notes.map((note) => ({
+                type: "note",
+                ref: `session:${options.groupId}:${note.root_session_id}:note:${note.id}`,
+                snippet: note.snippet,
+                score: note.score,
+                id: note.id,
+                root_session_id: note.root_session_id,
+                scope: note.scope,
+                created_at: note.created_at,
+                updated_at: note.updated_at,
+                source: "session-notes",
+            }));
+            const ordered = orderMemoryResults([
+                ...entries,
+                ...normalizedNotes,
+                ...summaries,
+            ], { mode: "query" });
+            const results = ordered.slice(0, resultLimit);
+            return {
+                status: "ok",
+                results,
+                refs: uniqueRefs(results),
+                truncated: ordered.length > results.length,
+            };
+        },
+    };
+};

package/esm/src/services/opencode-warning.d.ts

@@ -6,4 +6,5 @@ export declare const logStructuredWarning: (message: string, extra?: unknown) =>
 export declare const showWarningToast: (message: string, extra?: unknown) => boolean;
 export declare const notifyPluginWarning: (message: string, extra?: unknown) => void;
 export declare const notifyGraphitiAvailabilityIssue: (message: string, extra?: unknown) => void;
+export declare const notifyDreamShutdownDelay: () => void;
 //# sourceMappingURL=opencode-warning.d.ts.map

package/esm/src/services/opencode-warning.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"opencode-warning.d.ts","sourceRoot":"","sources":["../../../src/src/services/opencode-warning.ts"],"names":[],"mappings":"AAoCA,eAAO,MAAM,wCAAwC,QAAO,OAM3D,CAAC;AA6FF,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,OAAO,KACd,IAEF,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,WAAW,CAAC,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC,GAAG,SAAS,KACtD,IAIF,CAAC;AAEF,eAAO,MAAM,6CAA6C,GACxD,OAAO,OAAO,GAAG,SAAS,KACzB,IAEF,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,SAAS,MAAM,EACf,QAAQ,OAAO,KACd,OAEF,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,EAAE,QAAQ,OAAO,KAAG,OAEnE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,SAAS,MAAM,EACf,QAAQ,OAAO,KACd,IAMF,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAC1C,SAAS,MAAM,EACf,QAAQ,OAAO,KACd,IAEF,CAAC"}
+{"version":3,"file":"opencode-warning.d.ts","sourceRoot":"","sources":["../../../src/src/services/opencode-warning.ts"],"names":[],"mappings":"AAoCA,eAAO,MAAM,wCAAwC,QAAO,OAM3D,CAAC;AA6FF,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,OAAO,KACd,IAEF,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,WAAW,CAAC,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC,GAAG,SAAS,KACtD,IAIF,CAAC;AAEF,eAAO,MAAM,6CAA6C,GACxD,OAAO,OAAO,GAAG,SAAS,KACzB,IAEF,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,SAAS,MAAM,EACf,QAAQ,OAAO,KACd,OAEF,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,EAAE,QAAQ,OAAO,KAAG,OAEnE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,SAAS,MAAM,EACf,QAAQ,OAAO,KACd,IAMF,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAC1C,SAAS,MAAM,EACf,QAAQ,OAAO,KACd,IAEF,CAAC;AAEF,eAAO,MAAM,wBAAwB,QAAO,IAI3C,CAAC"}

package/esm/src/services/opencode-warning.js

@@ -105,3 +105,6 @@ export const notifyPluginWarning = (message, extra) => {
 export const notifyGraphitiAvailabilityIssue = (message, extra) => {
     notifyPluginWarning(message, extra);
 };
+export const notifyDreamShutdownDelay = () => {
+    notifyPluginWarning("Dreaming is still in progress; keep OpenCode open and wait for dreaming to complete before exiting.");
+};

package/esm/src/services/redis-snapshot.d.ts

@@ -1,5 +1,13 @@
 import { type SessionEvent } from "../types/index.js";
 import type { RedisClient } from "./redis-client.js";
+import type { NormalizedMemoryResult } from "../types/index.js";
+export declare const createSnapshotSummaryResult: (input: {
+    rootSessionId: string;
+    created_at: string;
+    snippet: string;
+    id?: string;
+    granularity?: string;
+}) => NormalizedMemoryResult;
 export declare const buildSessionSnapshotXml: (sessionId: string, events: SessionEvent[]) => string;
 export interface RedisSnapshotServiceOptions {
     ttlSeconds: number;

package/esm/src/services/redis-snapshot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redis-snapshot.d.ts","sourceRoot":"","sources":["../../../src/src/services/redis-snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAgCrD,eAAO,MAAM,uBAAuB,GAClC,WAAW,MAAM,EACjB,QAAQ,YAAY,EAAE,KACrB,MAiOF,CAAC;AAEF,MAAM,WAAW,2BAA2B;IAC1C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,oBAAoB;IAE7B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,2BAA2B;IAGjD,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAItD,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQhE,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO/C,cAAc,CAClB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,YAAY,EAAE,GACrB,OAAO,CAAC,MAAM,CAAC;CAKnB"}
+{"version":3,"file":"redis-snapshot.d.ts","sourceRoot":"","sources":["../../../src/src/services/redis-snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAUrD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAKhE,eAAO,MAAM,2BAA2B,GAAI,OAAO;IACjD,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,KAAG,sBAaF,CAAC;AAoBH,eAAO,MAAM,uBAAuB,GAClC,WAAW,MAAM,EACjB,QAAQ,YAAY,EAAE,KACrB,MAiOF,CAAC;AAEF,MAAM,WAAW,2BAA2B;IAC1C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,oBAAoB;IAE7B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,2BAA2B;IAGjD,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAItD,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQhE,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO/C,cAAc,CAClB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,YAAY,EAAE,GACrB,OAAO,CAAC,MAAM,CAAC;CAKnB"}

package/esm/src/services/redis-snapshot.js

@@ -3,6 +3,18 @@ import { sessionSnapshotKey } from "./redis-events.js";
 import { escapeXml, normalizeMemoryText, renderXmlListSection, renderXmlSingleSection, sanitizeMemoryInput, uniqueNormalizedValues, } from "./render-utils.js";
 const SNAPSHOT_BUDGET = 3_000;
 const BLOCKER_PATTERN = /\b(blocker|blocked|blocking)\b/i;
+export const createSnapshotSummaryResult = (input) => ({
+    type: "summary",
+    ref: `session:${input.rootSessionId}:summary:snapshot:${input.id ?? input.created_at}`,
+    snippet: input.snippet,
+    score: 1,
+    created_at: input.created_at,
+    id: input.id ?? input.created_at,
+    root_session_id: input.rootSessionId,
+    scope: "session",
+    granularity: input.granularity ?? "session",
+    source: "snapshot",
+});
 const selectRecent = (events, predicate, map, limit, excludedNormalized = new Set()) => uniqueNormalizedValues(events.flatMap((event) => {
     if (!predicate(event))
         return [];

package/esm/src/services/runtime-teardown.d.ts

@@ -2,6 +2,7 @@ export type RuntimeTeardownTask = {
     name: string;
     run: () => void | Promise<void>;
 };
+export declare const createRuntimeTeardownTask: (name: string, run: () => void | Promise<void>) => RuntimeTeardownTask;
 export interface RuntimeTeardownRegistration {
     run(): Promise<void>;
     dispose(): void;