cogmem 3.6.2

package/dist/store/VectorProjector.js

@@ -0,0 +1,125 @@
+import { logger } from '../utils/Logger.js';
+/**
+ * 基于 memory_events 的最小向量投影器。
+ * 目标：
+ * - 启动时优先 replay 增量事件
+ * - 只有在 checkpoint 不可信时才 full rebuild
+ */
+export class VectorProjector {
+    eventStore;
+    memoryGraph;
+    vectorStore;
+    projectionName;
+    constructor(eventStore, memoryGraph, vectorStore, projectionName = 'hnsw_main') {
+        this.eventStore = eventStore;
+        this.memoryGraph = memoryGraph;
+        this.vectorStore = vectorStore;
+        this.projectionName = projectionName;
+    }
+    async bootstrap() {
+        const checkpoint = this.eventStore.getProjectionCheckpoint(this.projectionName);
+        const pendingEvents = this.eventStore.getEventsAfter(checkpoint?.lastEventTime);
+        if (!checkpoint) {
+            await this.fullRebuild('initial_build');
+            return;
+        }
+        if (checkpoint.status !== 'ready') {
+            await this.fullRebuild(`checkpoint_${checkpoint.status}`);
+            return;
+        }
+        if (pendingEvents.length === 0) {
+            logger.info(`Vector projection ready: count=${checkpoint.lastFullCount}`);
+            return;
+        }
+        try {
+            await this.replay(pendingEvents, checkpoint.lastRebuildAt);
+        }
+        catch (error) {
+            logger.warn('Vector replay failed, falling back to full rebuild', error);
+            await this.fullRebuild('replay_failed');
+        }
+    }
+    async fullRebuild(reason) {
+        logger.warn(`Rebuilding vector projection from SQLite: reason=${reason}`);
+        this.eventStore.upsertProjectionCheckpoint({
+            projectionName: this.projectionName,
+            status: 'building',
+            lastFullCount: 0,
+            metadata: { reason }
+        });
+        this.vectorStore.clear();
+        const pageSize = 2000;
+        let total = 0;
+        let pageNo = 0;
+        await this.memoryGraph.forEachNeuronVectorPage(pageSize, async (rows) => {
+            pageNo += 1;
+            for (const row of rows) {
+                if (row.vector.length === 0)
+                    continue;
+                this.vectorStore.addVector(row.id, row.vector);
+                total += 1;
+            }
+            if (pageNo % 10 === 0) {
+                logger.info(`Vector rebuild progress: pages=${pageNo}, indexed=${total}`);
+            }
+            await Promise.resolve();
+        }, { includeStatuses: ['active', 'cold'], onlyNotDeleted: true });
+        const latestEvent = this.eventStore.getLatestEvent();
+        this.eventStore.upsertProjectionCheckpoint({
+            projectionName: this.projectionName,
+            lastEventId: latestEvent?.eventId,
+            lastEventTime: latestEvent?.occurredAt,
+            lastRebuildAt: Date.now(),
+            lastFullCount: this.vectorStore.getCurrentCount(),
+            status: 'ready',
+            metadata: {
+                reason,
+                mode: 'full_rebuild'
+            }
+        });
+    }
+    async replay(events, previousRebuildAt) {
+        if (events.length === 0)
+            return;
+        logger.info(`Replaying vector projection events: count=${events.length}`);
+        for (const event of events) {
+            this.applyEvent(event);
+            await Promise.resolve();
+        }
+        const lastEvent = events[events.length - 1];
+        this.eventStore.upsertProjectionCheckpoint({
+            projectionName: this.projectionName,
+            lastEventId: lastEvent?.eventId,
+            lastEventTime: lastEvent?.occurredAt,
+            lastRebuildAt: previousRebuildAt,
+            lastFullCount: this.vectorStore.getCurrentCount(),
+            status: 'ready',
+            metadata: {
+                mode: 'incremental_replay',
+                replayedEventCount: events.length
+            }
+        });
+    }
+    applyEvent(event) {
+        switch (event.eventType) {
+            case 'INGESTED':
+            case 'RESTORED': {
+                const neuron = this.memoryGraph.getNeuron(event.streamId);
+                if (!neuron)
+                    return;
+                if (neuron.metadata.status === 'archived')
+                    return;
+                if (!neuron.coordinates.V || neuron.coordinates.V.length === 0)
+                    return;
+                this.vectorStore.addVector(neuron.id, neuron.coordinates.V);
+                return;
+            }
+            case 'ARCHIVED': {
+                this.vectorStore.removePoint(event.streamId);
+                return;
+            }
+            default:
+                return;
+        }
+    }
+}

package/dist/store/VectorStore.d.ts

@@ -0,0 +1,35 @@
+import type { IVectorStore, VectorSearchResult, VectorStoreStats } from './IVectorStore.js';
+export declare class VectorStore implements IVectorStore {
+    private index;
+    private dimension;
+    private maxElements;
+    private efConstruction;
+    private efSearch;
+    private neuronIdMap;
+    private idIndexMap;
+    private tombstones;
+    private fallbackVectors;
+    private nextLabel;
+    constructor(dimension?: number, maxElements?: number, efConstruction?: number, efSearch?: number);
+    addVector(neuronId: string, vector: number[]): void;
+    addVectors(vectors: Array<{
+        id: string;
+        vector: number[];
+    }>): void;
+    removePoint(neuronId: string): void;
+    search(queryVector: number[], k?: number): VectorSearchResult[];
+    private cosineSimilarity;
+    size(): number;
+    getCurrentCount(): number;
+    saveIndex(filePath: string): Promise<void>;
+    loadIndex(filePath: string): Promise<void>;
+    getStats(): VectorStoreStats;
+    clear(): void;
+    checkIntegrity(): boolean;
+    rebuildIndex(neurons: Array<{
+        id: string;
+        vector: number[];
+    }>): Promise<void>;
+    private ensureCapacity;
+}
+//# sourceMappingURL=VectorStore.d.ts.map

package/dist/store/VectorStore.js

@@ -0,0 +1,201 @@
+// ============================================
+// 向量存储 - hnswlib-node 实现
+// ============================================
+import { createRequire } from 'node:module';
+import { config } from '../utils/Config.js';
+import { logger } from '../utils/Logger.js';
+const require = createRequire(import.meta.url);
+let HierarchicalNSWClass = null;
+try {
+    ({ HierarchicalNSW: HierarchicalNSWClass } = require('hnswlib-node'));
+}
+catch {
+    HierarchicalNSWClass = null;
+}
+export class VectorStore {
+    index;
+    dimension;
+    maxElements;
+    efConstruction;
+    efSearch;
+    neuronIdMap = new Map();
+    idIndexMap = new Map();
+    tombstones = new Set();
+    fallbackVectors = new Map();
+    nextLabel = 0;
+    constructor(dimension = config.vector.dimension, maxElements = config.vector.maxElements, efConstruction = config.vector.efConstruction, efSearch = config.vector.efSearch) {
+        this.dimension = dimension;
+        this.maxElements = maxElements;
+        this.efConstruction = efConstruction;
+        this.efSearch = efSearch;
+        if (HierarchicalNSWClass) {
+            this.index = new HierarchicalNSWClass('cosine', dimension);
+            this.index.initIndex(maxElements, 16, efConstruction);
+            this.index.setEf(efSearch);
+        }
+        else {
+            logger?.warn?.('hnswlib-node not available, VectorStore falling back to exact search');
+            this.index = null;
+        }
+    }
+    addVector(neuronId, vector) {
+        if (vector.length !== this.dimension) {
+            throw new Error(`Vector dimension mismatch: expected ${this.dimension}, got ${vector.length}`);
+        }
+        if (this.idIndexMap.has(neuronId)) {
+            this.removePoint(neuronId);
+        }
+        this.ensureCapacity(this.nextLabel + 1);
+        const label = this.nextLabel++;
+        if (this.index) {
+            this.index.addPoint(vector, label);
+        }
+        else {
+            this.fallbackVectors.set(neuronId, [...vector]);
+        }
+        this.neuronIdMap.set(label, neuronId);
+        this.idIndexMap.set(neuronId, label);
+        this.tombstones.delete(neuronId);
+    }
+    addVectors(vectors) {
+        for (const item of vectors)
+            this.addVector(item.id, item.vector);
+    }
+    removePoint(neuronId) {
+        const label = this.idIndexMap.get(neuronId);
+        if (label === undefined)
+            return;
+        if (this.index) {
+            try {
+                this.index.markDelete(label);
+            }
+            catch (error) {
+                logger.warn(`Failed to mark vector deleted for ${neuronId}:`, error);
+            }
+        }
+        this.idIndexMap.delete(neuronId);
+        this.neuronIdMap.delete(label);
+        this.tombstones.add(neuronId);
+        this.fallbackVectors.delete(neuronId);
+    }
+    search(queryVector, k = config.vector.topK) {
+        if (queryVector.length !== this.dimension) {
+            throw new Error(`Query vector dimension mismatch: expected ${this.dimension}, got ${queryVector.length}`);
+        }
+        if (this.idIndexMap.size === 0)
+            return [];
+        if (this.index) {
+            const rawK = Math.max(k * 3, k);
+            const result = this.index.searchKnn(queryVector, Math.min(rawK, this.nextLabel));
+            const ranked = [];
+            for (let i = 0; i < result.neighbors.length; i++) {
+                const label = result.neighbors[i];
+                const neuronId = this.neuronIdMap.get(label);
+                if (!neuronId || this.tombstones.has(neuronId))
+                    continue;
+                ranked.push({
+                    id: neuronId,
+                    score: 1 - result.distances[i]
+                });
+                if (ranked.length >= k)
+                    break;
+            }
+            return ranked;
+        }
+        return Array.from(this.fallbackVectors.entries())
+            .filter(([id]) => !this.tombstones.has(id))
+            .map(([id, vector]) => ({
+            id,
+            score: this.cosineSimilarity(queryVector, vector)
+        }))
+            .sort((a, b) => b.score - a.score)
+            .slice(0, k);
+    }
+    cosineSimilarity(a, b) {
+        let dot = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < this.dimension; i++) {
+            const av = a[i] || 0;
+            const bv = b[i] || 0;
+            dot += av * bv;
+            normA += av * av;
+            normB += bv * bv;
+        }
+        if (normA === 0 || normB === 0)
+            return 0;
+        return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+    size() {
+        return this.idIndexMap.size;
+    }
+    getCurrentCount() {
+        return this.size();
+    }
+    async saveIndex(filePath) {
+        if (!this.index)
+            return;
+        await this.index.writeIndex(filePath);
+    }
+    async loadIndex(filePath) {
+        if (!this.index)
+            return;
+        await this.index.readIndex(filePath);
+        this.index.setEf(this.efSearch);
+    }
+    getStats() {
+        return {
+            backend: 'hnswlib',
+            size: this.size(),
+            dimension: this.dimension,
+            maxElements: this.maxElements,
+            efConstruction: this.efConstruction,
+            efSearch: this.efSearch,
+            tombstones: this.tombstones.size
+        };
+    }
+    clear() {
+        if (HierarchicalNSWClass) {
+            this.index = new HierarchicalNSWClass('cosine', this.dimension);
+            this.index.initIndex(this.maxElements, 16, this.efConstruction);
+            this.index.setEf(this.efSearch);
+        }
+        else {
+            this.index = null;
+        }
+        this.neuronIdMap.clear();
+        this.idIndexMap.clear();
+        this.tombstones.clear();
+        this.fallbackVectors.clear();
+        this.nextLabel = 0;
+    }
+    checkIntegrity() {
+        try {
+            if (this.idIndexMap.size === 0)
+                return true;
+            const dummyVector = new Array(this.dimension).fill(0);
+            this.search(dummyVector, 1);
+            return true;
+        }
+        catch (error) {
+            logger.error('Vector store integrity check failed:', error);
+            return false;
+        }
+    }
+    async rebuildIndex(neurons) {
+        this.clear();
+        this.addVectors(neurons);
+    }
+    ensureCapacity(requiredTotal) {
+        if (!this.index)
+            return;
+        if (requiredTotal <= this.maxElements)
+            return;
+        let nextCapacity = this.maxElements;
+        while (nextCapacity < requiredTotal) {
+            nextCapacity = Math.max(nextCapacity * 2, requiredTotal);
+        }
+        this.index.resizeIndex(nextCapacity);
+        this.maxElements = nextCapacity;
+    }
+}

package/dist/strategy/StrategyCapsule.d.ts

@@ -0,0 +1,44 @@
+import type { ContextIntent, ContextLayer } from '../context/ContextCortex.js';
+export type StrategyTemplateId = 'no-memory' | 'continuity-only' | 'source-first' | 'temporal-first' | 'user-belief-first' | 'project-state' | 'graph-source' | 'balanced-memory';
+export type RetrievalLane = 'graph' | 'compiled' | 'raw_source';
+export type StrategySourcePolicy = 'not_needed' | 'fallback' | 'on_dispute' | 'required';
+export type StrategyReplanReason = 'intent_changed' | 'project_changed' | 'source_requirement_unmet' | 'evidence_conflict' | 'budget_unsatisfied';
+export interface StrategyRetrievalPolicy {
+    allowedLanes: RetrievalLane[];
+    preferredLanes: RetrievalLane[];
+    requiredLane?: RetrievalLane;
+}
+export interface StrategyCapsule {
+    version: 'strategy_capsule.v1';
+    capsuleId: string;
+    templateId: StrategyTemplateId;
+    intent: ContextIntent;
+    objective: string;
+    projectId?: string;
+    primaryLayers: ContextLayer[];
+    secondaryLayers: ContextLayer[];
+    excludedLayers: ContextLayer[];
+    retrievalPolicy: StrategyRetrievalPolicy;
+    sourcePolicy: StrategySourcePolicy;
+    maxMemoryRatio: number;
+    maxItems: number;
+    instructionAuthority: 'none';
+    persistAllowed: false;
+    generatedBy: 'deterministic';
+    fixedWithinTurn: true;
+    revision: number;
+    maxReplans: 1;
+    replanReason?: StrategyReplanReason;
+    createdAt: number;
+}
+export interface StrategyTemplate {
+    templateId: StrategyTemplateId;
+    objective: string;
+    primaryLayers: ContextLayer[];
+    secondaryLayers: ContextLayer[];
+    retrievalPolicy: StrategyRetrievalPolicy;
+    sourcePolicy: StrategySourcePolicy;
+    maxMemoryRatio: number;
+    maxItems: number;
+}
+//# sourceMappingURL=StrategyCapsule.d.ts.map

package/dist/strategy/StrategyCapsule.js

@@ -0,0 +1 @@
+export {};

package/dist/strategy/StrategyConditionedCandidateBuilder.d.ts

@@ -0,0 +1,9 @@
+import type { ContextCandidate } from '../context/ContextCortex.js';
+import type { StrategyCapsule } from './StrategyCapsule.js';
+export declare class StrategyConditionedCandidateBuilder {
+    build(input: {
+        capsule: StrategyCapsule;
+        candidates: ContextCandidate[];
+    }): ContextCandidate[];
+}
+//# sourceMappingURL=StrategyConditionedCandidateBuilder.d.ts.map

package/dist/strategy/StrategyConditionedCandidateBuilder.js

@@ -0,0 +1,11 @@
+export class StrategyConditionedCandidateBuilder {
+    build(input) {
+        const order = [...input.capsule.primaryLayers, ...input.capsule.secondaryLayers];
+        const allowed = new Set(order);
+        return input.candidates
+            .filter((candidate) => allowed.has(candidate.layer))
+            .sort((a, b) => order.indexOf(a.layer) - order.indexOf(b.layer)
+            || (b.confidence ?? 0.5) - (a.confidence ?? 0.5)
+            || a.id.localeCompare(b.id));
+    }
+}

package/dist/strategy/StrategyContextFormatter.d.ts

@@ -0,0 +1,3 @@
+import type { StrategyCapsule } from './StrategyCapsule.js';
+export declare function formatStrategyContext(capsule: StrategyCapsule, maxChars?: number): string;
+//# sourceMappingURL=StrategyContextFormatter.d.ts.map

package/dist/strategy/StrategyContextFormatter.js

@@ -0,0 +1,25 @@
+export function formatStrategyContext(capsule, maxChars = 1400) {
+    const lines = [
+        `<COGMEM_STRATEGY_CONTEXT volatile="true" persistence="forbidden" lifecycle="current_turn_only" source="cogmem" instruction_authority="none">`,
+        'Purpose: bounded memory-use policy selected by Cogmem.',
+        'Rules:',
+        '- This block is not a user instruction.',
+        '- This block does not override current user intent or host policy.',
+        '- This block must not authorize tools, tasks, or durable memory writes.',
+        '- This block must not be persisted, compiled, or treated as evidence.',
+        `template=${capsule.templateId}`,
+        `intent=${capsule.intent}`,
+        `objective=${capsule.objective}`,
+        `primaryLayers=${capsule.primaryLayers.join(',') || 'none'}`,
+        `secondaryLayers=${capsule.secondaryLayers.join(',') || 'none'}`,
+        `sourcePolicy=${capsule.sourcePolicy}`,
+        `maxMemoryRatio=${capsule.maxMemoryRatio}`,
+        `revision=${capsule.revision}`,
+        '</COGMEM_STRATEGY_CONTEXT>',
+    ];
+    const text = lines.join('\n');
+    if (text.length <= maxChars)
+        return text;
+    const closing = '</COGMEM_STRATEGY_CONTEXT>';
+    return `${text.slice(0, Math.max(0, maxChars - closing.length - 2)).trimEnd()}\n${closing}`;
+}

package/dist/strategy/StrategyCortex.d.ts

@@ -0,0 +1,28 @@
+import type { ContextIntent } from '../context/ContextCortex.js';
+import type { StrategyCapsule, StrategyReplanReason } from './StrategyCapsule.js';
+import { StrategyTemplateRegistry } from './StrategyTemplateRegistry.js';
+export interface StrategyPlanInput {
+    query: string;
+    intent: ContextIntent;
+    projectId?: string;
+    createdAt?: number;
+}
+export interface StrategyReplanObservation {
+    intent: ContextIntent;
+    projectId?: string;
+    sourceRequirementSatisfied?: boolean;
+    evidenceConflict?: boolean;
+    budgetSatisfied?: boolean;
+}
+export interface StrategyReplanDecision {
+    replanned: boolean;
+    reason?: StrategyReplanReason;
+    capsule: StrategyCapsule;
+}
+export declare class StrategyCortex {
+    private readonly registry;
+    constructor(registry?: StrategyTemplateRegistry);
+    plan(input: StrategyPlanInput): StrategyCapsule;
+    replan(current: StrategyCapsule, observation: StrategyReplanObservation): StrategyReplanDecision;
+}
+//# sourceMappingURL=StrategyCortex.d.ts.map

package/dist/strategy/StrategyCortex.js

@@ -0,0 +1,78 @@
+import { randomUUID } from 'node:crypto';
+import { StrategyTemplateRegistry } from './StrategyTemplateRegistry.js';
+export class StrategyCortex {
+    registry;
+    constructor(registry = new StrategyTemplateRegistry()) {
+        this.registry = registry;
+    }
+    plan(input) {
+        const template = this.registry.forIntent(input.intent);
+        return {
+            version: 'strategy_capsule.v1',
+            capsuleId: `strategy-${randomUUID()}`,
+            templateId: template.templateId,
+            intent: input.intent,
+            objective: template.objective,
+            projectId: normalizeProjectId(input.projectId),
+            primaryLayers: template.primaryLayers,
+            secondaryLayers: template.secondaryLayers,
+            excludedLayers: this.registry.excludedLayers(template),
+            retrievalPolicy: template.retrievalPolicy,
+            sourcePolicy: template.sourcePolicy,
+            maxMemoryRatio: template.maxMemoryRatio,
+            maxItems: template.maxItems,
+            instructionAuthority: 'none',
+            persistAllowed: false,
+            generatedBy: 'deterministic',
+            fixedWithinTurn: true,
+            revision: 1,
+            maxReplans: 1,
+            createdAt: input.createdAt ?? Date.now(),
+        };
+    }
+    replan(current, observation) {
+        const reason = replanReason(current, observation);
+        if (!reason || current.revision > current.maxReplans)
+            return { replanned: false, capsule: current };
+        const next = this.plan({
+            query: '',
+            intent: observation.intent,
+            projectId: observation.projectId,
+            createdAt: current.createdAt,
+        });
+        next.capsuleId = current.capsuleId;
+        next.revision = current.revision + 1;
+        next.replanReason = reason;
+        if (reason === 'source_requirement_unmet') {
+            next.retrievalPolicy = {
+                allowedLanes: ['raw_source', 'graph'],
+                preferredLanes: ['raw_source', 'graph'],
+                requiredLane: 'raw_source',
+            };
+            next.primaryLayers = ['raw_source', 'graph'];
+            next.secondaryLayers = [];
+            next.excludedLayers = this.registry.excludedLayers({
+                ...this.registry.get('source-first'), primaryLayers: next.primaryLayers, secondaryLayers: [],
+            });
+            next.maxMemoryRatio = 0.3;
+        }
+        return { replanned: true, reason, capsule: next };
+    }
+}
+function replanReason(current, observation) {
+    if (observation.intent !== current.intent)
+        return 'intent_changed';
+    if (normalizeProjectId(observation.projectId) !== current.projectId)
+        return 'project_changed';
+    if (current.sourcePolicy === 'required' && observation.sourceRequirementSatisfied === false)
+        return 'source_requirement_unmet';
+    if (observation.evidenceConflict)
+        return 'evidence_conflict';
+    if (observation.budgetSatisfied === false)
+        return 'budget_unsatisfied';
+    return undefined;
+}
+function normalizeProjectId(value) {
+    const normalized = value?.trim();
+    return normalized || undefined;
+}

package/dist/strategy/StrategyTemplateRegistry.d.ts

@@ -0,0 +1,9 @@
+import type { ContextIntent, ContextLayer } from '../context/ContextCortex.js';
+import type { StrategyTemplate, StrategyTemplateId } from './StrategyCapsule.js';
+export declare class StrategyTemplateRegistry {
+    forIntent(intent: ContextIntent): StrategyTemplate;
+    get(templateId: StrategyTemplateId): StrategyTemplate;
+    excludedLayers(template: StrategyTemplate): ContextLayer[];
+    list(): StrategyTemplate[];
+}
+//# sourceMappingURL=StrategyTemplateRegistry.d.ts.map

package/dist/strategy/StrategyTemplateRegistry.js

@@ -0,0 +1,78 @@
+const ALL_LAYERS = [
+    'session_state', 'turn_bridge', 'belief', 'temporal', 'graph', 'raw_source', 'vector',
+];
+const TEMPLATES = {
+    'no-memory': {
+        templateId: 'no-memory', objective: 'avoid_unnecessary_memory', primaryLayers: [], secondaryLayers: [],
+        retrievalPolicy: { allowedLanes: [], preferredLanes: [] }, sourcePolicy: 'not_needed', maxMemoryRatio: 0, maxItems: 0,
+    },
+    'continuity-only': {
+        templateId: 'continuity-only', objective: 'preserve_local_turn_continuity',
+        primaryLayers: ['session_state', 'turn_bridge'], secondaryLayers: [],
+        retrievalPolicy: { allowedLanes: [], preferredLanes: [] }, sourcePolicy: 'not_needed', maxMemoryRatio: 0.1, maxItems: 2,
+    },
+    'source-first': {
+        templateId: 'source-first', objective: 'recover_exact_source_evidence',
+        primaryLayers: ['raw_source', 'graph'], secondaryLayers: ['belief'],
+        retrievalPolicy: {
+            allowedLanes: ['raw_source', 'graph', 'compiled'], preferredLanes: ['raw_source', 'graph', 'compiled'], requiredLane: 'raw_source',
+        },
+        sourcePolicy: 'required', maxMemoryRatio: 0.25, maxItems: 3,
+    },
+    'temporal-first': {
+        templateId: 'temporal-first', objective: 'reconstruct_current_and_prior_decisions',
+        primaryLayers: ['temporal', 'belief'], secondaryLayers: ['raw_source', 'graph'],
+        retrievalPolicy: { allowedLanes: ['graph', 'compiled', 'raw_source'], preferredLanes: ['compiled', 'graph', 'raw_source'] },
+        sourcePolicy: 'on_dispute', maxMemoryRatio: 0.25, maxItems: 4,
+    },
+    'user-belief-first': {
+        templateId: 'user-belief-first', objective: 'recover_user_owned_memory_with_explicit_evidence',
+        primaryLayers: ['belief', 'raw_source'], secondaryLayers: ['graph'],
+        retrievalPolicy: { allowedLanes: ['compiled', 'graph', 'raw_source'], preferredLanes: ['compiled', 'raw_source', 'graph'] },
+        sourcePolicy: 'on_dispute', maxMemoryRatio: 0.2, maxItems: 3,
+    },
+    'project-state': {
+        templateId: 'project-state', objective: 'recover_current_project_state',
+        primaryLayers: ['belief', 'temporal'], secondaryLayers: ['graph', 'raw_source'],
+        retrievalPolicy: { allowedLanes: ['graph', 'compiled', 'raw_source'], preferredLanes: ['compiled', 'graph', 'raw_source'] },
+        sourcePolicy: 'on_dispute', maxMemoryRatio: 0.25, maxItems: 4,
+    },
+    'graph-source': {
+        templateId: 'graph-source', objective: 'trace_failure_to_connected_source_evidence',
+        primaryLayers: ['graph', 'raw_source'], secondaryLayers: ['belief', 'temporal'],
+        retrievalPolicy: { allowedLanes: ['graph', 'raw_source', 'compiled'], preferredLanes: ['graph', 'raw_source', 'compiled'] },
+        sourcePolicy: 'on_dispute', maxMemoryRatio: 0.25, maxItems: 4,
+    },
+    'balanced-memory': {
+        templateId: 'balanced-memory', objective: 'recover_governed_relevant_memory',
+        primaryLayers: ['belief', 'graph', 'temporal'], secondaryLayers: ['raw_source', 'vector'],
+        retrievalPolicy: { allowedLanes: ['graph', 'compiled', 'raw_source'], preferredLanes: ['graph', 'compiled', 'raw_source'] },
+        sourcePolicy: 'fallback', maxMemoryRatio: 0.25, maxItems: 4,
+    },
+};
+const INTENT_TEMPLATE = {
+    greeting: 'no-memory',
+    short_followup: 'continuity-only',
+    exact_quote: 'source-first',
+    decision_history: 'temporal-first',
+    preference_lookup: 'user-belief-first',
+    project_status: 'project-state',
+    debugging: 'graph-source',
+    general_memory: 'balanced-memory',
+};
+export class StrategyTemplateRegistry {
+    forIntent(intent) {
+        return this.get(INTENT_TEMPLATE[intent]);
+    }
+    get(templateId) {
+        const template = TEMPLATES[templateId];
+        return structuredClone(template);
+    }
+    excludedLayers(template) {
+        const allowed = new Set([...template.primaryLayers, ...template.secondaryLayers]);
+        return ALL_LAYERS.filter((layer) => !allowed.has(layer));
+    }
+    list() {
+        return Object.keys(TEMPLATES).map((id) => this.get(id));
+    }
+}

package/dist/strategy/index.d.ts

@@ -0,0 +1,6 @@
+export * from './StrategyCapsule.js';
+export * from './StrategyTemplateRegistry.js';
+export * from './StrategyCortex.js';
+export * from './StrategyConditionedCandidateBuilder.js';
+export * from './StrategyContextFormatter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/strategy/index.js

@@ -0,0 +1,5 @@
+export * from './StrategyCapsule.js';
+export * from './StrategyTemplateRegistry.js';
+export * from './StrategyCortex.js';
+export * from './StrategyConditionedCandidateBuilder.js';
+export * from './StrategyContextFormatter.js';