cogmem 3.6.2

package/dist/engine/OrphanCleaner.js

@@ -0,0 +1,27 @@
+export class OrphanCleaner {
+    memoryGraph;
+    options;
+    constructor(memoryGraph, options = {}) {
+        this.memoryGraph = memoryGraph;
+        this.options = options;
+    }
+    async run(projectId) {
+        const cutoff = Date.now() - (this.options.orphanAgeMs ?? 72 * 60 * 60 * 1000);
+        const batchSize = this.options.batchSize ?? 200;
+        const candidates = this.memoryGraph.getAllNeurons()
+            .filter((neuron) => neuron.metadata.projectId === projectId)
+            .filter((neuron) => neuron.metadata.status === 'active')
+            .filter((neuron) => (neuron.metadata.createdAt || 0) < cutoff)
+            .filter((neuron) => neuron.metadata.importanceLevel === 'low' || neuron.metadata.importanceLevel === 'normal' || !neuron.metadata.importanceLevel)
+            .filter((neuron) => neuron.metadata.type !== 'semantic_consolidation' && neuron.metadata.type !== 'cross_domain_principle' && neuron.metadata.type !== 'skill')
+            .filter((neuron) => this.degree(neuron.id) === 0)
+            .slice(0, batchSize);
+        for (const neuron of candidates)
+            this.memoryGraph.updateNeuronMetadata(neuron.id, { status: 'suspect' });
+        return { orphansMarked: candidates.length };
+    }
+    degree(neuronId) {
+        return this.memoryGraph.getSynapses(neuronId).length
+            + this.memoryGraph.getAllNeurons().filter((neuron) => neuron.synapses.some((synapse) => synapse.targetId === neuronId)).length;
+    }
+}

package/dist/engine/PipelineMetrics.d.ts

@@ -0,0 +1,32 @@
+import type Database from 'bun:sqlite';
+export interface StepTiming {
+    stepName: string;
+    durationMs: number;
+    completedAt: number;
+}
+export interface NonFatalPipelineEventInput {
+    kind: string;
+    projectId?: string;
+    message?: string;
+    details?: Record<string, unknown>;
+    occurredAt?: number;
+}
+export declare class PipelineMetrics {
+    private readonly db;
+    constructor(db: Database);
+    initSchema(): void;
+    record(runId: string, steps: StepTiming[], totalMs: number, aborted: boolean): void;
+    getPipelineP99(recentN?: number): number;
+    getLastRun(): {
+        completedAt: number;
+        aborted: boolean;
+        totalMs: number;
+    } | undefined;
+    getStepAverages(): Record<string, number>;
+    recordNonFatal(kind: string, input?: Omit<NonFatalPipelineEventInput, 'kind'>): void;
+    getNonFatalCount(kind?: string, options?: {
+        projectId?: string;
+    }): number;
+    cleanup(retentionMs?: number): void;
+}
+//# sourceMappingURL=PipelineMetrics.d.ts.map

package/dist/engine/PipelineMetrics.js

@@ -0,0 +1,126 @@
+export class PipelineMetrics {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initSchema();
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS pipeline_runs (
+        run_id TEXT PRIMARY KEY,
+        total_ms INTEGER NOT NULL,
+        aborted INTEGER NOT NULL CHECK (aborted IN (0, 1)),
+        completed_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS pipeline_step_timings (
+        run_id TEXT NOT NULL,
+        step_name TEXT NOT NULL,
+        duration_ms INTEGER NOT NULL,
+        completed_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_pipeline_runs_completed_at
+        ON pipeline_runs(completed_at DESC);
+
+      CREATE INDEX IF NOT EXISTS idx_pipeline_step_name
+        ON pipeline_step_timings(step_name, completed_at DESC);
+
+      CREATE TABLE IF NOT EXISTS pipeline_nonfatal_events (
+        event_id TEXT PRIMARY KEY,
+        kind TEXT NOT NULL,
+        project_id TEXT,
+        message TEXT,
+        details_json TEXT,
+        occurred_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_pipeline_nonfatal_kind_project
+        ON pipeline_nonfatal_events(kind, project_id, occurred_at DESC);
+    `);
+    }
+    record(runId, steps, totalMs, aborted) {
+        this.db.prepare(`
+      INSERT OR REPLACE INTO pipeline_runs (run_id, total_ms, aborted, completed_at)
+      VALUES (?, ?, ?, ?)
+    `).run(runId, totalMs, aborted ? 1 : 0, Date.now());
+        this.db.prepare(`DELETE FROM pipeline_step_timings WHERE run_id = ?`).run(runId);
+        const insert = this.db.prepare(`
+      INSERT INTO pipeline_step_timings (run_id, step_name, duration_ms, completed_at)
+      VALUES (?, ?, ?, ?)
+    `);
+        for (const step of steps) {
+            insert.run(runId, step.stepName, step.durationMs, step.completedAt);
+        }
+    }
+    getPipelineP99(recentN = 100) {
+        const rows = this.db.prepare(`
+      SELECT total_ms FROM pipeline_runs
+      ORDER BY completed_at DESC
+      LIMIT ?
+    `).all(recentN);
+        if (rows.length === 0)
+            return 0;
+        const values = rows.map((row) => row.total_ms).sort((a, b) => a - b);
+        return values[Math.max(0, Math.ceil(values.length * 0.99) - 1)];
+    }
+    getLastRun() {
+        const row = this.db.prepare(`
+      SELECT completed_at, aborted, total_ms
+      FROM pipeline_runs
+      ORDER BY completed_at DESC
+      LIMIT 1
+    `).get();
+        return row
+            ? { completedAt: row.completed_at, aborted: row.aborted === 1, totalMs: row.total_ms }
+            : undefined;
+    }
+    getStepAverages() {
+        const rows = this.db.prepare(`
+      SELECT step_name, AVG(duration_ms) AS avg_ms
+      FROM pipeline_step_timings
+      GROUP BY step_name
+    `).all();
+        return Object.fromEntries(rows.map((row) => [row.step_name, row.avg_ms]));
+    }
+    recordNonFatal(kind, input = {}) {
+        const occurredAt = input.occurredAt ?? Date.now();
+        const eventId = `${kind}-${occurredAt}-${Math.random().toString(36).slice(2)}`;
+        this.db.prepare(`
+      INSERT INTO pipeline_nonfatal_events (
+        event_id, kind, project_id, message, details_json, occurred_at
+      ) VALUES (?, ?, ?, ?, ?, ?)
+    `).run(eventId, kind, input.projectId || null, input.message || null, input.details ? JSON.stringify(input.details) : null, occurredAt);
+    }
+    getNonFatalCount(kind, options = {}) {
+        const clauses = [];
+        const params = [];
+        if (kind) {
+            clauses.push('kind = ?');
+            params.push(kind);
+        }
+        if (options.projectId) {
+            clauses.push('project_id = ?');
+            params.push(options.projectId);
+        }
+        const where = clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : '';
+        const row = this.db.prepare(`
+      SELECT COUNT(*) AS count
+      FROM pipeline_nonfatal_events
+      ${where}
+    `).get(...params);
+        return Number(row.count);
+    }
+    cleanup(retentionMs = 30 * 24 * 60 * 60 * 1000) {
+        const cutoff = Date.now() - retentionMs;
+        const oldRuns = this.db.prepare(`
+      SELECT run_id FROM pipeline_runs
+      WHERE completed_at < ?
+    `).all(cutoff);
+        const deleteSteps = this.db.prepare(`DELETE FROM pipeline_step_timings WHERE run_id = ?`);
+        for (const run of oldRuns)
+            deleteSteps.run(run.run_id);
+        this.db.prepare(`DELETE FROM pipeline_runs WHERE completed_at < ?`).run(cutoff);
+        this.db.prepare(`DELETE FROM pipeline_nonfatal_events WHERE occurred_at < ?`).run(cutoff);
+    }
+}

package/dist/engine/PrincipleDecayPolicy.d.ts

@@ -0,0 +1,17 @@
+import type { MemoryGraph } from '../core/MemoryGraph.js';
+export interface PrincipleDecayPolicyOptions {
+    staleDaysMs?: number;
+    reinforcementOverlapThreshold?: number;
+}
+export interface PrincipleDecayPolicyResult {
+    reinforced: number;
+    degraded: number;
+    markedStale: number;
+}
+export declare class PrincipleDecayPolicy {
+    private readonly memoryGraph;
+    private readonly options;
+    constructor(memoryGraph: MemoryGraph, options?: PrincipleDecayPolicyOptions);
+    run(projectId: string): Promise<PrincipleDecayPolicyResult>;
+}
+//# sourceMappingURL=PrincipleDecayPolicy.d.ts.map

package/dist/engine/PrincipleDecayPolicy.js

@@ -0,0 +1,64 @@
+export class PrincipleDecayPolicy {
+    memoryGraph;
+    options;
+    constructor(memoryGraph, options = {}) {
+        this.memoryGraph = memoryGraph;
+        this.options = options;
+    }
+    async run(projectId) {
+        const now = Date.now();
+        const staleDaysMs = this.options.staleDaysMs ?? 90 * 24 * 60 * 60 * 1000;
+        const overlapThreshold = this.options.reinforcementOverlapThreshold ?? 0.3;
+        const neurons = this.memoryGraph.getAllNeurons().filter((neuron) => neuron.metadata.projectId === projectId);
+        const principles = neurons.filter((neuron) => neuron.metadata.type === 'cross_domain_principle');
+        const semantics = neurons.filter((neuron) => neuron.metadata.type === 'semantic_consolidation');
+        let reinforced = 0;
+        let degraded = 0;
+        let markedStale = 0;
+        for (const principle of principles) {
+            const principleTopics = sourceTopics(principle);
+            const lastReinforcedAt = principle.metadata.lastReinforcedAt ?? principle.metadata.createdAt ?? 0;
+            const reinforcingSemantic = semantics.find((semantic) => (semantic.metadata.createdAt || 0) > lastReinforcedAt
+                && tagOverlap(principleTopics, semanticTags(semantic)) >= overlapThreshold);
+            if (reinforcingSemantic) {
+                this.memoryGraph.updateNeuronMetadata(principle.id, { lastReinforcedAt: now });
+                principle.metadata.lastReinforcedAt = now;
+                reinforced += 1;
+            }
+            const referencedSources = principle.synapses
+                .filter((synapse) => synapse.type === 'Referenced')
+                .map((synapse) => this.memoryGraph.getNeuron(synapse.targetId))
+                .filter((neuron) => Boolean(neuron))
+                .filter((neuron) => neuron.metadata.type === 'semantic_consolidation');
+            if (referencedSources.length > 0
+                && referencedSources.every((source) => source.metadata.status === 'cold' || source.metadata.status === 'suspect' || source.metadata.status === 'archived')
+                && principle.metadata.status !== 'suspect') {
+                this.memoryGraph.updateNeuronMetadata(principle.id, { status: 'suspect' });
+                principle.metadata.status = 'suspect';
+                markedStale += 1;
+            }
+            // v1.9.4 principles predate lastReinforcedAt; use createdAt so legacy
+            // principles age naturally instead of being permanently exempt.
+            const effectiveLastReinforcedAt = principle.metadata.lastReinforcedAt ?? principle.metadata.createdAt ?? 0;
+            if (principle.metadata.importanceLevel === 'permanent'
+                && effectiveLastReinforcedAt < now - staleDaysMs) {
+                this.memoryGraph.updateNeuronMetadata(principle.id, { importanceLevel: 'important' });
+                principle.metadata.importanceLevel = 'important';
+                degraded += 1;
+            }
+        }
+        return { reinforced, degraded, markedStale };
+    }
+}
+function sourceTopics(neuron) {
+    return (neuron.metadata.tags || []).filter((tag) => tag !== 'cross_domain');
+}
+function semanticTags(neuron) {
+    return Array.from(new Set([...(neuron.metadata.tags || []), neuron.metadata.topicPath].filter((tag) => Boolean(tag))));
+}
+function tagOverlap(left, right) {
+    if (left.length === 0 || right.length === 0)
+        return 0;
+    const rightSet = new Set(right);
+    return left.filter((tag) => rightSet.has(tag)).length / Math.max(left.length, right.length);
+}

package/dist/engine/TopologyCompiler.d.ts

@@ -0,0 +1,25 @@
+import type { Neuron, TimeBucketRecord } from '../types/index.js';
+import type { ConsolidationResult } from './ConsolidationPipeline.js';
+import { TopologyStore } from '../store/TopologyStore.js';
+export declare class TopologyCompiler {
+    private store;
+    constructor(store: TopologyStore);
+    compile(input: {
+        neuron: Neuron;
+        consolidation: ConsolidationResult;
+    }): {
+        timeBuckets: TimeBucketRecord[];
+        branchIds: string[];
+        taskIds: string[];
+        clusterIds: string[];
+    };
+    private attachTimeBuckets;
+    private attachProjectBranches;
+    private attachTaskBranches;
+    private attachEventClusters;
+    private buildBucket;
+    private looksLikeTaskCarrier;
+    private toClusterType;
+    private normalizeKey;
+}
+//# sourceMappingURL=TopologyCompiler.d.ts.map

package/dist/engine/TopologyCompiler.js

@@ -0,0 +1,276 @@
+import { randomUUID } from 'crypto';
+export class TopologyCompiler {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    compile(input) {
+        const { neuron, consolidation } = input;
+        const projectId = neuron.metadata.projectId;
+        const createdAt = neuron.metadata.createdAt;
+        const ref = {
+            neuronId: neuron.id,
+            unitId: consolidation.interactionUnit?.unitId,
+            createdAt
+        };
+        const timeBuckets = this.attachTimeBuckets(createdAt, projectId, ref);
+        const branchIds = projectId ? this.attachProjectBranches(projectId, neuron, consolidation, ref) : [];
+        const taskIds = this.attachTaskBranches(projectId, neuron, consolidation, ref);
+        const clusterIds = this.attachEventClusters(projectId, neuron, consolidation, ref);
+        return { timeBuckets, branchIds, taskIds, clusterIds };
+    }
+    attachTimeBuckets(createdAt, projectId, ref) {
+        const buckets = [
+            this.buildBucket('day', createdAt),
+            this.buildBucket('week', createdAt),
+            this.buildBucket('month', createdAt)
+        ];
+        for (const bucket of buckets) {
+            this.store.upsertTimeBucket(bucket);
+            this.store.attachToTimeBucket(bucket.bucketId, {
+                ...ref,
+                projectId
+            });
+        }
+        return buckets;
+    }
+    attachProjectBranches(projectId, neuron, consolidation, ref) {
+        const createdAt = ref.createdAt;
+        const branchIds = [];
+        const root = this.store.upsertProjectBranch({
+            branchId: `pbranch-${randomUUID()}`,
+            projectId,
+            branchKey: `project:${projectId}`,
+            branchKind: 'project_root',
+            title: projectId,
+            createdAt
+        });
+        this.store.attachToBranch(root.branchId, ref);
+        branchIds.push(root.branchId);
+        if (consolidation.interactionUnit) {
+            const interactionBranch = this.store.upsertProjectBranch({
+                branchId: `pbranch-${randomUUID()}`,
+                projectId,
+                branchKey: `interaction:${consolidation.interactionUnit.unitId}`,
+                branchKind: 'interaction',
+                title: consolidation.interactionUnit.semanticText,
+                createdAt
+            });
+            this.store.linkBranches(root.branchId, interactionBranch.branchId, 'contains', createdAt);
+            this.store.attachToBranch(interactionBranch.branchId, ref);
+            branchIds.push(interactionBranch.branchId);
+        }
+        for (const belief of consolidation.beliefs) {
+            const branch = this.store.upsertProjectBranch({
+                branchId: `pbranch-${randomUUID()}`,
+                projectId,
+                branchKey: `belief:${belief.canonicalKey}`,
+                branchKind: 'belief',
+                title: `${belief.subject} ${belief.predicate}=${belief.objectValue.raw}`,
+                createdAt
+            });
+            this.store.linkBranches(root.branchId, branch.branchId, 'contains', createdAt);
+            this.store.attachToBranch(branch.branchId, {
+                ...ref,
+                beliefId: belief.id
+            });
+            branchIds.push(branch.branchId);
+        }
+        for (const fact of consolidation.compiledFacts) {
+            const branch = this.store.upsertProjectBranch({
+                branchId: `pbranch-${randomUUID()}`,
+                projectId,
+                branchKey: `fact:${fact.subject}:${fact.predicateFamily}:${fact.object || fact.predicateValue || 'unknown'}`,
+                branchKind: 'fact',
+                title: `${fact.subject} ${fact.predicateFamily} ${fact.object || fact.predicateValue || ''}`.trim(),
+                createdAt
+            });
+            this.store.linkBranches(root.branchId, branch.branchId, 'contains', createdAt);
+            this.store.attachToBranch(branch.branchId, {
+                ...ref,
+                factId: fact.factId
+            });
+            branchIds.push(branch.branchId);
+        }
+        for (const event of consolidation.compiledEvents) {
+            const branch = this.store.upsertProjectBranch({
+                branchId: `pbranch-${randomUUID()}`,
+                projectId,
+                branchKey: `event:${event.eventType}:${event.target || event.actor || 'unknown'}`,
+                branchKind: 'event',
+                title: `${event.eventType}:${event.target || event.actor || 'event'}`,
+                createdAt
+            });
+            this.store.linkBranches(root.branchId, branch.branchId, 'contains', createdAt);
+            this.store.attachToBranch(branch.branchId, {
+                ...ref,
+                eventId: event.eventId
+            });
+            branchIds.push(branch.branchId);
+        }
+        if (this.looksLikeTaskCarrier(neuron.content, consolidation.beliefs)) {
+            const taskBranch = this.store.upsertProjectBranch({
+                branchId: `pbranch-${randomUUID()}`,
+                projectId,
+                branchKey: `task:${this.normalizeKey(neuron.content).slice(0, 72)}`,
+                branchKind: 'task',
+                title: neuron.content.slice(0, 96),
+                createdAt
+            });
+            this.store.linkBranches(root.branchId, taskBranch.branchId, 'contains', createdAt);
+            this.store.attachToBranch(taskBranch.branchId, ref);
+            branchIds.push(taskBranch.branchId);
+        }
+        return branchIds;
+    }
+    attachTaskBranches(projectId, neuron, consolidation, ref) {
+        const taskIds = [];
+        const createdAt = ref.createdAt;
+        const taskTitles = new Set();
+        for (const fact of consolidation.compiledFacts) {
+            if (fact.predicateFamily === 'worked_on' && fact.object)
+                taskTitles.add(fact.object);
+            if (fact.predicateFamily === 'has_issue' && fact.object)
+                taskTitles.add(`issue:${fact.object}`);
+        }
+        for (const belief of consolidation.beliefs) {
+            if (belief.predicate.startsWith('workflow.') || belief.predicate.startsWith('decision.')) {
+                taskTitles.add(belief.predicate);
+            }
+        }
+        if (consolidation.interactionUnit?.type === 'proposal') {
+            taskTitles.add(consolidation.interactionUnit.semanticText);
+        }
+        for (const title of taskTitles) {
+            const task = this.store.upsertTaskBranch({
+                taskId: `task-${randomUUID()}`,
+                projectId,
+                taskKey: `${projectId || 'global'}:${this.normalizeKey(title)}`,
+                title,
+                status: 'derived',
+                createdAt
+            });
+            this.store.attachToTask(task.taskId, ref);
+            for (const fact of consolidation.compiledFacts) {
+                this.store.attachToTask(task.taskId, { factId: fact.factId, createdAt });
+            }
+            for (const belief of consolidation.beliefs) {
+                this.store.attachToTask(task.taskId, { beliefId: belief.id, createdAt });
+            }
+            taskIds.push(task.taskId);
+        }
+        return taskIds;
+    }
+    attachEventClusters(projectId, neuron, consolidation, ref) {
+        const clusterIds = [];
+        const createdAt = ref.createdAt;
+        for (const event of consolidation.compiledEvents) {
+            const clusterType = this.toClusterType(event.eventType);
+            const cluster = this.store.upsertEventCluster({
+                clusterId: `cluster-${randomUUID()}`,
+                projectId,
+                clusterKey: `${projectId || 'global'}:${clusterType}:${this.normalizeKey(event.target || event.actor || event.eventType)}`,
+                clusterType,
+                title: event.target || event.actor || event.eventType,
+                createdAt
+            });
+            this.store.attachToEventCluster(cluster.clusterId, {
+                ...ref,
+                eventId: event.eventId
+            });
+            clusterIds.push(cluster.clusterId);
+        }
+        for (const fact of consolidation.compiledFacts) {
+            if (fact.predicateFamily !== 'has_issue' && fact.predicateFamily !== 'worked_on')
+                continue;
+            const clusterType = fact.predicateFamily === 'has_issue' ? 'issue' : 'project';
+            const cluster = this.store.upsertEventCluster({
+                clusterId: `cluster-${randomUUID()}`,
+                projectId,
+                clusterKey: `${projectId || 'global'}:${clusterType}:${this.normalizeKey(fact.object || fact.predicateValue || fact.subject)}`,
+                clusterType,
+                title: fact.object || fact.predicateValue || fact.subject,
+                createdAt
+            });
+            this.store.attachToEventCluster(cluster.clusterId, {
+                ...ref,
+                factId: fact.factId
+            });
+            clusterIds.push(cluster.clusterId);
+        }
+        for (const belief of consolidation.beliefs) {
+            if (!belief.predicate.startsWith('decision.'))
+                continue;
+            const cluster = this.store.upsertEventCluster({
+                clusterId: `cluster-${randomUUID()}`,
+                projectId,
+                clusterKey: `${projectId || 'global'}:fact:${this.normalizeKey(belief.predicate)}`,
+                clusterType: 'fact',
+                title: belief.predicate,
+                createdAt
+            });
+            this.store.attachToEventCluster(cluster.clusterId, {
+                ...ref,
+                beliefId: belief.id
+            });
+            clusterIds.push(cluster.clusterId);
+        }
+        if (clusterIds.length === 0 && this.looksLikeTaskCarrier(neuron.content, consolidation.beliefs)) {
+            const cluster = this.store.upsertEventCluster({
+                clusterId: `cluster-${randomUUID()}`,
+                projectId,
+                clusterKey: `${projectId || 'global'}:generic:${this.normalizeKey(neuron.content).slice(0, 72)}`,
+                clusterType: 'generic',
+                title: neuron.content.slice(0, 96),
+                createdAt
+            });
+            this.store.attachToEventCluster(cluster.clusterId, ref);
+            clusterIds.push(cluster.clusterId);
+        }
+        return clusterIds;
+    }
+    buildBucket(bucketType, timestamp) {
+        const date = new Date(timestamp);
+        let start;
+        let end;
+        let label;
+        if (bucketType === 'day') {
+            start = new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+            end = start + 24 * 60 * 60 * 1000;
+            label = new Date(start).toISOString().slice(0, 10);
+        }
+        else if (bucketType === 'week') {
+            const day = date.getDay();
+            const diff = (day + 6) % 7;
+            start = new Date(date.getFullYear(), date.getMonth(), date.getDate() - diff).getTime();
+            end = start + 7 * 24 * 60 * 60 * 1000;
+            label = `week:${new Date(start).toISOString().slice(0, 10)}`;
+        }
+        else {
+            start = new Date(date.getFullYear(), date.getMonth(), 1).getTime();
+            end = new Date(date.getFullYear(), date.getMonth() + 1, 1).getTime();
+            label = new Date(start).toISOString().slice(0, 7);
+        }
+        return {
+            bucketId: `${bucketType}:${start}`,
+            bucketType,
+            bucketStart: start,
+            bucketEnd: end,
+            label
+        };
+    }
+    looksLikeTaskCarrier(content, beliefs) {
+        return /项目|project|修复|fix|实现|implement|计划|plan|任务|task|workflow|步骤|step/i.test(content)
+            || beliefs.some((belief) => belief.predicate.startsWith('workflow.') || belief.predicate.startsWith('decision.'));
+    }
+    toClusterType(eventType) {
+        if (/approved/i.test(eventType))
+            return 'approval';
+        if (/rejected/i.test(eventType))
+            return 'rejection';
+        return 'generic';
+    }
+    normalizeKey(value) {
+        return value.trim().toLowerCase().replace(/[^\p{L}\p{N}._-]+/gu, '_').replace(/^_+|_+$/g, '');
+    }
+}

package/dist/engine/WorkingMemoryDelta.d.ts

@@ -0,0 +1,23 @@
+import type Database from 'bun:sqlite';
+import type { MemoryGraph } from '../core/MemoryGraph.js';
+export interface WorkingMemoryDeltaRecord {
+    deltaId: string;
+    projectId?: string;
+    neuronId: string;
+    createdAt: number;
+    consumed?: boolean;
+    payload?: unknown;
+}
+export declare class WorkingMemoryDelta {
+    private readonly db;
+    private readonly memoryGraph;
+    constructor(db: Database, memoryGraph: MemoryGraph);
+    initSchema(): void;
+    append(record: WorkingMemoryDeltaRecord): void;
+    markConsumed(deltaId: string): void;
+    cleanup(retentionMs?: number): {
+        deleted: number;
+    };
+    private ensureColumn;
+}
+//# sourceMappingURL=WorkingMemoryDelta.d.ts.map

package/dist/engine/WorkingMemoryDelta.js

@@ -0,0 +1,63 @@
+const DEFAULT_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+export class WorkingMemoryDelta {
+    db;
+    memoryGraph;
+    constructor(db, memoryGraph) {
+        this.db = db;
+        this.memoryGraph = memoryGraph;
+        this.initSchema();
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS working_memory_deltas (
+        delta_id TEXT PRIMARY KEY,
+        project_id TEXT,
+        neuron_id TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        consumed INTEGER NOT NULL DEFAULT 0 CHECK (consumed IN (0, 1)),
+        payload TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_working_memory_deltas_created
+        ON working_memory_deltas(created_at ASC);
+
+      CREATE INDEX IF NOT EXISTS idx_working_memory_deltas_project
+        ON working_memory_deltas(project_id, created_at ASC);
+    `);
+        this.ensureColumn('consumed', 'ALTER TABLE working_memory_deltas ADD COLUMN consumed INTEGER NOT NULL DEFAULT 0 CHECK (consumed IN (0, 1))');
+        this.ensureColumn('payload', 'ALTER TABLE working_memory_deltas ADD COLUMN payload TEXT');
+    }
+    append(record) {
+        this.db.prepare(`
+      INSERT OR REPLACE INTO working_memory_deltas (
+        delta_id, project_id, neuron_id, created_at, consumed, payload
+      ) VALUES (?, ?, ?, ?, ?, ?)
+    `).run(record.deltaId, record.projectId ?? null, record.neuronId, record.createdAt, record.consumed ? 1 : 0, typeof record.payload === 'undefined' ? null : JSON.stringify(record.payload));
+    }
+    markConsumed(deltaId) {
+        this.db.prepare(`UPDATE working_memory_deltas SET consumed = 1 WHERE delta_id = ?`).run(deltaId);
+    }
+    cleanup(retentionMs = DEFAULT_RETENTION_MS) {
+        const cutoff = Date.now() - retentionMs;
+        const rows = this.db.prepare(`
+      SELECT delta_id, neuron_id, consumed
+      FROM working_memory_deltas
+      WHERE created_at < ?
+    `).all(cutoff);
+        const deleteDelta = this.db.prepare(`DELETE FROM working_memory_deltas WHERE delta_id = ?`);
+        let deleted = 0;
+        for (const row of rows) {
+            const neuronExists = Boolean(this.memoryGraph.getNeuron(row.neuron_id));
+            if (!neuronExists && row.consumed !== 1)
+                continue;
+            deleteDelta.run(row.delta_id);
+            deleted += 1;
+        }
+        return { deleted };
+    }
+    ensureColumn(columnName, alterSql) {
+        const columns = this.db.prepare('PRAGMA table_info(working_memory_deltas)').all();
+        if (!columns.some((column) => column.name === columnName))
+            this.db.exec(alterSql);
+    }
+}