@kinqs/brainrouter-mcp-server 0.3.5 → 0.3.6

package/dist/memory/store/relevance-judge.d.ts

@@ -0,0 +1,51 @@
+import type { RelevanceJudgeServiceConfig, RelevanceVerdict } from "@kinqs/brainrouter-types";
+export interface JudgeCandidate {
+    /** Stable id used for logging — typically the memory's record_id. */
+    id: string;
+    /** Memory content the judge will read. */
+    content: string;
+}
+export interface JudgeResult {
+    /** Verdicts in the order returned by the judge. */
+    verdicts: RelevanceVerdict[];
+    /** Indices the judge approved as relevant. */
+    approvedIndices: number[];
+}
+/**
+ * LLM-as-judge stage that approves or rejects retrieved memories based on
+ * actual semantic relevance to the user query — sits between the reranker and
+ * context formatting, dropping candidates that share keywords but aren't
+ * genuinely about the query subject.
+ *
+ * Failure mode is "skip the gate": if the call errors out, callers fall back
+ * to the unfiltered reranker output. We never want a flaky judge call to
+ * crash a recall.
+ */
+export declare class RelevanceJudgeService {
+    private readonly enabled;
+    private readonly endpoint;
+    private readonly apiKey;
+    private readonly model;
+    private readonly maxCandidates;
+    private readonly timeoutMs;
+    private readonly ready;
+    constructor(config: RelevanceJudgeServiceConfig);
+    isReady(): boolean;
+    getMaxCandidates(): number;
+    /**
+     * Grade a batch of candidates against the query. Returns verdicts and the
+     * subset of indices approved as relevant. Throws on transport/parsing
+     * failure — callers are expected to fall back to pre-judge results.
+     */
+    judge(params: {
+        query: string;
+        candidates: JudgeCandidate[];
+    }): Promise<JudgeResult>;
+    /**
+     * Defensive JSON parse — strips code fences, picks the first valid JSON
+     * object/array, and tolerates either {"verdicts":[…]} or a bare array.
+     * Returns one verdict per candidate; missing entries default to "rejected"
+     * so a malformed response can't silently approve everything.
+     */
+    private parseVerdicts;
+}

package/dist/memory/store/relevance-judge.js

@@ -0,0 +1,196 @@
+import { fetchWithExternalRetry } from "../retry.js";
+import { acquireLLMSlot } from "../llm-semaphore.js";
+/**
+ * LLM-as-judge stage that approves or rejects retrieved memories based on
+ * actual semantic relevance to the user query — sits between the reranker and
+ * context formatting, dropping candidates that share keywords but aren't
+ * genuinely about the query subject.
+ *
+ * Failure mode is "skip the gate": if the call errors out, callers fall back
+ * to the unfiltered reranker output. We never want a flaky judge call to
+ * crash a recall.
+ */
+export class RelevanceJudgeService {
+    enabled;
+    endpoint;
+    apiKey;
+    model;
+    maxCandidates;
+    timeoutMs;
+    ready;
+    constructor(config) {
+        this.enabled = config.enabled ?? false;
+        this.endpoint = config.endpoint ?? "https://api.openai.com/v1/chat/completions";
+        this.apiKey = config.apiKey ?? "";
+        this.model = config.model ?? "gpt-4o-mini";
+        this.maxCandidates = Math.max(1, config.maxCandidates ?? 10);
+        this.timeoutMs = Math.max(1000, config.timeoutMs ?? 15_000);
+        this.ready = this.enabled && !!this.apiKey;
+        if (this.enabled && !this.apiKey) {
+            console.error("[BrainRouter] Relevance judge enabled but no API key set. Stage 4 judging will be skipped.");
+        }
+    }
+    isReady() {
+        return this.ready;
+    }
+    getMaxCandidates() {
+        return this.maxCandidates;
+    }
+    /**
+     * Grade a batch of candidates against the query. Returns verdicts and the
+     * subset of indices approved as relevant. Throws on transport/parsing
+     * failure — callers are expected to fall back to pre-judge results.
+     */
+    async judge(params) {
+        if (!this.ready) {
+            throw new Error("RelevanceJudgeService is not ready (disabled or missing API key)");
+        }
+        if (params.candidates.length === 0) {
+            return { verdicts: [], approvedIndices: [] };
+        }
+        const candidates = params.candidates.slice(0, this.maxCandidates);
+        const safeQuery = params.query.length > 800 ? params.query.slice(0, 800) + "…" : params.query;
+        const candidateBlock = candidates
+            .map((c, i) => {
+            const text = c.content.length > 600 ? c.content.slice(0, 600) + "…" : c.content;
+            return `[${i}] ${text.replace(/\s+/g, " ").trim()}`;
+        })
+            .join("\n");
+        const systemPrompt = [
+            "You are a strict relevance judge for a memory retrieval system.",
+            "For each candidate memory, decide whether it is actually relevant to the user's query.",
+            "A memory is RELEVANT only if it provides information that directly helps answer, contextualize, or inform the query.",
+            "It is NOT relevant if it merely shares keywords, is about a different subject, or is generic background.",
+            "When in doubt, reject — false positives pollute the agent's context window.",
+            "Respond with strict JSON only, no prose.",
+        ].join(" ");
+        const userPrompt = [
+            `Query: ${safeQuery}`,
+            "",
+            "Candidates:",
+            candidateBlock,
+            "",
+            "Respond with exactly this JSON shape:",
+            `{"verdicts":[{"index":0,"relevant":true,"reason":"…"}, …]}`,
+            "Include one verdict per candidate. Keep each reason under 120 chars.",
+        ].join("\n");
+        const doFetch = () => fetchWithExternalRetry(this.endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${this.apiKey}`,
+            },
+            // Deliberately omitting `response_format` — OpenAI accepts
+            // `{type:"json_object"}`, but LM Studio / llama.cpp-style backends
+            // reject anything except `json_schema` or `text` with a 400, and
+            // Ollama / vLLM each have their own quirks. The system prompt is
+            // explicit about strict-JSON output and the parser below strips
+            // code fences + tolerates surrounding prose, so dropping the hint
+            // is cheaper than per-provider branching.
+            body: JSON.stringify({
+                model: this.model,
+                messages: [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: userPrompt },
+                ],
+                temperature: 0,
+            }),
+            signal: AbortSignal.timeout(this.timeoutMs),
+        }, {
+            label: "Relevance Judge API",
+        });
+        const release = await acquireLLMSlot();
+        let raw;
+        try {
+            let res = await doFetch();
+            // LM Studio quirk: idle models auto-unload and the first call after
+            // unload returns 400 with "Model is unloaded" / "No models loaded".
+            // The backend then loads the model in the background, so a retry
+            // ~1.5s later usually succeeds. Mirrors ModelLLMRunner in engine.ts.
+            if (res.status === 400) {
+                const errorBody = await res.text();
+                if (/model\s+(is\s+)?unloaded|model\s+not\s+loaded|no\s+models?\s+loaded/i.test(errorBody)) {
+                    await new Promise((resolve) => setTimeout(resolve, 1500));
+                    res = await doFetch();
+                    if (!res.ok) {
+                        const retryBody = await res.text().catch(() => "(no body)");
+                        throw new Error(`Relevance Judge API failed after LM Studio reload retry: HTTP ${res.status} ${res.statusText} - ${retryBody}`);
+                    }
+                }
+                else {
+                    throw new Error(`Relevance Judge API failed: HTTP ${res.status} ${res.statusText} - ${errorBody}`);
+                }
+            }
+            else if (!res.ok) {
+                const err = await res.text().catch(() => "(no body)");
+                throw new Error(`Relevance Judge API failed: HTTP ${res.status} ${res.statusText} - ${err}`);
+            }
+            const data = await res.json();
+            if (data?.error) {
+                const errMsg = typeof data.error === "string" ? data.error : (data.error.message ?? JSON.stringify(data.error).slice(0, 400));
+                throw new Error(`Relevance Judge endpoint returned an error envelope: ${errMsg}`);
+            }
+            const choice = data?.choices?.[0];
+            const content = choice?.message?.content ?? choice?.delta?.content;
+            if (typeof content !== "string") {
+                throw new Error(`Relevance Judge returned no usable content. Response: ${JSON.stringify(data).slice(0, 400)}`);
+            }
+            raw = content;
+        }
+        finally {
+            release();
+        }
+        const parsed = this.parseVerdicts(raw, candidates.length);
+        const approvedIndices = [];
+        for (const v of parsed) {
+            if (v.relevant && v.index >= 0 && v.index < candidates.length) {
+                approvedIndices.push(v.index);
+            }
+        }
+        return { verdicts: parsed, approvedIndices };
+    }
+    /**
+     * Defensive JSON parse — strips code fences, picks the first valid JSON
+     * object/array, and tolerates either {"verdicts":[…]} or a bare array.
+     * Returns one verdict per candidate; missing entries default to "rejected"
+     * so a malformed response can't silently approve everything.
+     */
+    parseVerdicts(raw, candidateCount) {
+        let text = raw.trim();
+        text = text.replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/i, "").trim();
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            const objMatch = text.match(/\{[\s\S]*\}/);
+            const arrMatch = text.match(/\[[\s\S]*\]/);
+            const candidate = objMatch?.[0] ?? arrMatch?.[0];
+            if (!candidate) {
+                throw new Error(`Relevance Judge produced non-JSON output: ${text.slice(0, 200)}`);
+            }
+            parsed = JSON.parse(candidate);
+        }
+        const list = Array.isArray(parsed)
+            ? parsed
+            : Array.isArray(parsed?.verdicts) ? parsed.verdicts : [];
+        const byIndex = new Map();
+        for (const item of list) {
+            if (!item || typeof item !== "object")
+                continue;
+            const index = Number(item.index);
+            if (!Number.isFinite(index))
+                continue;
+            byIndex.set(index, {
+                index,
+                relevant: Boolean(item.relevant),
+                reason: typeof item.reason === "string" ? item.reason.slice(0, 200) : "",
+            });
+        }
+        const out = [];
+        for (let i = 0; i < candidateCount; i++) {
+            out.push(byIndex.get(i) ?? { index: i, relevant: false, reason: "no verdict returned" });
+        }
+        return out;
+    }
+}

package/dist/memory/working/canvas.js

@@ -24,6 +24,17 @@ export function buildAnnotatedCanvas(steps, activeNodeId) {
     for (let index = 1; index < steps.length; index += 1) {
         lines.push(`  ${steps[index - 1].nodeId} --> ${steps[index].nodeId}`);
     }
+    // Reasoning steps ("Why: …" decisions emitted via memory_working_offload
+    // with kind:"reasoning") get a dashed border so the audit trail is
+    // visually separable from tool_output and compressed_summary nodes when
+    // a human (or the dashboard) inspects canvas.mmd. Emitted before the
+    // active-node fill so the active highlight overrides the dashed style
+    // when the same node happens to be both.
+    for (const step of steps) {
+        if (step.kind === "reasoning") {
+            lines.push(`  style ${step.nodeId} stroke-dasharray:4 4,stroke:#9f7aea,stroke-width:2px`);
+        }
+    }
     if (activeNodeId && steps.some((step) => step.nodeId === activeNodeId)) {
         lines.push(`  style ${activeNodeId} fill:#2b6cb0,stroke:#3182ce,stroke-width:2px,color:#fff`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kinqs/brainrouter-mcp-server",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "BrainRouter MCP server — the cognitive memory engine. Exposes recall, capture, focus scenes, persona, contradictions, skills, and graph queries as MCP tools for any MCP-speaking agent.",
   "type": "module",
   "main": "dist/index.js",
@@ -45,7 +45,7 @@
     "gray-matter": "^4.0.3",
     "sqlite-vec": "^0.1.9",
     "zod": "^3.22.4",
-    "@kinqs/brainrouter-types": "^0.3.5"
+    "@kinqs/brainrouter-types": "^0.3.6"
   },
   "engines": {
     "node": ">=22.0.0"

package/dist/memory/config.d.ts

@@ -1,2 +0,0 @@
-export type BrainRouterLlmMode = "server" | "agent";
-export declare function getBrainRouterLlmMode(): BrainRouterLlmMode;

package/dist/memory/config.js

@@ -1,3 +0,0 @@
-export function getBrainRouterLlmMode() {
-    return process.env.BRAINROUTER_LLM_MODE === "agent" ? "agent" : "server";
-}

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

@@ -1,7 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,39 +0,0 @@
-/**
- * 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

@@ -1,21 +0,0 @@
-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

@@ -1,180 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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" };
-    }
-}