cogmem 3.6.2

package/dist/engine/DeepWriteMemoryCompiler.js

@@ -0,0 +1,42 @@
+function truncate(value, maxLength) {
+    return value.length <= maxLength ? value : `${value.slice(0, maxLength)}...`;
+}
+function stripJsonFence(raw) {
+    const trimmed = raw.trim();
+    const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+    return fenced?.[1]?.trim() || trimmed;
+}
+export class DeepWriteMemoryCompiler {
+    generate;
+    constructor(generate) {
+        this.generate = generate;
+    }
+    async compile(input) {
+        const systemPrompt = [
+            'You are the write-time memory compiler for cogmem.',
+            'Return JSON only.',
+            'Do not invent facts.',
+            'Every candidate must include evidence.',
+            'Distinguish explicit user statements from assistant claims and model inference.',
+            'Treat metaphors, emotions, and causal links as interpretations unless directly stated.',
+            'Do not store small talk as long-term memory unless it reveals a durable preference, goal, constraint, relationship, plan, or state.',
+            'Use these top-level arrays when applicable: summary, entities, facts, relations, causalLinks, preferences, emotionalSignals, metaphorInterpretations, contradictions, unresolvedQuestions.',
+            'Each item should include confidence, evidence, source, durability, and risk.'
+        ].join('\n');
+        const userPrompt = truncate(JSON.stringify({
+            projectId: input.projectId,
+            sessionId: input.sessionId,
+            currentExchange: input.currentExchange,
+            recentTurns: input.recentTurns,
+            recalledMemory: input.recalledMemory
+        }, null, 2), 24000);
+        const rawOutput = await this.generate(systemPrompt, userPrompt);
+        const parsed = JSON.parse(stripJsonFence(rawOutput || '{}'));
+        return {
+            output: parsed && typeof parsed === 'object' ? parsed : {},
+            rawOutput,
+            systemPrompt,
+            userPrompt
+        };
+    }
+}

package/dist/engine/DeepWriteMemoryOrchestrator.d.ts

@@ -0,0 +1,60 @@
+import type { DeepWriteConfig } from './DeepWriteConfig.js';
+import { DeepWriteMemoryCompiler, type DeepWriteMemoryCompilerInput, type DeepWriteTurnInput } from './DeepWriteMemoryCompiler.js';
+import { DeepWriteCandidateStore } from '../store/DeepWriteCandidateStore.js';
+import type { DeepWritePromotionPolicy } from './DeepWritePromotionPolicy.js';
+import type { CustomRedactor, DeepWriteRedactor } from './DeepWriteRedactor.js';
+export interface DeepWriteRecallResultLike {
+    compiledMemory?: {
+        facts?: unknown[];
+        beliefs?: unknown[];
+        events?: unknown[];
+        entityTimeline?: unknown[];
+    };
+    rawEvidence?: Array<{
+        id?: string;
+        content?: string;
+        metadata?: {
+            createdAt?: number;
+            tags?: string[];
+        };
+    }>;
+    profileSurface?: {
+        userProfile?: unknown[];
+        agentPersona?: unknown[];
+    };
+}
+export interface DeepWriteMemoryOrchestratorInput {
+    projectId?: string;
+    sessionId?: string;
+    sourceNeuronIds: string[];
+    currentExchange: DeepWriteMemoryCompilerInput['currentExchange'];
+    recentTurns: DeepWriteTurnInput[];
+}
+export interface DeepWriteMemoryOrchestratorDeps {
+    config: DeepWriteConfig;
+    store: DeepWriteCandidateStore;
+    compiler: DeepWriteMemoryCompiler;
+    recall: (query: string, options?: {
+        projectId?: string;
+        limit?: number;
+        includeRawEvidence?: boolean;
+    }) => DeepWriteRecallResultLike;
+    modelProvider?: string;
+    modelName?: string;
+    redactor?: DeepWriteRedactor;
+    customRedactors?: CustomRedactor[];
+    promotionPolicy?: DeepWritePromotionPolicy;
+}
+export declare class DeepWriteMemoryOrchestrator {
+    private readonly deps;
+    constructor(deps: DeepWriteMemoryOrchestratorDeps);
+    run(input: DeepWriteMemoryOrchestratorInput): Promise<{
+        runId?: string;
+        candidateCount: number;
+        skipped: boolean;
+    }>;
+    private flattenCandidates;
+    private buildEvidenceRoleMap;
+    private attachEvidenceRole;
+}
+//# sourceMappingURL=DeepWriteMemoryOrchestrator.d.ts.map

package/dist/engine/DeepWriteMemoryOrchestrator.js

@@ -0,0 +1,175 @@
+import { createHash } from 'crypto';
+const CATEGORY_KEYS = [
+    'summary',
+    'entities',
+    'facts',
+    'relations',
+    'causalLinks',
+    'preferences',
+    'emotionalSignals',
+    'metaphorInterpretations',
+    'contradictions',
+    'unresolvedQuestions'
+];
+function hash(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function toArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function confidenceOf(value) {
+    if (!value || typeof value !== 'object')
+        return 0.5;
+    const confidence = Number(value.confidence);
+    return Number.isFinite(confidence) ? Math.min(1, Math.max(0, confidence)) : 0.5;
+}
+function evidenceOf(value) {
+    if (!value || typeof value !== 'object')
+        return [];
+    return toArray(value.evidence);
+}
+export class DeepWriteMemoryOrchestrator {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async run(input) {
+        if (!this.deps.config.enabled || this.deps.config.mode === 'off') {
+            return { candidateCount: 0, skipped: true };
+        }
+        const recallQuery = [
+            input.currentExchange.userText,
+            input.currentExchange.assistantText || ''
+        ].join('\n').trim();
+        const recalled = this.deps.recall(recallQuery, {
+            projectId: input.projectId,
+            limit: this.deps.config.recallLimit,
+            includeRawEvidence: true
+        });
+        let compilerInput = {
+            projectId: input.projectId,
+            sessionId: input.sessionId,
+            currentExchange: input.currentExchange,
+            recentTurns: input.recentTurns.slice(-this.deps.config.contextTurns),
+            recalledMemory: {
+                facts: recalled.compiledMemory?.facts || [],
+                beliefs: recalled.compiledMemory?.beliefs || [],
+                entities: [
+                    ...(recalled.compiledMemory?.entityTimeline || []),
+                    ...(recalled.profileSurface?.userProfile || []),
+                    ...(recalled.profileSurface?.agentPersona || [])
+                ],
+                rawEvidence: (recalled.rawEvidence || []).map((item) => ({
+                    neuronId: item.id || '',
+                    content: item.content || '',
+                    createdAt: item.metadata?.createdAt || 0,
+                    tags: item.metadata?.tags || []
+                })).filter((item) => item.neuronId && item.content)
+            }
+        };
+        if (this.deps.config.redactionEnabled && this.deps.redactor) {
+            compilerInput = this.deps.redactor.redact(compilerInput).value;
+            for (const redactor of this.deps.customRedactors || []) {
+                compilerInput = redactor.redact(compilerInput).value;
+            }
+        }
+        const promptHash = hash(JSON.stringify(compilerInput));
+        try {
+            const compiled = await this.deps.compiler.compile(compilerInput);
+            const outputHash = hash(compiled.rawOutput || JSON.stringify(compiled.output));
+            const run = this.deps.store.insertRun({
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                sourceNeuronIds: input.sourceNeuronIds,
+                modelProvider: this.deps.modelProvider,
+                modelName: this.deps.modelName,
+                mode: this.deps.config.mode,
+                promptHash,
+                outputHash,
+                status: 'succeeded'
+            });
+            const candidates = this.flattenCandidates(run.runId, compiled.output, compilerInput);
+            const inserted = this.deps.store.insertCandidates(candidates);
+            if (this.deps.config.mode === 'promote_guarded' && this.deps.promotionPolicy) {
+                this.deps.promotionPolicy.promoteRun(run.runId);
+            }
+            return { runId: run.runId, candidateCount: inserted.length, skipped: false };
+        }
+        catch (error) {
+            const run = this.deps.store.insertRun({
+                projectId: input.projectId,
+                sessionId: input.sessionId,
+                sourceNeuronIds: input.sourceNeuronIds,
+                modelProvider: this.deps.modelProvider,
+                modelName: this.deps.modelName,
+                mode: this.deps.config.mode,
+                promptHash,
+                outputHash: hash(''),
+                status: 'failed',
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return { runId: run.runId, candidateCount: 0, skipped: false };
+        }
+    }
+    flattenCandidates(runId, output, compilerInput) {
+        const status = this.deps.config.mode === 'shadow' ? 'shadow' : 'candidate';
+        const candidates = [];
+        const roleByNeuronId = this.buildEvidenceRoleMap(compilerInput);
+        for (const key of CATEGORY_KEYS) {
+            for (const item of toArray(output[key])) {
+                const evidence = evidenceOf(item).map((entry) => this.attachEvidenceRole(entry, roleByNeuronId));
+                if (evidence.length === 0)
+                    continue;
+                candidates.push({
+                    runId,
+                    candidateType: key,
+                    status,
+                    confidence: confidenceOf(item),
+                    content: item,
+                    evidence
+                });
+            }
+        }
+        return candidates;
+    }
+    buildEvidenceRoleMap(input) {
+        const roleByNeuronId = new Map();
+        for (const item of input.recalledMemory.rawEvidence) {
+            const raw = item;
+            if (!raw.neuronId)
+                continue;
+            const tags = raw.tags || [];
+            const role = tags.some((tag) => tag === 'turn_role:user')
+                || /^User:/i.test(raw.content || '')
+                ? 'user'
+                : tags.some((tag) => tag === 'turn_role:assistant') || /^Assistant:/i.test(raw.content || '')
+                    ? 'assistant'
+                    : undefined;
+            if (role)
+                roleByNeuronId.set(raw.neuronId, role);
+        }
+        if (this.deps.config.mode !== 'off') {
+            const userId = input.currentExchange.userTurnId;
+            const assistantId = input.currentExchange.assistantTurnId;
+            if (userId)
+                roleByNeuronId.set(userId, 'user');
+            if (assistantId)
+                roleByNeuronId.set(assistantId, 'assistant');
+        }
+        return roleByNeuronId;
+    }
+    attachEvidenceRole(entry, roleByNeuronId) {
+        if (typeof entry === 'string') {
+            const role = roleByNeuronId.get(entry);
+            return role ? { neuronId: entry, role } : entry;
+        }
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            return entry;
+        const record = entry;
+        const id = ['neuronId', 'neuron_id', 'sourceId', 'sourceNeuronId', 'id']
+            .map((key) => record[key])
+            .find((value) => typeof value === 'string' && value.trim().length > 0);
+        const role = id ? roleByNeuronId.get(id) : undefined;
+        return role && !record.role ? { ...record, role } : record;
+    }
+}

package/dist/engine/DeepWritePromotionPolicy.d.ts

@@ -0,0 +1,48 @@
+import type { BeliefStore } from '../belief/BeliefStore.js';
+import type { FactStore } from '../store/FactStore.js';
+import type { EntityStore } from '../store/EntityStore.js';
+import type { SummaryStore } from '../store/SummaryStore.js';
+import type { GraphEdgeStoreLike } from '../types/ExtensionPoints.js';
+import { DeepWriteCandidateStore, type DeepWriteCandidateRecord } from '../store/DeepWriteCandidateStore.js';
+export type DeepWritePromotionOutcome = 'promote_provisional' | 'promote_verified' | 'needs_confirmation' | 'keep_candidate' | 'reject';
+export interface DeepWritePromotionDecision {
+    outcome: DeepWritePromotionOutcome;
+    reason: string;
+    targetType?: string;
+    targetId?: string;
+}
+export interface DeepWritePromotionPolicyDeps {
+    candidateStore: DeepWriteCandidateStore;
+    factStore?: FactStore;
+    beliefStore?: BeliefStore;
+    entityStore?: EntityStore;
+    summaryStore?: SummaryStore;
+    relationStore?: GraphEdgeStoreLike;
+    minPromoteConfidence: number;
+    promoteCausalLinks?: boolean;
+}
+export interface DeepWritePromotionOptions {
+    projectId?: string;
+}
+export interface DeepWriteEvaluationOptions {
+    reviewConfirmed?: boolean;
+}
+export declare class DeepWritePromotionPolicy {
+    private readonly deps;
+    constructor(deps: DeepWritePromotionPolicyDeps);
+    promoteRun(runId: string): DeepWritePromotionDecision[];
+    promotePending(limit?: number, options?: DeepWritePromotionOptions): DeepWritePromotionDecision[];
+    evaluateAndApply(candidate: DeepWriteCandidateRecord, options?: DeepWriteEvaluationOptions): DeepWritePromotionDecision;
+    private promoteOrganizationCandidate;
+    private promoteFact;
+    private promoteSummary;
+    private promoteRelation;
+    private promoteCausalLink;
+    private promoteGraphEdge;
+    private resolveEntity;
+    private promotePreference;
+    private promoteEntity;
+    private keep;
+    private mark;
+}
+//# sourceMappingURL=DeepWritePromotionPolicy.d.ts.map