@psiclawops/hypermem 0.5.5 → 0.6.2

package/dist/compositor.js

@@ -17,13 +17,23 @@ import { SessionTopicMap } from './session-topic-map.js';
 import { toProviderFormat } from './provider-translator.js';
 import { DocChunkStore } from './doc-chunk-store.js';
 import { hybridSearch } from './hybrid-retrieval.js';
-import { ensureCompactionFenceSchema, updateCompactionFence } from './compaction-fence.js';
+import { ensureCompactionFenceSchema, updateCompactionFence, getCompactionFence } from './compaction-fence.js';
+import { getActiveContext } from './context-store.js';
 import { rankKeystones, scoreKeystone } from './keystone-scorer.js';
 import { buildOrgRegistryFromDb, defaultOrgRegistry } from './cross-agent.js';
 import { getActiveFOS, matchMOD, renderFOS, renderMOD, renderLightFOS, resolveOutputTier, buildActionVerificationSummary } from './fos-mod.js';
 import { KnowledgeStore } from './knowledge-store.js';
 import { TemporalStore, hasTemporalSignals } from './temporal-store.js';
 import { isOpenDomainQuery, searchOpenDomain } from './open-domain.js';
+/**
+ * Files that OpenClaw's contextInjection injects into the system prompt.
+ * HyperMem must not re-inject these via doc chunk retrieval to avoid duplication.
+ * Exported so plugin and other consumers can share the same dedup set.
+ */
+export const OPENCLAW_BOOTSTRAP_FILES = new Set([
+    'SOUL.md', 'IDENTITY.md', 'USER.md', 'TOOLS.md',
+    'AGENTS.md', 'HEARTBEAT.md', 'MEMORY.md', 'BOOTSTRAP.md',
+]);
 /**
  * Model context window sizes by provider/model string (or partial match).
  * Used as fallback when tokenBudget is not passed by the runtime.
@@ -65,7 +75,26 @@ const MODEL_CONTEXT_WINDOWS = [
  * Default reserve: 25% (leaves 75% for input context).
  * Falls back to defaultTokenBudget if no model match.
  */
-function resolveModelBudget(model, defaultBudget, reserve = 0.15) {
+/**
+ * Resolve effective input token budget for a model.
+ *
+ * Priority:
+ * 1. If budgetFraction is set AND model window is detected: window × budgetFraction × (1 - reserve)
+ * 2. If model window detected but no budgetFraction: window × (1 - reserve)
+ * 3. Fallback to defaultTokenBudget (absolute number)
+ */
+function resolveModelBudget(model, defaultBudget, reserve = 0.15, budgetFraction) {
+    const window = resolveModelWindow(model, defaultBudget);
+    // If we detected an actual model window (not the fallback derivation)
+    if (model && budgetFraction != null) {
+        const normalized = model.toLowerCase();
+        for (const entry of MODEL_CONTEXT_WINDOWS) {
+            if (normalized.includes(entry.pattern)) {
+                return Math.floor(entry.tokens * budgetFraction * (1 - reserve));
+            }
+        }
+    }
+    // Original path: detected window × (1 - reserve), or absolute fallback
     if (!model)
         return defaultBudget;
     const normalized = model.toLowerCase();
@@ -102,12 +131,19 @@ function resolveModelWindow(model, defaultBudget) {
  * emit a warning or trigger checkpointing.
  */
 function computeDynamicReserve(recentMessages, totalWindow, config) {
-    const base = config.contextWindowReserve ?? 0.15;
+    const base = config.reserveFraction ?? config.contextWindowReserve ?? 0.25;
     const horizon = config.dynamicReserveTurnHorizon ?? 5;
     const max = config.dynamicReserveMax ?? 0.50;
     const enabled = config.dynamicReserveEnabled ?? true;
-    if (!enabled || recentMessages.length === 0 || totalWindow <= 0) {
-        return { reserve: base, avgTurnCost: 0, dynamic: false, pressureHigh: false };
+    // Cold sessions (no message history) use a minimal floor so the full window
+    // stays available. The static reserveFraction applies only once the session
+    // has messages and dynamic sampling can compute a meaningful estimate.
+    const COLD_SESSION_FLOOR = 0.15;
+    if (!enabled || totalWindow <= 0) {
+        return { reserve: COLD_SESSION_FLOOR, avgTurnCost: 0, dynamic: false, pressureHigh: false };
+    }
+    if (recentMessages.length === 0) {
+        return { reserve: COLD_SESSION_FLOOR, avgTurnCost: 0, dynamic: false, pressureHigh: false };
     }
     // Sample the last 20 user+assistant messages for turn cost estimation.
     // Tool messages are excluded — they're already compressed by the gradient
@@ -131,17 +167,26 @@ function computeDynamicReserve(recentMessages, totalWindow, config) {
     return { reserve: dynamicFrac, avgTurnCost, dynamic: true, pressureHigh: false };
 }
 const DEFAULT_CONFIG = {
+    // Primary budget controls
+    budgetFraction: 0.703,
+    reserveFraction: 0.25,
+    historyFraction: 0.40,
+    memoryFraction: 0.40,
+    // Absolute fallback
     defaultTokenBudget: 90000,
+    // History internals
     maxHistoryMessages: 250,
-    maxFacts: 28,
-    maxCrossSessionContext: 6000,
-    maxRecentToolPairs: 3,
-    maxProseToolPairs: 10,
     warmHistoryBudgetFraction: 0.4,
     keystoneHistoryFraction: 0.2,
     keystoneMaxMessages: 15,
     keystoneMinSignificance: 0.5,
-    contextWindowReserve: 0.15,
+    // Memory internals
+    maxFacts: 28,
+    maxCrossSessionContext: 6000,
+    // Tool gradient (internal)
+    maxRecentToolPairs: 3,
+    maxProseToolPairs: 10,
+    // Dynamic reserve
     dynamicReserveTurnHorizon: 5,
     dynamicReserveMax: 0.50,
     dynamicReserveEnabled: true,
@@ -784,6 +829,73 @@ export class Compositor {
     async compose(request, db, libraryDb) {
         const store = new MessageStore(db);
         const libDb = libraryDb || this.libraryDb;
+        const toComposeOutputMessages = (inputMessages) => {
+            // When skipProviderTranslation is set, compose returns the neutral window
+            // typed as ProviderMessage[] by contract. The runtime translates later.
+            return request.skipProviderTranslation
+                ? inputMessages
+                : toProviderFormat(inputMessages, request.provider ?? request.model ?? null);
+        };
+        // ── C4: Window cache fast-exit ────────────────────────────
+        // If nothing has changed since the last compose (cursor.lastSentId >= newest
+        // message id in the DB), skip the full pipeline and return the cached window.
+        // Particularly effective for low-frequency sessions (heartbeat agents, council
+        // seats between rounds). TTL on the cache write remains 120s — this is a
+        // conservative early-exit before the TTL expires, not a TTL extension.
+        if (request.includeHistory !== false && request.skipWindowCache !== true) {
+            try {
+                const newestRow = db.prepare('SELECT MAX(id) AS maxId FROM messages WHERE agent_id = ?').get(request.agentId);
+                const newestMsgId = newestRow?.maxId;
+                if (newestMsgId != null) {
+                    const cachedBundle = await this.cache.getFreshWindowBundle(request.agentId, request.sessionKey, newestMsgId);
+                    if (cachedBundle) {
+                        // Validate the cached bundle is compatible with this request.
+                        // A mismatch on any of these means we must do a full compose:
+                        //   - tokenBudget: cached total exceeds the requested cap
+                        //   - slot flags: caller disabled slots that the cache populated
+                        //   - historyDepth: caller wants fewer messages than the cache holds
+                        const cachedTotal = cachedBundle.meta.totalTokens;
+                        const budgetOk = !request.tokenBudget ||
+                            cachedTotal <= request.tokenBudget * 1.05;
+                        const factsOk = request.includeFacts !== false ||
+                            (cachedBundle.meta.slots['facts'] ?? 0) === 0;
+                        const libraryOk = request.includeLibrary !== false ||
+                            (cachedBundle.meta.slots['library'] ?? 0) === 0;
+                        const contextOk = request.includeContext !== false ||
+                            (cachedBundle.meta.slots['context'] ?? 0) === 0;
+                        // historyDepth constrains how many messages the caller wants;
+                        // we can't slice a cached bundle safely, so skip cache.
+                        const depthOk = !request.historyDepth;
+                        if (budgetOk && factsOk && libraryOk && contextOk && depthOk) {
+                            const cachedSlots = {
+                                system: cachedBundle.meta.slots['system'] ?? 0,
+                                identity: cachedBundle.meta.slots['identity'] ?? 0,
+                                history: cachedBundle.meta.slots['history'] ?? 0,
+                                facts: cachedBundle.meta.slots['facts'] ?? 0,
+                                context: cachedBundle.meta.slots['context'] ?? 0,
+                                library: cachedBundle.meta.slots['library'] ?? 0,
+                            };
+                            return {
+                                messages: toComposeOutputMessages(cachedBundle.messages),
+                                tokenCount: cachedBundle.meta.totalTokens,
+                                slots: cachedSlots,
+                                truncated: false,
+                                hasWarnings: cachedBundle.meta.warnings.length > 0,
+                                warnings: cachedBundle.meta.warnings,
+                                diagnostics: {
+                                    ...cachedBundle.meta.diagnostics,
+                                    windowCacheHit: true,
+                                },
+                            };
+                        }
+                        // Incompatible request — fall through to full compose
+                    }
+                }
+            }
+            catch {
+                // Cache fast-exit is best-effort, fall through to full compose
+            }
+        }
         // Dynamic reserve: use a lightweight SQLite sample to estimate avg turn cost
         // BEFORE assembling the full context. This gives us the reserve fraction we
         // need to compute the effective token budget at the start of compose.
@@ -794,8 +906,23 @@ export class Compositor {
             ? store.getRecentMessages(sampleConv.id, 40)
             : [];
         const { reserve: dynamicReserve, avgTurnCost, dynamic: isDynamic, pressureHigh } = computeDynamicReserve(sampleMessages, totalWindow, this.config);
-        const budget = request.tokenBudget || resolveModelBudget(request.model, this.config.defaultTokenBudget, dynamicReserve);
+        const budget = request.tokenBudget || resolveModelBudget(request.model, this.config.defaultTokenBudget, dynamicReserve, this.config.budgetFraction);
         let remaining = budget;
+        // Phase 0 fence enforcement: resolve the compaction fence for this conversation.
+        // All downstream message queries use this as a lower bound to exclude zombie
+        // messages below the fence that should have been compacted.
+        let fenceMessageId;
+        if (sampleConv) {
+            try {
+                ensureCompactionFenceSchema(db);
+                const fence = getCompactionFence(db, sampleConv.id);
+                if (fence)
+                    fenceMessageId = fence.fenceMessageId;
+            }
+            catch {
+                // Fence lookup is best-effort — never fail composition
+            }
+        }
         const warnings = [];
         const slots = {
             system: 0,
@@ -838,7 +965,7 @@ export class Compositor {
         if (remaining > 100 && request.includeLibrary !== false) {
             const fosEnabled = this.config?.enableFOS !== false;
             const modEnabled = this.config?.enableMOD !== false;
-            const outputTier = resolveOutputTier((this.config?.outputProfile ?? this.config?.outputStandard), fosEnabled, modEnabled);
+            const outputTier = resolveOutputTier((this.config?.hyperformProfile ?? this.config?.outputProfile ?? this.config?.outputStandard), fosEnabled, modEnabled);
             const stableOutputParts = [];
             if (outputTier.tier === 'light') {
                 stableOutputParts.push(renderLightFOS().join('\n'));
@@ -882,6 +1009,15 @@ export class Compositor {
         let composedActiveTopicId;
         let composedActiveTopicName;
         if (request.includeHistory !== false) {
+            // Phase 3 (Turn DAG): resolve active context for DAG-native reads.
+            // This is the primary branch-scoping mechanism; fence remains as transitional safety.
+            let activeContext = null;
+            try {
+                activeContext = getActiveContext(db, request.agentId, request.sessionKey);
+            }
+            catch {
+                // Context resolution is best-effort — fall back to fence-based reads
+            }
             // P3.4: Look up the active topic for this session (non-fatal)
             let activeTopicId;
             let activeTopic;
@@ -913,7 +1049,7 @@ export class Compositor {
             // Hoist resolved topic id+name so the window dual-write and wiki injection sections can access them
             composedActiveTopicId = activeTopicId;
             composedActiveTopicName = activeTopic?.name;
-            const rawHistoryMessages = await this.getHistory(request.agentId, request.sessionKey, request.historyDepth || this.config.maxHistoryMessages, store, activeTopicId);
+            const rawHistoryMessages = await this.getHistory(request.agentId, request.sessionKey, request.historyDepth || this.config.maxHistoryMessages, store, activeTopicId, fenceMessageId, activeContext);
             // Deduplicate history by StoredMessage.id (second line of defense after
             // pushHistory() tail-check dedup). Guards against any duplicates that
             // slipped through the warm path — e.g. bootstrap re-runs on existing sessions.
@@ -945,9 +1081,16 @@ export class Compositor {
             const budgetClusters = clusterNeutralMessages(evictedHistory);
             let historyTokens = 0;
             const includedClusters = [];
+            // Pre-allocate history budget. historyFraction is a fraction of the
+            // effective token budget (post-reserve). Falls back to unbounded fill
+            // (remaining) when historyFraction is not set.
+            const historyBudget = this.config.historyFraction != null
+                ? Math.floor(budget * this.config.historyFraction)
+                : remaining;
+            const historyFillCap = Math.min(historyBudget, remaining);
             for (let i = budgetClusters.length - 1; i >= 0; i--) {
                 const cluster = budgetClusters[i];
-                if (historyTokens + cluster.tokenCost > remaining && includedClusters.length > 0) {
+                if (historyTokens + cluster.tokenCost > historyFillCap && includedClusters.length > 0) {
                     const droppedMsgCount = budgetClusters.slice(0, i + 1).reduce((s, c) => s + c.messages.length, 0);
                     warnings.push(`History truncated at cluster ${i + 1}/${budgetClusters.length} (${droppedMsgCount} messages dropped)`);
                     break;
@@ -966,7 +1109,7 @@ export class Compositor {
             let keystoneMessages = [];
             let keystoneTokens = 0;
             if (request.includeKeystones !== false && includedHistory.length >= 30 && keystoneFraction > 0) {
-                const keystoneResult = await this.buildKeystones(db, request.agentId, includedHistory, historyTokens, keystoneFraction, keystoneMaxMsgs, request.prompt, libDb || undefined);
+                const keystoneResult = await this.buildKeystones(db, request.agentId, includedHistory, historyTokens, keystoneFraction, keystoneMaxMsgs, request.prompt, libDb || undefined, fenceMessageId, activeContext);
                 if (keystoneResult) {
                     keystoneMessages = keystoneResult.keystoneMessages;
                     keystoneTokens = keystoneResult.keystoneTokens;
@@ -984,7 +1127,7 @@ export class Compositor {
             let crossTopicTokens = 0;
             if (request.includeKeystones !== false && activeTopic && this.vectorStore) {
                 try {
-                    const rawCrossTopicKeystones = await this.getKeystonesByTopic(request.agentId, request.sessionKey, activeTopic, includedHistory, db, 3);
+                    const rawCrossTopicKeystones = await this.getKeystonesByTopic(request.agentId, request.sessionKey, activeTopic, includedHistory, db, 3, fenceMessageId, activeContext);
                     if (rawCrossTopicKeystones.length > 0) {
                         // Token budget: cap the full cross-topic block at 15% of remaining,
                         // including the header line.
@@ -1059,13 +1202,23 @@ export class Compositor {
                 slots.history = historyTokens;
                 remaining -= historyTokens;
             }
-            // targetBudgetFraction cap: limit total context slots to a fraction of the
-            // effective budget. This gives operators a single knob to make the system
-            // lighter without tuning individual slot fractions.
-            const targetFraction = this.config.targetBudgetFraction ?? 0.65;
-            const contextCap = Math.floor(budget * targetFraction);
-            if (remaining > contextCap) {
-                remaining = contextCap;
+            // Memory budget pool: facts, wiki, semantic recall, cross-session, and
+            // trigger-fired doc chunks all draw from this shared pool via `remaining`.
+            // memoryFraction is a fraction of the effective token budget (post-reserve).
+            // Falls back to targetBudgetFraction cap behavior when memoryFraction is not set.
+            let memoryBudget;
+            if (this.config.memoryFraction != null) {
+                memoryBudget = Math.floor(budget * this.config.memoryFraction);
+                if (remaining > memoryBudget) {
+                    remaining = memoryBudget;
+                }
+            }
+            else {
+                const targetFraction = this.config.targetBudgetFraction ?? 0.65;
+                memoryBudget = Math.floor(budget * targetFraction);
+                if (remaining > memoryBudget) {
+                    remaining = memoryBudget;
+                }
             }
             // T1.3: Ghost message suppression.
             // If the last message in the included history is a warm-seeded user message
@@ -1099,6 +1252,13 @@ export class Compositor {
         // conversation history (after system/identity).
         const contextParts = [];
         let contextTokens = 0;
+        // ── C1: Content fingerprint dedup set ────────────────────
+        // Replaces fragile substring-match dedup across temporal, open-domain,
+        // semantic recall, and cross-session paths. O(1) lookup on a normalized
+        // 120-char prefix catches rephrased duplicates the old 60-char includes()
+        // match missed without needing a hash.
+        const contextFingerprints = new Set();
+        const fingerprintEntries = new Map();
         // ── Compose-level diagnostics tracking vars ──────────────
         let diagTriggerHits = 0;
         let diagTriggerFallbackUsed = false;
@@ -1106,23 +1266,48 @@ export class Compositor {
         let diagSemanticResults = 0;
         let diagDocChunkCollections = 0;
         let diagScopeFiltered = 0;
+        let diagFingerprintDedups = 0;
+        let diagFingerprintCollisions = 0;
         let diagRetrievalMode = 'none';
+        function normalizeFingerprintText(text) {
+            return text.toLowerCase().replace(/\s+/g, ' ').trim();
+        }
+        function contentFingerprint(text) {
+            return normalizeFingerprintText(text).slice(0, 120);
+        }
+        function addFingerprint(text) {
+            const normalized = normalizeFingerprintText(text);
+            const fingerprint = normalized.slice(0, 120);
+            contextFingerprints.add(fingerprint);
+            const entries = fingerprintEntries.get(fingerprint) ?? new Set();
+            entries.add(normalized);
+            fingerprintEntries.set(fingerprint, entries);
+        }
+        function isDuplicate(text) {
+            const normalized = normalizeFingerprintText(text);
+            const fingerprint = normalized.slice(0, 120);
+            if (!contextFingerprints.has(fingerprint))
+                return false;
+            const entries = fingerprintEntries.get(fingerprint);
+            if (entries && !entries.has(normalized))
+                diagFingerprintCollisions += 1;
+            return true;
+        }
         // ── Wiki Page (L4: Library — active topic synthesis) ──────
         // Inject synthesized wiki page for the active topic before general knowledge.
-        // Token budget: capped at 15% of remaining.
+        // Draws from the shared memory budget pool (remaining is pre-capped by memoryBudget).
         if (request.includeLibrary !== false && remaining > 300 && libDb && composedActiveTopicName) {
             const wikiContent = this.buildWikiPageContext(request.agentId, composedActiveTopicName, libDb);
             if (wikiContent) {
                 const tokens = estimateTokens(wikiContent);
-                const cap = Math.floor(remaining * 0.15);
-                if (tokens <= cap) {
+                if (tokens <= remaining) {
                     contextParts.push(wikiContent);
                     contextTokens += tokens;
                     remaining -= tokens;
                     slots.library += tokens;
                 }
-                else {
-                    const truncated = this.truncateToTokens(wikiContent, cap);
+                else if (remaining > 200) {
+                    const truncated = this.truncateToTokens(wikiContent, remaining);
                     const truncTokens = estimateTokens(truncated);
                     contextParts.push(truncated);
                     contextTokens += truncTokens;
@@ -1133,6 +1318,7 @@ export class Compositor {
         }
         // ── Facts (L4: Library) ──────────────────────────────────
         // scope: agent — filtered by agentId via filterByScope after fetch
+        // Draws from the shared memory budget pool (remaining is pre-capped by memoryBudget).
         if (request.includeFacts !== false && remaining > 500) {
             const factsContent = this.buildFactsFromDb(request.agentId, request.sessionKey, libDb || db);
             if (factsContent !== null) {
@@ -1141,21 +1327,27 @@ export class Compositor {
                 diagScopeFiltered += scopeFiltered;
                 if (content) {
                     const tokens = estimateTokens(content);
-                    if (tokens <= remaining * 0.25) { // Cap facts at 25% of remaining (W4: was 0.3)
+                    if (tokens <= remaining) {
                         contextParts.push(`## Active Facts\n${content}`);
                         contextTokens += tokens;
                         remaining -= tokens;
                         slots.facts = tokens;
                     }
-                    else {
-                        // Truncate to budget
-                        const truncated = this.truncateToTokens(content, Math.floor(remaining * 0.25));
+                    else if (remaining > 200) {
+                        const truncated = this.truncateToTokens(content, remaining);
                         const truncTokens = estimateTokens(truncated);
                         contextParts.push(`## Active Facts (truncated)\n${truncated}`);
                         contextTokens += truncTokens;
                         remaining -= truncTokens;
                         slots.facts = truncTokens;
-                        warnings.push('Facts truncated to fit budget');
+                        warnings.push('Facts truncated to fit memory budget');
+                    }
+                    // C1: Fingerprint each fact line so downstream dedup paths can skip duplicates
+                    const factLines = content.split('\n');
+                    for (const line of factLines) {
+                        if (line.startsWith('- [')) {
+                            addFingerprint(line);
+                        }
                     }
                 }
             }
@@ -1173,14 +1365,17 @@ export class Compositor {
                         order: 'DESC',
                     });
                     if (temporalFacts.length > 0) {
-                        // Deduplicate against facts already in context
-                        const existingContent = contextParts.join('\n');
-                        const novel = temporalFacts.filter(f => !existingContent.includes(f.content.slice(0, 60)));
+                        // C1: Use fingerprint dedup instead of fragile substring match
+                        const beforeCount = temporalFacts.length;
+                        const novel = temporalFacts.filter(f => !isDuplicate(f.content));
+                        diagFingerprintDedups += beforeCount - novel.length;
                         if (novel.length > 0) {
                             const temporalBlock = novel
                                 .map(f => {
                                 const ts = new Date(f.occurredAt).toISOString().slice(0, 10);
-                                return `[${ts}] ${f.content}`;
+                                const line = `[${ts}] ${f.content}`;
+                                addFingerprint(f.content);
+                                return line;
                             })
                                 .join('\n');
                             const temporalSection = `## Temporal Context\n${temporalBlock}`;
@@ -1214,11 +1409,16 @@ export class Compositor {
             // questions. Primary fix for LoCoMo open-domain F1 gap (0.133 baseline).
             if (request.includeSemanticRecall !== false && queryText && isOpenDomainQuery(queryText) && db && remaining > 300) {
                 try {
-                    const existingContent = contextParts.join('\n');
-                    const odResults = searchOpenDomain(db, queryText, existingContent, 10);
+                    // searchOpenDomain still does intra-result dedup. Existing-context dedup
+                    // now happens here via fingerprints so we keep one dedup path.
+                    const rawOdResults = searchOpenDomain(db, queryText, '', 10);
+                    const beforeOd = rawOdResults.length;
+                    const odResults = rawOdResults.filter(r => !isDuplicate(r.content));
+                    diagFingerprintDedups += beforeOd - odResults.length;
                     if (odResults.length > 0) {
                         const odBlock = odResults
                             .map(r => {
+                            addFingerprint(r.content);
                             const ts = r.createdAt
                                 ? new Date(r.createdAt).toISOString().slice(0, 10)
                                 : '';
@@ -1314,7 +1514,8 @@ export class Compositor {
                         // Redis lookup is best-effort — fall through to Ollama
                     }
                     const semanticContent = await this.buildSemanticRecall(lastUserMsg, request.agentId, Math.floor(remaining * 0.12), // Cap at 12% of remaining (W4: was 0.15)
-                    libDb || undefined, precomputedEmbedding);
+                    libDb || undefined, precomputedEmbedding, contextFingerprints // C2: skip results already in Active Facts
+                    );
                     if (semanticContent) {
                         const tokens = estimateTokens(semanticContent);
                         contextParts.push(`## Related Memory\n${semanticContent}`);
@@ -1388,14 +1589,19 @@ export class Compositor {
                             const bLen = Math.max(...matchedKeywords.filter(kw => b.toLowerCase().includes(kw.toLowerCase()) || kw.toLowerCase().includes(b.toLowerCase().slice(0, 5))).map(kw => kw.length), 0);
                             return bLen - aLen; // Most specific match first
                         });
+                        // Sanitize FTS5 terms: quote each word, strip internal quotes, add prefix wildcard.
+                        // Matches the pattern used in the keystone history FTS path.
+                        const sanitizeFtsTerm = (w) => `"${w.replace(/"/g, '')}"*`;
                         const ftsTerms = sortedWords.length > 0
-                            ? sortedWords.slice(0, 6).map(w => `${w}*`).join(' OR ')
+                            ? sortedWords.slice(0, 6).map(sanitizeFtsTerm).join(' OR ')
                             : matchedKeywords
                                 .sort((a, b) => b.length - a.length)
                                 .slice(0, 3)
-                                .map(kw => `${kw}*`)
+                                .map(sanitizeFtsTerm)
                                 .join(' OR ');
-                        const ftsKeyword = ftsTerms || lastMsg.split(/\s+/).slice(0, 3).join(' ');
+                        // Fallback uses raw message words — also sanitize to prevent FTS5 syntax errors.
+                        const ftsKeyword = ftsTerms || lastMsg.split(/\s+/).slice(0, 3)
+                            .map(sanitizeFtsTerm).join(' OR ');
                         const chunks = docChunkStore.queryChunks({
                             collection: trigger.collection,
                             agentId: request.agentId,
@@ -1410,6 +1616,10 @@ export class Compositor {
                         for (const chunk of chunks) {
                             if (chunkTokens + chunk.tokenEstimate > maxTokens)
                                 break;
+                            // Skip chunks from files OpenClaw already injects into the system prompt
+                            const chunkBasename = chunk.sourcePath.split('/').pop() || '';
+                            if (OPENCLAW_BOOTSTRAP_FILES.has(chunkBasename))
+                                continue;
                             chunkLines.push(`### ${chunk.sectionPath}\n${chunk.content}`);
                             chunkTokens += chunk.tokenEstimate;
                         }
@@ -1438,7 +1648,8 @@ export class Compositor {
                 // If refactored to run both paths, cap combined semantic budget to avoid double-recall.
                 try {
                     const fallbackContent = await Promise.race([
-                        this.buildSemanticRecall(lastMsg, request.agentId, Math.floor(remaining * 0.10), libDb || undefined),
+                        this.buildSemanticRecall(lastMsg, request.agentId, Math.floor(remaining * 0.10), libDb || undefined, undefined, contextFingerprints // C2: skip results already in Active Facts
+                        ),
                         new Promise((_, reject) => setTimeout(() => reject(new Error('fallback_knn_timeout')), 3000)),
                     ]);
                     if (fallbackContent) {
@@ -1489,7 +1700,8 @@ export class Compositor {
         }
         // ── Cross-Session Context (L2: Messages) ─────────────────
         if (request.includeContext !== false && remaining > 500) {
-            const crossSessionContent = this.buildCrossSessionContext(request.agentId, request.sessionKey, db, libDb);
+            const crossSessionContent = this.buildCrossSessionContext(request.agentId, request.sessionKey, db, libDb, contextFingerprints // C3: skip entries already in facts/semantic recall
+            );
             if (crossSessionContent) {
                 const tokens = estimateTokens(crossSessionContent);
                 const maxContextTokens = Math.min(this.config.maxCrossSessionContext, Math.floor(remaining * 0.2));
@@ -1584,9 +1796,7 @@ export class Compositor {
         // When skipProviderTranslation is set, return NeutralMessages directly.
         // The context engine plugin uses this: the OpenClaw runtime handles its
         // own provider translation, so double-translating corrupts tool calls.
-        const outputMessages = request.skipProviderTranslation
-            ? messages
-            : toProviderFormat(messages, request.provider ?? request.model ?? null);
+        const outputMessages = toComposeOutputMessages(messages);
         // T1.3: Strip warm-replay provenance flags before output.
         // _warmed is an internal tag added by warmSession() to mark messages
         // seeded from SQLite into Redis. It must not leak into provider submissions
@@ -1615,68 +1825,6 @@ export class Compositor {
                 slots.history = (slots.history ?? 0) + delta;
             }
         }
-        // ─── Write Window Cache ─────────────────────────────
-        // Cache the composed message array so the plugin can serve it directly
-        // on the next assemble() call without re-running the full compose pipeline.
-        // Short TTL (120s) — invalidated by afterTurn when new messages arrive.
-        //
-        // VS-1: Dual-write — session-scoped key for backwards compat;
-        // topic-scoped key for per-topic window retrieval when activeTopicId is set.
-        try {
-            await this.cache.setWindow(request.agentId, request.sessionKey, messages, 120);
-        }
-        catch {
-            // Window cache write is best-effort
-        }
-        // VS-1: Topic-scoped window dual-write
-        if (composedActiveTopicId) {
-            try {
-                await this.cache.setTopicWindow(request.agentId, request.sessionKey, composedActiveTopicId, messages, 120);
-            }
-            catch {
-                // Topic window write is best-effort
-            }
-        }
-        // ─── Write Session Cursor ─────────────────────────────────
-        // Record the newest message included in the submission window.
-        // Background indexer uses this to find unprocessed high-signal content.
-        if (request.includeHistory !== false && slots.history > 0) {
-            try {
-                const historyMsgs = messages.filter(m => m.role !== 'system');
-                const lastHistoryMsg = historyMsgs.length > 0 ? historyMsgs[historyMsgs.length - 1] : null;
-                if (lastHistoryMsg) {
-                    const sm = lastHistoryMsg;
-                    if (sm.id != null && sm.messageIndex != null) {
-                        const cursor = {
-                            lastSentId: sm.id,
-                            lastSentIndex: sm.messageIndex,
-                            lastSentAt: new Date().toISOString(),
-                            windowSize: historyMsgs.length,
-                            tokenCount: totalTokens,
-                        };
-                        await this.cache.setCursor(request.agentId, request.sessionKey, cursor);
-                        // Dual-write cursor to SQLite for durability across Redis eviction (P1.3)
-                        try {
-                            db.prepare(`
-                UPDATE conversations
-                SET cursor_last_sent_id = ?,
-                    cursor_last_sent_index = ?,
-                    cursor_last_sent_at = ?,
-                    cursor_window_size = ?,
-                    cursor_token_count = ?
-                WHERE session_key = ?
-              `).run(cursor.lastSentId, cursor.lastSentIndex, cursor.lastSentAt, cursor.windowSize, cursor.tokenCount, request.sessionKey);
-                        }
-                        catch {
-                            // SQLite cursor write is best-effort — don't block compose
-                        }
-                    }
-                }
-            }
-            catch {
-                // Cursor write is best-effort
-            }
-        }
         // ─── Compaction Fence Update ──────────────────────────────
         // Record the oldest message ID that the LLM can see in this compose
         // cycle. Everything below this ID becomes eligible for compaction.
@@ -1746,6 +1894,9 @@ export class Compositor {
             avgTurnCostTokens: avgTurnCost,
             dynamicReserveActive: isDynamic,
             sessionPressureHigh: pressureHigh,
+            fingerprintDedups: diagFingerprintDedups,
+            fingerprintCollisions: diagFingerprintCollisions,
+            windowCacheHit: false,
         };
         if (pressureHigh) {
             warnings.push(`SESSION_PRESSURE_HIGH: avg_turn_cost=${avgTurnCost} tokens, dynamic reserve capped at ${Math.round(dynamicReserve * 100)}%`);
@@ -1753,6 +1904,74 @@ export class Compositor {
         else if (dynamicReserve > 0.40) {
             console.info(`[hypermem:compositor] dynamic_reserve=${Math.round(dynamicReserve * 100)}% avg_turn_cost=${Math.round(avgTurnCost / 1000)}k horizon=${this.config.dynamicReserveTurnHorizon ?? 5}`);
         }
+        const composedAt = new Date().toISOString();
+        // ─── Write Window Cache ─────────────────────────────
+        // Cache the composed message array so the plugin can serve it directly
+        // on the next assemble() call without re-running the full compose pipeline.
+        // Short TTL (120s). External L4 mutations should set skipWindowCache=true.
+        //
+        // VS-1: Dual-write, session-scoped key for backwards compat;
+        // topic-scoped key for per-topic window retrieval when activeTopicId is set.
+        try {
+            await this.cache.setWindow(request.agentId, request.sessionKey, messages, 120);
+            await this.cache.setWindowMeta(request.agentId, request.sessionKey, {
+                slots: slots,
+                totalTokens,
+                warnings,
+                diagnostics,
+                composedAt,
+            }, 120);
+        }
+        catch {
+            // Window cache write is best-effort
+        }
+        if (composedActiveTopicId) {
+            try {
+                await this.cache.setTopicWindow(request.agentId, request.sessionKey, composedActiveTopicId, messages, 120);
+            }
+            catch {
+                // Topic window write is best-effort
+            }
+        }
+        // ─── Write Session Cursor ─────────────────────────────────
+        // Record the newest message included in the submission window.
+        // Background indexer uses this to find unprocessed high-signal content.
+        if (request.includeHistory !== false && slots.history > 0) {
+            try {
+                const historyMsgs = messages.filter(m => m.role !== 'system');
+                const lastHistoryMsg = historyMsgs.length > 0 ? historyMsgs[historyMsgs.length - 1] : null;
+                if (lastHistoryMsg) {
+                    const sm = lastHistoryMsg;
+                    if (sm.id != null && sm.messageIndex != null) {
+                        const cursor = {
+                            lastSentId: sm.id,
+                            lastSentIndex: sm.messageIndex,
+                            lastSentAt: composedAt,
+                            windowSize: historyMsgs.length,
+                            tokenCount: totalTokens,
+                        };
+                        await this.cache.setCursor(request.agentId, request.sessionKey, cursor);
+                        try {
+                            db.prepare(`
+                UPDATE conversations
+                SET cursor_last_sent_id = ?,
+                    cursor_last_sent_index = ?,
+                    cursor_last_sent_at = ?,
+                    cursor_window_size = ?,
+                    cursor_token_count = ?
+                WHERE session_key = ?
+              `).run(cursor.lastSentId, cursor.lastSentIndex, cursor.lastSentAt, cursor.windowSize, cursor.tokenCount, request.sessionKey);
+                        }
+                        catch {
+                            // SQLite cursor write is best-effort, don't block compose
+                        }
+                    }
+                }
+            }
+            catch {
+                // Cursor write is best-effort
+            }
+        }
         console.log(`[hypermem:compose] agent=${request.agentId} triggers=${diagTriggerHits} fallback=${diagTriggerFallbackUsed} facts=${diagFactsIncluded} semantic=${diagSemanticResults} chunks=${diagDocChunkCollections} scopeFiltered=${diagScopeFiltered} mode=${diagRetrievalMode} crossTopicKeystones=${diagCrossTopicKeystones}`);
         return {
             messages: outputMessages,
@@ -1774,6 +1993,27 @@ export class Compositor {
         const conversation = store.getConversation(sessionKey);
         if (!conversation)
             return;
+        // Phase 3 (Turn DAG): resolve active context for DAG-native warm preload.
+        // Uses context.head_message_id to walk only the active branch.
+        let activeContext = null;
+        try {
+            activeContext = getActiveContext(db, agentId, sessionKey);
+        }
+        catch {
+            // Context resolution is best-effort
+        }
+        // Phase 0 fence enforcement: resolve compaction fence for warm bootstrap.
+        // Fence remains as transitional safety — primary scoping is via DAG walk.
+        let warmFenceMessageId;
+        try {
+            ensureCompactionFenceSchema(db);
+            const fence = getCompactionFence(db, conversation.id);
+            if (fence)
+                warmFenceMessageId = fence.fenceMessageId;
+        }
+        catch {
+            // Fence lookup is best-effort
+        }
         // Fetch a generous pool from SQLite, apply gradient transform, then
         // token-budget-cap the warm set. This replaces the old WARM_BOOTSTRAP_CAP
         // message-count constant which was a blunt instrument — 100 messages of
@@ -1781,9 +2021,21 @@ export class Compositor {
         // Warm budget uses the same reserve fraction as compose() so warm history
         // never pre-fills more than compose() would actually allow.
         const reserve = this.config.contextWindowReserve ?? 0.15;
-        const effectiveBudget = resolveModelBudget(opts?.model, this.config.defaultTokenBudget, reserve);
+        const effectiveBudget = resolveModelBudget(opts?.model, this.config.defaultTokenBudget, reserve, this.config.budgetFraction);
         const warmBudget = Math.floor(effectiveBudget * (this.config.warmHistoryBudgetFraction ?? 0.4));
-        const rawHistory = store.getRecentMessages(conversation.id, this.config.maxHistoryMessages);
+        // Phase 3 (Turn DAG): prefer DAG walk from context head for warm preload.
+        // This ensures only active-branch messages enter the warm cache.
+        let rawHistory;
+        if (activeContext?.headMessageId) {
+            rawHistory = store.getHistoryByDAGWalk(activeContext.headMessageId, this.config.maxHistoryMessages);
+            // DAG walk may return empty for legacy data — fall back to fence-scoped query
+            if (rawHistory.length === 0) {
+                rawHistory = store.getRecentMessages(conversation.id, this.config.maxHistoryMessages, warmFenceMessageId);
+            }
+        }
+        else {
+            rawHistory = store.getRecentMessages(conversation.id, this.config.maxHistoryMessages, warmFenceMessageId);
+        }
         const transformedForWarm = applyToolGradient(rawHistory, {
             totalWindowTokens: resolveModelWindow(opts?.model, this.config.defaultTokenBudget),
         });
@@ -1808,6 +2060,10 @@ export class Compositor {
         // compose() calls buildFactsFromDb() and buildCrossSessionContext() directly
         // from SQLite on every turn (~0.3ms each) — faster than a Redis GET round-trip.
         // Caching them here would create stale entries that compose() ignores anyway.
+        // Invalidate the window cache so the next compose rebuilds with the fresh
+        // system/identity slots. Without this, the fast-exit returns a stale bundle
+        // that predates the warm and reports identity=0.
+        await this.cache.invalidateWindow(agentId, sessionKey);
         await this.cache.warmSession(agentId, sessionKey, {
             system: opts?.systemPrompt,
             identity: opts?.identity,
@@ -1829,7 +2085,36 @@ export class Compositor {
         const conversation = store.getConversation(sessionKey);
         if (!conversation)
             return;
-        const rawHistory = store.getRecentMessages(conversation.id, this.config.maxHistoryMessages);
+        // Phase 3 (Turn DAG): resolve active context for DAG-native gradient refresh
+        let activeContext = null;
+        try {
+            activeContext = getActiveContext(db, agentId, sessionKey);
+        }
+        catch {
+            // Context resolution is best-effort
+        }
+        // Phase 0 fence enforcement for gradient refresh (transitional safety)
+        let gradientFenceMessageId;
+        try {
+            ensureCompactionFenceSchema(db);
+            const fence = getCompactionFence(db, conversation.id);
+            if (fence)
+                gradientFenceMessageId = fence.fenceMessageId;
+        }
+        catch {
+            // Fence lookup is best-effort
+        }
+        // Phase 3: prefer DAG walk from context head
+        let rawHistory;
+        if (activeContext?.headMessageId) {
+            rawHistory = store.getHistoryByDAGWalk(activeContext.headMessageId, this.config.maxHistoryMessages);
+            if (rawHistory.length === 0) {
+                rawHistory = store.getRecentMessages(conversation.id, this.config.maxHistoryMessages, gradientFenceMessageId);
+            }
+        }
+        else {
+            rawHistory = store.getRecentMessages(conversation.id, this.config.maxHistoryMessages, gradientFenceMessageId);
+        }
         const transformedHistory = applyToolGradient(rawHistory, {
             totalWindowTokens: tokenBudget && tokenBudget > 0
                 ? Math.max(tokenBudget, Math.floor(tokenBudget / 0.80))
@@ -1890,21 +2175,30 @@ export class Compositor {
      * The Redis path is unaffected — Redis doesn't index by topic, so topic
      * filtering only applies to the SQLite fallback.
      */
-    async getHistory(agentId, sessionKey, limit, store, topicId) {
+    async getHistory(agentId, sessionKey, limit, store, topicId, fenceMessageId, activeContext) {
         // Pass limit through to Redis — this is the correct enforcement point.
         // Previously getHistory() ignored the limit on the Redis path (LRANGE 0 -1),
         // meaning historyDepth in the compose request had no effect on hot sessions.
         const cached = await this.cache.getHistory(agentId, sessionKey, limit);
         if (cached.length > 0)
             return cached;
+        // Phase 3 (Turn DAG): walk from context.head_message_id backward through
+        // parent_id links. This is the primary correctness mechanism — the fence
+        // remains as transitional safety only.
+        if (activeContext?.headMessageId) {
+            const dagMessages = store.getHistoryByDAGWalk(activeContext.headMessageId, limit);
+            if (dagMessages.length > 0)
+                return dagMessages;
+            // DAG walk returned empty (e.g., legacy data without parent chains) — fall through
+        }
         const conversation = store.getConversation(sessionKey);
         if (!conversation)
             return [];
         if (topicId) {
             // P3.4: Option B — active topic messages + legacy NULL messages
-            return store.getRecentMessagesByTopic(conversation.id, topicId, limit);
+            return store.getRecentMessagesByTopic(conversation.id, topicId, limit, fenceMessageId);
         }
-        return store.getRecentMessages(conversation.id, limit);
+        return store.getRecentMessages(conversation.id, limit, fenceMessageId);
     }
     // ─── L4 Library Builders ─────────────────────────────────────
     /**
@@ -2048,10 +2342,15 @@ export class Compositor {
      * @param precomputedEmbedding — optional pre-computed embedding for the query.
      *   When provided, the Ollama call inside VectorStore.search() is skipped.
      */
-    async buildSemanticRecall(userMessage, agentId, maxTokens, libraryDb, precomputedEmbedding) {
+    async buildSemanticRecall(userMessage, agentId, maxTokens, libraryDb, precomputedEmbedding, existingFingerprints // C2: skip results already in Active Facts
+    ) {
         const libDb = libraryDb || this.libraryDb;
         if (!libDb && !this.vectorStore)
             return null;
+        // Inline fingerprint helper (mirrors compose-scope version; C2 dedup only used here)
+        const fpCheck = existingFingerprints
+            ? (text) => existingFingerprints.has(text.toLowerCase().replace(/\s+/g, ' ').trim().slice(0, 120))
+            : () => false;
         // Use hybrid search when library DB is available
         if (libDb) {
             const results = await hybridSearch(libDb, this.vectorStore, userMessage, {
@@ -2108,6 +2407,10 @@ export class Compositor {
                 // (score >= 0.04) for episodes to make it into assembled context.
                 if (result.sourceTable === 'episodes' && result.score < 0.04)
                     continue;
+                // C2: Skip results whose content is already fingerprinted (e.g. in Active Facts)
+                // Dedup count is not tracked separately here — compose-level counter covers the other paths.
+                if (fpCheck(result.content))
+                    continue;
                 const label = this.formatHybridResult(result);
                 const lineTokens = estimateTokens(label);
                 if (tokens + lineTokens > maxTokens)
@@ -2181,7 +2484,11 @@ export class Compositor {
      * Build cross-session context by finding recent activity
      * in other sessions for this agent.
      */
-    buildCrossSessionContext(agentId, currentSessionKey, db, _libraryDb) {
+    // TODO Phase 1: buildCrossSessionContext queries OTHER conversations. Each has its
+    // own compaction fence. Per-conversation fence filtering should be added here so
+    // zombie messages from other sessions don't leak into cross-session context.
+    buildCrossSessionContext(agentId, currentSessionKey, db, _libraryDb, existingFingerprints // C3: skip entries already in facts/semantic recall
+    ) {
         const conversation = db.prepare('SELECT id FROM conversations WHERE session_key = ?').get(currentSessionKey);
         if (!conversation)
             return null;
@@ -2199,11 +2506,18 @@ export class Compositor {
     `).all(agentId, conversation.id);
         if (rows.length === 0)
             return null;
-        const lines = rows.map(r => {
+        const fpCheck = existingFingerprints
+            ? (text) => existingFingerprints.has(text.toLowerCase().replace(/\s+/g, ' ').trim().slice(0, 120))
+            : () => false;
+        const lines = [];
+        for (const r of rows) {
+            // C3: Skip cross-session entries whose content fingerprint already appears in context
+            if (fpCheck(r.text_content))
+                continue;
             const preview = r.text_content.substring(0, 200);
-            return `- [${r.channel_type}/${r.role} @ ${r.created_at}] ${preview}`;
-        });
-        return lines.join('\n');
+            lines.push(`- [${r.channel_type}/${r.role} @ ${r.created_at}] ${preview}`);
+        }
+        return lines.length > 0 ? lines.join('\n') : null;
     }
     // ─── Utilities ───────────────────────────────────────────────
     /**
@@ -2244,7 +2558,7 @@ export class Compositor {
      * Returns null if keystones cannot be injected (no cutoff ID found,
      * no candidates, or all errors).
      */
-    async buildKeystones(db, agentId, includedHistory, historyTokens, keystoneFraction, keystoneMaxMsgs, prompt, libraryDb) {
+    async buildKeystones(db, agentId, includedHistory, historyTokens, keystoneFraction, keystoneMaxMsgs, prompt, libraryDb, fenceMessageId, activeContext) {
         const keystoneBudget = Math.floor(historyTokens * keystoneFraction);
         if (keystoneBudget <= 0)
             return null;
@@ -2300,6 +2614,14 @@ export class Compositor {
                     // Episodes query is best-effort
                 }
             }
+            const fenceClause = fenceMessageId != null ? 'AND m.id >= ?' : '';
+            // Phase 3 (Turn DAG): prefer context_id scoping over conversation_id+fence
+            const contextClause = activeContext ? 'AND m.context_id = ?' : '';
+            const baseParams = [conversationId, cutoffId];
+            if (fenceMessageId != null)
+                baseParams.push(fenceMessageId);
+            if (activeContext)
+                baseParams.push(activeContext.id);
             const baseQuery = `
         SELECT
           m.id,
@@ -2310,6 +2632,8 @@ export class Compositor {
         FROM messages m
         WHERE m.conversation_id = ?
           AND m.id < ?
+          ${fenceClause}
+          ${contextClause}
           AND m.text_content IS NOT NULL
           AND m.is_heartbeat = 0
           AND m.text_content != ''
@@ -2324,6 +2648,12 @@ export class Compositor {
                     .join(' OR ');
                 if (ftsTerms) {
                     try {
+                        const ftsParams = [conversationId, cutoffId];
+                        if (fenceMessageId != null)
+                            ftsParams.push(fenceMessageId);
+                        if (activeContext)
+                            ftsParams.push(activeContext.id);
+                        ftsParams.push(ftsTerms);
                         candidateRows = db.prepare(`
               SELECT
                 m.id,
@@ -2334,6 +2664,8 @@ export class Compositor {
               FROM messages m
               WHERE m.conversation_id = ?
                 AND m.id < ?
+                ${fenceClause}
+                ${contextClause}
                 AND m.text_content IS NOT NULL
                 AND m.is_heartbeat = 0
                 AND m.text_content != ''
@@ -2343,19 +2675,19 @@ export class Compositor {
                   LIMIT 100
                 )
               LIMIT 200
-            `).all(conversationId, cutoffId, ftsTerms);
+            `).all(...ftsParams);
                     }
                     catch {
                         // FTS query may fail on special characters — fall back to base query
-                        candidateRows = db.prepare(baseQuery).all(conversationId, cutoffId);
+                        candidateRows = db.prepare(baseQuery).all(...baseParams);
                     }
                 }
                 else {
-                    candidateRows = db.prepare(baseQuery).all(conversationId, cutoffId);
+                    candidateRows = db.prepare(baseQuery).all(...baseParams);
                 }
             }
             else {
-                candidateRows = db.prepare(baseQuery).all(conversationId, cutoffId);
+                candidateRows = db.prepare(baseQuery).all(...baseParams);
             }
             if (candidateRows.length === 0)
                 return null;
@@ -2437,7 +2769,7 @@ export class Compositor {
      * @param maxKeystones - Max cross-topic keystones to return (default 3)
      * @returns Scored keystones sorted by score DESC, deduplicated by message id
      */
-    async getKeystonesByTopic(agentId, sessionKey, activeTopic, currentMessages, db, maxKeystones = 3) {
+    async getKeystonesByTopic(agentId, sessionKey, activeTopic, currentMessages, db, maxKeystones = 3, fenceMessageId, activeContext) {
         const otherTopics = db.prepare(`
       SELECT id, name
       FROM topics
@@ -2458,6 +2790,14 @@ export class Compositor {
         for (const topic of otherTopics) {
             let topicMessages;
             try {
+                const topicFenceClause = fenceMessageId != null ? 'AND m.id >= ?' : '';
+                // Phase 3 (Turn DAG): constrain cross-topic queries to active context_id
+                const topicContextClause = activeContext ? 'AND m.context_id = ?' : '';
+                const topicParams = [sessionKey, agentId, topic.id];
+                if (fenceMessageId != null)
+                    topicParams.push(fenceMessageId);
+                if (activeContext)
+                    topicParams.push(activeContext.id);
                 topicMessages = db.prepare(`
           SELECT m.id, m.message_index, m.role, m.text_content, m.created_at
           FROM messages m
@@ -2465,12 +2805,14 @@ export class Compositor {
           WHERE c.session_key = ?
             AND c.agent_id = ?
             AND m.topic_id = ?
+            ${topicFenceClause}
+            ${topicContextClause}
             AND m.text_content IS NOT NULL
             AND m.text_content != ''
             AND m.is_heartbeat = 0
           ORDER BY m.message_index DESC
           LIMIT 50
-        `).all(sessionKey, agentId, topic.id);
+        `).all(...topicParams);
             }
             catch {
                 // Corrupt topic data — skip this topic, never throw