@kinqs/brainrouter-mcp-server 0.3.4

package/dist/memory/pipeline/focus-direction-shift.js

@@ -0,0 +1,27 @@
+import { FOCUS_DIRECTION_SHIFT_SYSTEM_PROMPT, formatFocusDirectionShiftPrompt } from "../prompts/focus-direction-shift.js";
+export async function detectFocusShift(params) {
+    const { activeScene, newCognitiveRecords, llmRunner } = params;
+    try {
+        const prompt = formatFocusDirectionShiftPrompt(activeScene.sceneName, activeScene.summaryMd, newCognitiveRecords.map(r => ({ content: r.content, type: r.type })));
+        const response = await llmRunner.run({
+            prompt,
+            systemPrompt: FOCUS_DIRECTION_SHIFT_SYSTEM_PROMPT,
+            taskId: "focus-direction-shift",
+            timeoutMs: 30_000,
+        });
+        const jsonMatch = response.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            throw new Error("No JSON object found in LLM response");
+        }
+        const parsed = JSON.parse(jsonMatch[0]);
+        return {
+            shift: Boolean(parsed.shift),
+            confidence: Number(parsed.confidence) || 0,
+            reason: String(parsed.reason) || "",
+        };
+    }
+    catch (err) {
+        console.error(`[BrainRouter] Focus direction shift detection failed:`, err.message);
+        return { shift: false, confidence: 0, reason: "Error" };
+    }
+}

package/dist/memory/pipeline/graph-builder.d.ts

@@ -0,0 +1,11 @@
+import type { IMemoryStore } from "@kinqs/brainrouter-types";
+import type { LLMRunner, CognitiveRecord } from "@kinqs/brainrouter-types";
+/**
+ * Graph Construction Pipeline
+ * Extracts entities and relationships from Cognitive records to update the Knowledge Graph.
+ */
+export declare function buildGraphFromCognitive(params: {
+    record: CognitiveRecord;
+    store: IMemoryStore;
+    llmRunner: LLMRunner;
+}): Promise<void>;

package/dist/memory/pipeline/graph-builder.js

@@ -0,0 +1,88 @@
+import { GRAPH_EXTRACTION_SYSTEM_PROMPT, formatGraphExtractionPrompt } from "../prompts/graph-extraction.js";
+import crypto from "node:crypto";
+/**
+ * Graph Construction Pipeline
+ * Extracts entities and relationships from Cognitive records to update the Knowledge Graph.
+ */
+export async function buildGraphFromCognitive(params) {
+    const { record, store, llmRunner } = params;
+    // Gate execution with env flag (default is true)
+    if (process.env.BRAINROUTER_GRAPH_ENABLED === "false") {
+        return;
+    }
+    // Skip graph extraction if memory is invalidated
+    if (record.invalidAt)
+        return;
+    const _parsedTimeout = parseInt(process.env.BRAINROUTER_GRAPH_TIMEOUT_MS || "", 10);
+    const timeoutMs = isNaN(_parsedTimeout) ? 120000 : _parsedTimeout;
+    try {
+        const rawExtraction = await llmRunner.run({
+            prompt: formatGraphExtractionPrompt(record.content),
+            systemPrompt: GRAPH_EXTRACTION_SYSTEM_PROMPT,
+            taskId: `graph-extraction-${record.id}`,
+            timeoutMs
+        });
+        const jsonMatch = rawExtraction.match(/\{[\s\S]*\}/);
+        if (!jsonMatch)
+            return;
+        const data = JSON.parse(jsonMatch[0]);
+        if (!data || !Array.isArray(data.entities))
+            return;
+        const entityMap = new Map(); // name -> node.id
+        // 1. Process and upsert nodes
+        for (const ent of data.entities) {
+            const entityName = String(ent.entity || "").trim();
+            const entityType = String(ent.type || "concept").trim();
+            const confidence = typeof ent.confidence === "number" ? ent.confidence : 1.0;
+            if (!entityName)
+                continue;
+            // Check if node already exists to get its ID, otherwise create a new one
+            const existingNode = store.getGraphNodeByEntity(record.userId, entityName);
+            const nodeId = existingNode?.id ?? `gn_${crypto.randomBytes(6).toString("hex")}`;
+            entityMap.set(entityName.toLowerCase(), nodeId);
+            const node = {
+                id: nodeId,
+                userId: record.userId,
+                entity: entityName,
+                entityType,
+                skillTag: record.skillTag || "",
+                confidence,
+                sourceRecordId: record.id,
+                createdTime: record.createdTime || new Date().toISOString()
+            };
+            store.upsertGraphNode(node);
+        }
+        // 2. Process and upsert edges
+        if (Array.isArray(data.relations)) {
+            for (const rel of data.relations) {
+                const fromName = String(rel.from || "").trim();
+                const toName = String(rel.to || "").trim();
+                const relation = String(rel.relation || "relates_to").trim();
+                const confidence = typeof rel.confidence === "number" ? rel.confidence : 1.0;
+                if (!fromName || !toName)
+                    continue;
+                const fromNodeId = entityMap.get(fromName.toLowerCase());
+                const toNodeId = entityMap.get(toName.toLowerCase());
+                if (!fromNodeId || !toNodeId) {
+                    // Skip edges where one endpoint wasn't extracted (LLM mentioned it in relations but not in entities — common with the 5-entity cap)
+                    continue;
+                }
+                const edge = {
+                    id: `ge_${crypto.randomBytes(6).toString("hex")}`,
+                    userId: record.userId,
+                    fromNodeId,
+                    toNodeId,
+                    relation,
+                    skillTag: record.skillTag || "",
+                    confidence,
+                    sourceRecordId: record.id,
+                    createdTime: record.createdTime || new Date().toISOString()
+                };
+                store.upsertGraphEdge(edge);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`[BrainRouter] Graph extraction failed for record ${record.id}:`, err.message);
+    }
+}

package/dist/memory/pipeline/graph-recall.d.ts

@@ -0,0 +1,13 @@
+import type { IMemoryStore } from "@kinqs/brainrouter-types";
+/**
+ * Hybrid GraphRAG Recall Expansion
+ * Finds matching entities in the query and top Cognitive results, performs a 2-hop
+ * BFS traversal, and returns a formatted markdown block of the context.
+ */
+export declare function expandRecallWithGraph(params: {
+    topCognitiveResults: any[];
+    query: string;
+    userId: string;
+    activeSkill?: string;
+    store: IMemoryStore;
+}): string;

package/dist/memory/pipeline/graph-recall.js

@@ -0,0 +1,55 @@
+/**
+ * Hybrid GraphRAG Recall Expansion
+ * Finds matching entities in the query and top Cognitive results, performs a 2-hop
+ * BFS traversal, and returns a formatted markdown block of the context.
+ */
+export function expandRecallWithGraph(params) {
+    const { topCognitiveResults, query, userId, activeSkill, store } = params;
+    try {
+        // 1. Fetch all graph nodes for this user to match entities
+        const allNodes = store.getAllGraphNodes(userId);
+        if (allNodes.length === 0)
+            return "";
+        const combinedText = `${query} ${topCognitiveResults.map(r => r.content || "").join(" ")}`.toLowerCase();
+        // 2. Find which nodes are mentioned in the query or top results
+        const matchingNodeIds = new Set();
+        for (const node of allNodes) {
+            if (combinedText.includes(node.entity.toLowerCase())) {
+                matchingNodeIds.add(node.id);
+            }
+        }
+        if (matchingNodeIds.size === 0)
+            return "";
+        // 3. For each matching node, fetch neighbors up to 2 hops
+        const unionNodes = new Map();
+        const unionEdges = new Map();
+        for (const nodeId of matchingNodeIds) {
+            const { nodes, edges } = store.getGraphNeighbors(userId, nodeId, activeSkill, 2);
+            for (const n of nodes)
+                unionNodes.set(n.id, n);
+            for (const e of edges)
+                unionEdges.set(e.id, e);
+        }
+        if (unionNodes.size === 0)
+            return "";
+        // 4. Format into a beautiful Knowledge Graph Context
+        const nodeLines = Array.from(unionNodes.values()).map(n => `- **${n.entity}** (${n.entityType})`);
+        const edgeLines = Array.from(unionEdges.values()).map(e => {
+            const fromNode = unionNodes.get(e.fromNodeId);
+            const toNode = unionNodes.get(e.toNodeId);
+            if (!fromNode || !toNode)
+                return null;
+            return `- **${fromNode.entity}** --[${e.relation}]--> **${toNode.entity}** (confidence: ${e.confidence.toFixed(2)}${e.skillTag ? `, skill: ${e.skillTag}` : ""})`;
+        }).filter(Boolean);
+        let output = "\n==================================================\n";
+        output += "🕸️ KNOWLEDGE GRAPH CONTEXT (GraphRAG)\n";
+        output += "==================================================\n\n";
+        output += "### Graph Entities:\n" + nodeLines.join("\n") + "\n\n";
+        output += "### Graph Relationships:\n" + edgeLines.join("\n") + "\n";
+        return output;
+    }
+    catch (err) {
+        console.error("[BrainRouter] Graph recall expansion failed:", err.message);
+        return "";
+    }
+}

package/dist/memory/pipeline/identity-distiller.d.ts

@@ -0,0 +1,15 @@
+import type { IMemoryStore } from "@kinqs/brainrouter-types";
+import type { LLMRunner } from "@kinqs/brainrouter-types";
+/**
+ * Core Identity Distillation Pipeline
+ * Scans ALL persona + instruction CognitiveRecords across all sessions
+ * for a user and synthesizes a durable Narrative Profile.
+ */
+export declare function distillCoreIdentity(params: {
+    userId: string;
+    store: IMemoryStore;
+    llmRunner: LLMRunner;
+}): Promise<{
+    success: boolean;
+    personaMd?: string;
+}>;

package/dist/memory/pipeline/identity-distiller.js

@@ -0,0 +1,40 @@
+import { CORE_IDENTITY_SYSTEM_PROMPT, formatCoreIdentityPrompt } from "../prompts/core-identity.js";
+/**
+ * Core Identity Distillation Pipeline
+ * Scans ALL persona + instruction CognitiveRecords across all sessions
+ * for a user and synthesizes a durable Narrative Profile.
+ */
+export async function distillCoreIdentity(params) {
+    const { userId, store, llmRunner } = params;
+    // Cross-session: fetch all persona + instruction cognitives for this user
+    const memories = store.getIdentityAndInstructionCognitives(userId, 100);
+    if (memories.length === 0) {
+        console.error(`[BrainRouter] Core Identity distillation skipped for "${userId}" — no persona/instruction memories yet.`);
+        return { success: false };
+    }
+    let personaMd;
+    try {
+        personaMd = await llmRunner.run({
+            prompt: formatCoreIdentityPrompt(memories),
+            systemPrompt: CORE_IDENTITY_SYSTEM_PROMPT,
+            taskId: "identity-distillation",
+            timeoutMs: 90_000,
+        });
+    }
+    catch (err) {
+        console.error(`[BrainRouter] Core Identity distillation failed for "${userId}":`, err.message);
+        return { success: false };
+    }
+    const now = new Date().toISOString();
+    const existing = store.getCoreIdentity(userId);
+    const record = {
+        userId,
+        personaMd: personaMd.trim(),
+        cognitiveCountAtGeneration: memories.length,
+        createdTime: existing?.createdTime ?? now,
+        updatedTime: now,
+    };
+    store.upsertCoreIdentity(record);
+    console.error(`[BrainRouter] Core Identity updated for "${userId}" (${memories.length} cognitive records).`);
+    return { success: true, personaMd: personaMd.trim() };
+}

package/dist/memory/pipeline/l1-contradiction.d.ts

@@ -0,0 +1,7 @@
+import type { IMemoryStore } from "@brainrouter/types";
+import type { LLMRunner, L1Record } from "@brainrouter/types";
+export declare function detectContradictions(params: {
+    newRecord: L1Record;
+    store: IMemoryStore;
+    llmRunner: LLMRunner;
+}): Promise<void>;

package/dist/memory/pipeline/l1-contradiction.js

@@ -0,0 +1,66 @@
+import { L1_CONTRADICTION_PROMPT } from "../prompts/l1-contradiction.js";
+import crypto from "node:crypto";
+export async function detectContradictions(params) {
+    const { newRecord, store, llmRunner } = params;
+    // 1. Search for potentially related memories
+    // We use keyword search on the content of the new record to find similar existing ones
+    const candidates = store.searchL1Fts(newRecord.userId, newRecord.content, 5);
+    const evaluations = [];
+    const _parsedContradictionTimeout = parseInt(process.env.BRAINROUTER_CONTRADICTION_TIMEOUT_MS || "", 10);
+    const contradictionTimeoutMs = isNaN(_parsedContradictionTimeout) ? 60000 : _parsedContradictionTimeout;
+    for (const candidate of candidates) {
+        // Don't compare with self
+        if (candidate.record_id === newRecord.id)
+            continue;
+        // Only compare if they are of the same type or both are episodic/persona
+        // (instructions don't usually contradict episodic facts)
+        const prompt = L1_CONTRADICTION_PROMPT
+            .replace("{{newContent}}", newRecord.content)
+            .replace("{{existingContent}}", candidate.content);
+        try {
+            const response = await llmRunner.run({
+                prompt,
+                taskId: `contradiction-check-${newRecord.id}-${candidate.record_id}`,
+                timeoutMs: contradictionTimeoutMs
+            });
+            // Simple JSON extraction (flexible for local models)
+            const jsonMatch = response.match(/\{[\s\S]*\}/);
+            if (!jsonMatch)
+                continue;
+            const data = JSON.parse(jsonMatch[0]);
+            if (data.isContradiction && data.confidence > 0.7) {
+                evaluations.push({
+                    candidate,
+                    isContradiction: true,
+                    confidence: data.confidence,
+                    kind: data.kind || "genuine_conflict",
+                    reason: data.reason
+                });
+            }
+        }
+        catch (e) {
+            console.error(`[BrainRouter] Contradiction check failed for ${newRecord.id} vs ${candidate.record_id}:`, e.message);
+        }
+    }
+    // If ANY evaluation is a temporal_update, then the entire batch of contradictions represents a temporal transition!
+    const hasTemporalUpdate = evaluations.some(ev => ev.kind === "temporal_update");
+    for (const ev of evaluations) {
+        if (hasTemporalUpdate) {
+            // Treat all conflicting old records as superseded by the new record
+            console.error(`[BrainRouter] TEMPORAL UPDATE DETECTED (transition): Superseding memory ${ev.candidate.record_id} with new memory ${newRecord.id}`);
+            store.invalidateL1Record(newRecord.userId, ev.candidate.record_id, newRecord.id);
+        }
+        else {
+            // Genuine conflict
+            console.error(`[BrainRouter] CONTRADICTION DETECTED: ${newRecord.id} vs ${ev.candidate.record_id}`);
+            store.upsertContradiction({
+                id: `conflict_${crypto.randomBytes(4).toString("hex")}`,
+                userId: newRecord.userId,
+                recordIdA: ev.candidate.record_id,
+                recordIdB: newRecord.id,
+                reason: ev.reason,
+                confidence: ev.confidence
+            });
+        }
+    }
+}

package/dist/memory/pipeline/l1-dedup.d.ts

@@ -0,0 +1,23 @@
+import type { L1Record } from "@brainrouter/types";
+import type { IMemoryStore } from "@brainrouter/types";
+/**
+ * Result of the deduplication process
+ */
+export interface DedupResult {
+    /** Memories that are unique and should be stored */
+    uniqueRecords: L1Record[];
+    /** Memories that were identified as exact duplicates and dropped */
+    droppedCount: number;
+}
+/**
+ * Proactively deduplicate extracted memories against the existing memory store
+ * before they are stored.
+ *
+ * Uses exact/near-exact string matching to prevent identical noisy facts
+ * from accumulating in the L1 store.
+ */
+export declare function deduplicateMemories(params: {
+    records: L1Record[];
+    store: IMemoryStore;
+    userId: string;
+}): Promise<DedupResult>;

package/dist/memory/pipeline/l1-dedup.js

@@ -0,0 +1,39 @@
+/**
+ * Proactively deduplicate extracted memories against the existing memory store
+ * before they are stored.
+ *
+ * Uses exact/near-exact string matching to prevent identical noisy facts
+ * from accumulating in the L1 store.
+ */
+export async function deduplicateMemories(params) {
+    const { records, store, userId } = params;
+    if (records.length === 0) {
+        return { uniqueRecords: [], droppedCount: 0 };
+    }
+    const uniqueRecords = [];
+    let droppedCount = 0;
+    for (const newRecord of records) {
+        // 1. Keyword search to find potentially identical memories
+        // We only need top 3 to see if there is an exact match
+        const candidates = store.searchL1Fts(userId, newRecord.content, 3);
+        let isDuplicate = false;
+        for (const candidate of candidates) {
+            // Direct string comparison (case-insensitive, trimmed)
+            if (candidate.content.trim().toLowerCase() === newRecord.content.trim().toLowerCase()) {
+                isDuplicate = true;
+                break;
+            }
+        }
+        if (isDuplicate) {
+            console.log(`[BrainRouter] Dropped exact duplicate memory: "${newRecord.content}"`);
+            droppedCount++;
+        }
+        else {
+            uniqueRecords.push(newRecord);
+        }
+    }
+    return {
+        uniqueRecords,
+        droppedCount
+    };
+}

package/dist/memory/pipeline/l1-extractor.d.ts

@@ -0,0 +1,21 @@
+import type { L0Record, L1Record, LLMRunner } from "@brainrouter/types";
+export interface L1ExtractionResult {
+    success: boolean;
+    extractedCount: number;
+    records: L1Record[];
+    sceneNames: string[];
+    errorMessage?: string;
+}
+export declare function extractL1Memories(params: {
+    messages: L0Record[];
+    userId: string;
+    sessionKey: string;
+    sessionId: string;
+    llmRunner: LLMRunner;
+    maxMessagesPerExtraction?: number;
+    maxBackgroundMessages?: number;
+    previousSceneName?: string;
+    existingSceneNames?: string[];
+    activeSkill?: string;
+    skillHints?: string;
+}): Promise<L1ExtractionResult>;

package/dist/memory/pipeline/l1-extractor.js

@@ -0,0 +1,180 @@
+import { EXTRACT_MEMORIES_SYSTEM_PROMPT, formatExtractionPrompt } from "../prompts/l1-extraction.js";
+import { getMemoryTypeConfig } from "../memory-type-config.js";
+import crypto from "node:crypto";
+const ALLOWED_MEMORY_TYPES = new Set([
+    "persona", "episodic", "instruction", "skill_context", "tool_preference",
+    "codebase_fact", "api_contract", "data_model", "dependency_constraint",
+    "environment_constraint", "architecture_decision", "implementation_decision",
+    "design_constraint", "security_policy", "performance_baseline", "bug_finding",
+    "debug_trace", "fix_summary", "verification_result", "failed_attempt",
+    "regression_risk", "task_state", "handover_note", "blocked_reason",
+    "review_comment", "release_note", "source_evidence", "artifact_reference",
+    "file_history", "command_knowledge",
+]);
+const ALLOWED_SOURCE_KINDS = new Set([
+    "", "user_instruction", "source_file", "command_output", "test_result",
+    "model_inference", "prior_memory",
+]);
+const ALLOWED_VERIFICATION_STATUSES = new Set([
+    "", "verified", "unverified", "stale",
+]);
+// Ensure the message has actual words to extract from, not just symbols or single letters.
+function shouldExtractL1(text) {
+    if (!text)
+        return false;
+    const clean = text.trim();
+    if (clean.length < 3)
+        return false;
+    // If it's pure symbols/numbers, ignore
+    if (/^[^a-zA-Z\u4e00-\u9fa5]+$/.test(clean))
+        return false;
+    return true;
+}
+export async function extractL1Memories(params) {
+    const { messages, userId, sessionKey, sessionId, llmRunner, maxMessagesPerExtraction = 10, maxBackgroundMessages = 5, previousSceneName, existingSceneNames, activeSkill, skillHints } = params;
+    if (messages.length === 0) {
+        return { success: true, extractedCount: 0, records: [], sceneNames: [] };
+    }
+    const qualifiedMessages = messages.filter((m) => shouldExtractL1(m.messageText));
+    if (qualifiedMessages.length === 0) {
+        return { success: true, extractedCount: 0, records: [], sceneNames: [] };
+    }
+    const newMessages = qualifiedMessages.slice(-maxMessagesPerExtraction);
+    const bgEndIdx = qualifiedMessages.length - newMessages.length;
+    const backgroundMessages = bgEndIdx > 0
+        ? qualifiedMessages.slice(Math.max(0, bgEndIdx - maxBackgroundMessages), bgEndIdx)
+        : [];
+    const userPrompt = formatExtractionPrompt({
+        newMessages,
+        backgroundMessages,
+        previousSceneName,
+        existingSceneNames,
+        activeSkill,
+        skillHints
+    });
+    let rawResult;
+    try {
+        rawResult = await llmRunner.run({
+            prompt: userPrompt,
+            systemPrompt: EXTRACT_MEMORIES_SYSTEM_PROMPT,
+            taskId: "l1-extraction",
+            timeoutMs: 120_000
+        });
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        console.error("[BrainRouter] LLM extraction failed:", err);
+        return { success: false, extractedCount: 0, records: [], sceneNames: [], errorMessage };
+    }
+    const parsedScenes = parseExtractionResult(rawResult);
+    const records = [];
+    const sceneNames = [];
+    const nowStr = new Date().toISOString();
+    for (const scene of parsedScenes) {
+        sceneNames.push(scene.scene_name);
+        for (const mem of scene.memories) {
+            const config = getMemoryTypeConfig(mem.type);
+            records.push({
+                id: `l1_${sessionKey}_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`,
+                userId,
+                sessionKey,
+                sessionId,
+                content: mem.content,
+                type: mem.type,
+                priority: mem.priority,
+                sceneName: scene.scene_name,
+                skillTag: mem.skill_tag || activeSkill || "",
+                halfLifeDays: config.halfLifeDays,
+                supersededBy: null,
+                timestampStr: "", // Phase 1: Not strictly tracking time from LLM, just raw extraction
+                timestampStart: "",
+                timestampEnd: "",
+                createdTime: nowStr,
+                updatedTime: nowStr,
+                metadata: mem.metadata,
+                confidence: mem.confidence ?? config.defaultConfidence,
+                status: "active",
+                sourceKind: mem.sourceKind,
+                verificationStatus: mem.verificationStatus,
+                repoPaths: mem.repoPaths,
+                filePaths: mem.filePaths,
+                commands: mem.commands,
+                // ACE fields — zero on creation, updated by citation tracking
+                citationCount: 0,
+                lastCitedAt: null,
+                neverCitedCount: 0,
+                archived: false,
+            });
+        }
+    }
+    return {
+        success: true,
+        extractedCount: records.length,
+        records,
+        sceneNames
+    };
+}
+function parseExtractionResult(raw) {
+    try {
+        let cleaned = raw.trim();
+        if (cleaned.startsWith("\`\`\`")) {
+            cleaned = cleaned.replace(/^\`\`\`(?:json)?\s*\n?/, "").replace(/\n?\`\`\`\s*$/, "");
+        }
+        const match = cleaned.match(/\[[\s\S]*\]/);
+        if (!match)
+            return [];
+        const parsed = JSON.parse(match[0]);
+        if (!Array.isArray(parsed))
+            return [];
+        const scenes = [];
+        for (const item of parsed) {
+            if (!item || typeof item !== "object")
+                continue;
+            const s = item;
+            const memories = Array.isArray(s.memories) ? s.memories.map((m) => ({
+                content: String(m.content || ""),
+                type: parseMemoryType(m.type),
+                priority: clampNumber(m.priority, 0, 100, 50),
+                skill_tag: m.skill_tag ? String(m.skill_tag) : undefined,
+                confidence: typeof m.confidence === "number" ? clampNumber(m.confidence, 0, 1, 0.65) : undefined,
+                sourceKind: parseSourceKind(m.sourceKind ?? m.source_kind),
+                verificationStatus: parseVerificationStatus(m.verificationStatus ?? m.verification_status),
+                repoPaths: parseStringArray(m.repoPaths ?? m.repo_paths),
+                filePaths: parseStringArray(m.filePaths ?? m.file_paths),
+                commands: parseStringArray(m.commands),
+                metadata: m.metadata && typeof m.metadata === "object" ? m.metadata : {}
+            })).filter((m) => m.content.length > 0) : [];
+            scenes.push({
+                scene_name: String(s.scene_name || "Unknown Scene"),
+                memories
+            });
+        }
+        return scenes;
+    }
+    catch (err) {
+        console.error("[BrainRouter] Failed to parse extraction result", err);
+        return [];
+    }
+}
+function parseMemoryType(value) {
+    const candidate = String(value || "");
+    return ALLOWED_MEMORY_TYPES.has(candidate) ? candidate : "episodic";
+}
+function parseSourceKind(value) {
+    const candidate = String(value || "");
+    return ALLOWED_SOURCE_KINDS.has(candidate) ? candidate : "model_inference";
+}
+function parseVerificationStatus(value) {
+    const candidate = String(value || "");
+    return ALLOWED_VERIFICATION_STATUSES.has(candidate) ? candidate : "unverified";
+}
+function parseStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.map((item) => String(item).trim()).filter(Boolean))];
+}
+function clampNumber(value, min, max, fallback) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? Math.min(max, Math.max(min, value))
+        : fallback;
+}

package/dist/memory/pipeline/l2-direction-shift.d.ts

@@ -0,0 +1,10 @@
+import type { L1Record, L2SceneRecord, LLMRunner } from "@brainrouter/types";
+export declare function detectDirectionShift(params: {
+    activeScene: L2SceneRecord;
+    newL1Records: L1Record[];
+    llmRunner: LLMRunner;
+}): Promise<{
+    shift: boolean;
+    confidence: number;
+    reason: string;
+}>;

package/dist/memory/pipeline/l2-direction-shift.js

@@ -0,0 +1,27 @@
+import { L2_DIRECTION_SHIFT_SYSTEM_PROMPT, formatL2DirectionShiftPrompt } from "../prompts/l2-direction-shift.js";
+export async function detectDirectionShift(params) {
+    const { activeScene, newL1Records, llmRunner } = params;
+    try {
+        const prompt = formatL2DirectionShiftPrompt(activeScene.sceneName, activeScene.summaryMd, newL1Records.map(r => ({ content: r.content, type: r.type })));
+        const response = await llmRunner.run({
+            prompt,
+            systemPrompt: L2_DIRECTION_SHIFT_SYSTEM_PROMPT,
+            taskId: "l2-direction-shift",
+            timeoutMs: 30_000,
+        });
+        const jsonMatch = response.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            throw new Error("No JSON object found in LLM response");
+        }
+        const parsed = JSON.parse(jsonMatch[0]);
+        return {
+            shift: Boolean(parsed.shift),
+            confidence: Number(parsed.confidence) || 0,
+            reason: String(parsed.reason) || "",
+        };
+    }
+    catch (err) {
+        console.error(`[BrainRouter] L2 direction shift detection failed:`, err.message);
+        return { shift: false, confidence: 0, reason: "Error" };
+    }
+}

package/dist/memory/pipeline/l2-scene.d.ts

@@ -0,0 +1,15 @@
+import type { IMemoryStore } from "@brainrouter/types";
+import type { LLMRunner } from "@brainrouter/types";
+/**
+ * L2 Scene Pipeline
+ * Groups L1 memories by scene_name and asks the LLM to produce
+ * a Markdown summary for each scene. Updates heat scores.
+ */
+export declare function distillScenes(params: {
+    userId: string;
+    store: IMemoryStore;
+    llmRunner: LLMRunner;
+}): Promise<{
+    scenesDistilled: number;
+    sceneNames: string[];
+}>;