@jack200714/mafw 4.5.1

package/gateway/dist/memory/service.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryService = void 0;
+const path = __importStar(require("path"));
+const config_1 = require("../config");
+const harmonic_index_1 = require("../core/memory/harmonic-index");
+const cognitive_graph_1 = require("../core/memory/cognitive-graph");
+const l5_store_1 = require("../core/memory/l5-store");
+const store_1 = require("../core/memory/store");
+const injector_1 = require("../core/memory/injector");
+const memory_injector_1 = require("../interceptors/memory-injector");
+class MemoryService {
+    harmonicIndex;
+    cognitiveGraph;
+    l5;
+    parametricStore;
+    deltaInjector;
+    _mergedSearch = null;
+    constructor(mafwDir) {
+        this.harmonicIndex = new harmonic_index_1.HarmonicIndexManager(mafwDir);
+        this.cognitiveGraph = new cognitive_graph_1.CognitiveGraphManager(path.join(mafwDir, "data", "knowledge-graph.json"));
+        this.l5 = new l5_store_1.L5Store();
+        this.initParametric(mafwDir);
+    }
+    initParametric(mafwDir) {
+        const parametricDir = path.join(mafwDir, 'parametric');
+        try {
+            if (require('fs').existsSync(parametricDir)) {
+                this.parametricStore = new store_1.ParametricStore({ baseDir: parametricDir });
+                this.deltaInjector = new injector_1.DeltaInjector();
+            }
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    search(query, topK, options) {
+        return this.harmonicIndex.search(query, topK ?? config_1.config.search.defaultTopK, options);
+    }
+    /** Merged search: L3 parametric deltas + Harmonic Index, sorted by energy */
+    async mergedSearch(query, maxFacts = 5) {
+        if (!this._mergedSearch) {
+            this._mergedSearch = (0, memory_injector_1.createMemorySearch)(this.parametricStore, this.deltaInjector, this.harmonicIndex);
+        }
+        return this._mergedSearch(query, maxFacts);
+    }
+}
+exports.MemoryService = MemoryService;

package/gateway/dist/memory/t1-db.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.T1Database = void 0;
+// T1 observation store backed by SQLite (replaces spiral-*.jsonl files).
+// Single writer: the gateway process. The opencode-side plugin sends
+// observations via POST /api/obs/capture; the gateway assigns turn IDs
+// (database-driven, so serve/plugin restarts cannot renumber turns).
+//
+// Dedup is database-level (UNIQUE on session/turn/source/content), which
+// survives process restarts — unlike an in-memory hash window.
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+class T1Database {
+    db;
+    constructor(dbPath) {
+        const dir = path.dirname(dbPath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        this.db = new better_sqlite3_1.default(dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS t1_observations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        turn_id INTEGER NOT NULL,
+        source TEXT NOT NULL,
+        content TEXT NOT NULL,
+        failure INTEGER DEFAULT 0,
+        created_at INTEGER DEFAULT (unixepoch()),
+        UNIQUE(session_id, turn_id, source, content)
+      );
+      CREATE INDEX IF NOT EXISTS idx_t1_session ON t1_observations(session_id, turn_id);
+    `);
+    }
+    /**
+     * Next turn ID for a new user message: max existing turn for the session + 1.
+     * No rows yet → 1.
+     */
+    nextTurnId(session_id) {
+        const row = this.db
+            .prepare('SELECT COALESCE(MAX(turn_id), 0) AS m FROM t1_observations WHERE session_id = ?')
+            .get(session_id);
+        return row.m + 1;
+    }
+    /** Current turn ID for non-user observations: max existing turn, or 0. */
+    currentTurnId(session_id) {
+        const row = this.db
+            .prepare('SELECT COALESCE(MAX(turn_id), 0) AS m FROM t1_observations WHERE session_id = ?')
+            .get(session_id);
+        return row.m;
+    }
+    /**
+     * Insert one observation. Database-level dedup via the UNIQUE constraint:
+     * a duplicate (same session/turn/source/content) is silently ignored.
+     * Returns the row id, or null when deduplicated.
+     */
+    append(obs) {
+        const result = this.db
+            .prepare(`INSERT OR IGNORE INTO t1_observations (session_id, turn_id, source, content, failure)
+         VALUES (?, ?, ?, ?, ?)`)
+            .run(obs.session_id, obs.turn_id, obs.source, obs.content, obs.failure);
+        return result.changes > 0 ? Number(result.lastInsertRowid) : null;
+    }
+    /** Per-session turn summaries (grouped), optionally filtered to a session. */
+    listTurns(session_id) {
+        const where = session_id ? 'WHERE session_id = ?' : '';
+        const rows = this.db
+            .prepare(`SELECT session_id, turn_id,
+                COUNT(*) AS count,
+                MAX(CASE WHEN source = 'user_input' THEN 1 ELSE 0 END) AS has_user_input,
+                SUM(CASE WHEN source IN ('assistant_reply','tool_result','reasoning') AND length(trim(content)) > 0 THEN 1 ELSE 0 END) AS response_count,
+                MAX(created_at) AS last_ts
+         FROM t1_observations
+         ${where}
+         GROUP BY session_id, turn_id
+         ORDER BY session_id, turn_id`)
+            .all(...(session_id ? [session_id] : []));
+        return rows;
+    }
+    readTurn(session_id, turn_id) {
+        return this.db
+            .prepare('SELECT * FROM t1_observations WHERE session_id = ? AND turn_id = ? ORDER BY id')
+            .all(session_id, turn_id);
+    }
+    /** Remove all observations for a session up to (and including) a turn. */
+    deleteTurn(session_id, turn_id) {
+        const result = this.db
+            .prepare('DELETE FROM t1_observations WHERE session_id = ? AND turn_id = ?')
+            .run(session_id, turn_id);
+        return result.changes;
+    }
+    deleteSession(session_id) {
+        return this.db.prepare('DELETE FROM t1_observations WHERE session_id = ?').run(session_id).changes;
+    }
+    count() {
+        return this.db.prepare('SELECT COUNT(*) AS c FROM t1_observations').get().c;
+    }
+    close() {
+        this.db.close();
+    }
+}
+exports.T1Database = T1Database;

package/gateway/dist/memory/unmerge-cleanup.js

@@ -0,0 +1,82 @@
+"use strict";
+// Undo MinHash merge blobs: restore the superseded source units and delete
+// the ' | '-concatenated merge products. Pure planning function (no IO) so
+// the decision logic is unit-testable; the CLI in scripts/unmerge-blobs.ts
+// executes the plan against ~/.mafw/memory.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoredEnergy = restoredEnergy;
+exports.planUnmerge = planUnmerge;
+const isBlob = (e) => !!e && (e.merged_from?.length ?? 0) > 0;
+/** Restored energy: markSuperseded halved energy (floor 0.1) per supersede;
+ *  the original is unrecoverable, so double with a floor/cap. */
+function restoredEnergy(current) {
+    return Math.min(0.9, Math.max(0.4, (current ?? 0.4) * 2));
+}
+function planUnmerge(entries, fileExists) {
+    const byId = new Map(entries.map(e => [e.id, e]));
+    const blobs = entries.filter(isBlob);
+    // Expand a blob's merged_from through intermediate blobs (merge chains;
+    // consolidation mergeIntoNewer does not inherit ancestors).
+    const closureSources = (blob) => {
+        const sources = [];
+        const missing = [];
+        const seen = new Set([blob.id]);
+        const queue = [...(blob.merged_from ?? [])];
+        while (queue.length) {
+            const id = queue.shift();
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            const e = byId.get(id);
+            if (isBlob(e)) {
+                queue.push(...(e.merged_from ?? []));
+                continue;
+            }
+            if (!e || !fileExists(id)) {
+                missing.push(id);
+                continue;
+            }
+            sources.push(id);
+        }
+        return { sources, missing };
+    };
+    // Pass 1: decide each blob's fate.
+    const deleteSet = new Set();
+    const blobSources = new Map();
+    const keepBlobs = [];
+    const missingSources = [];
+    for (const blob of blobs) {
+        if (blob.pinned) {
+            keepBlobs.push({ id: blob.id, reason: 'pinned' });
+            continue;
+        }
+        const { sources, missing } = closureSources(blob);
+        if (missing.length > 0) {
+            keepBlobs.push({ id: blob.id, reason: `missing sources: ${missing.length}` });
+            for (const m of missing)
+                missingSources.push({ blobId: blob.id, sourceId: m });
+            continue;
+        }
+        deleteSet.add(blob.id);
+        blobSources.set(blob.id, sources);
+    }
+    // Pass 2: restore sources superseded by a blob that is being deleted.
+    // Never touch units superseded by a live non-blob unit (explicit
+    // knowledge-update via mafw_add_memory supersedes / mafw_supersede_memory).
+    const restore = [];
+    const restoredIds = new Set();
+    for (const blobId of deleteSet) {
+        for (const srcId of blobSources.get(blobId)) {
+            if (restoredIds.has(srcId))
+                continue;
+            const src = byId.get(srcId);
+            if (!src.superseded_by)
+                continue; // still live — nothing to undo
+            if (!deleteSet.has(src.superseded_by))
+                continue; // superseded by something kept
+            restoredIds.add(srcId);
+            restore.push({ id: srcId, energy: restoredEnergy(src.energy) });
+        }
+    }
+    return { restore, deleteBlobs: [...deleteSet], keepBlobs, missingSources };
+}

package/gateway/dist/memory/vector-store.js

@@ -0,0 +1,246 @@
+"use strict";
+// P1b: persistent vector store + write-path embedding indexer.
+//
+// MemoryVectorStore keeps one JSON file per embedding model next to the
+// harmonic index (<baseDir>/memory/vectors-<model>.json). Vectors are held in
+// memory and persisted atomically (tmp + rename). Cosine search is a brute
+// scan — at agent-memory scale (hundreds to low thousands of entries × 1024
+// dims) this is single-digit milliseconds, far below any ANN's complexity.
+//
+// EmbeddingIndexer decouples the write path from the embedding model: units
+// are enqueued on write (fire-and-forget) and embedded in batches, so BM25
+// recall stays instant while the dense channel converges asynchronously.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddingIndexer = exports.MemoryVectorStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../core/utils/logger");
+class MemoryVectorStore {
+    filePath;
+    dims;
+    model;
+    vectors = new Map();
+    dirty = false;
+    constructor(filePath, dims, model = '') {
+        this.filePath = filePath;
+        this.dims = dims;
+        this.model = model;
+        this.load();
+    }
+    load() {
+        try {
+            if (!fs.existsSync(this.filePath))
+                return;
+            const data = JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+            if (data && typeof data === 'object' && data.vectors) {
+                this.model = data.model || this.model;
+                this.dims = data.dims || this.dims;
+                for (const [id, vec] of Object.entries(data.vectors)) {
+                    this.vectors.set(id, vec);
+                }
+            }
+        }
+        catch (err) {
+            logger_1.log.warn(`[VectorStore] failed to load ${this.filePath}: ${err?.message || err}`);
+        }
+    }
+    flush() {
+        if (!this.dirty && fs.existsSync(this.filePath))
+            return;
+        const body = {
+            model: this.model,
+            dims: this.dims,
+            updated_at: new Date().toISOString(),
+            vectors: Object.fromEntries(this.vectors),
+        };
+        const tmp = this.filePath + '.tmp';
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        fs.writeFileSync(tmp, JSON.stringify(body), 'utf-8');
+        fs.renameSync(tmp, this.filePath);
+        this.dirty = false;
+    }
+    upsert(id, vector) {
+        this.vectors.set(id, vector);
+        this.dirty = true;
+    }
+    get(id) {
+        return this.vectors.get(id);
+    }
+    remove(id) {
+        if (this.vectors.delete(id))
+            this.dirty = true;
+    }
+    size() {
+        return this.vectors.size;
+    }
+    ids() {
+        return [...this.vectors.keys()];
+    }
+    /**
+     * Brute-force cosine scan. Entries whose stored dimension mismatches the
+     * query are skipped (model-change artifacts) rather than throwing.
+     */
+    searchByCosine(query, topK) {
+        const qNorm = norm(query);
+        if (qNorm === 0)
+            return [];
+        const hits = [];
+        for (const [id, vec] of this.vectors) {
+            if (vec.length !== query.length)
+                continue;
+            const vNorm = norm(vec);
+            if (vNorm === 0)
+                continue;
+            let dot = 0;
+            for (let i = 0; i < query.length; i++)
+                dot += query[i] * vec[i];
+            hits.push({ id, cosine: dot / (qNorm * vNorm) });
+        }
+        hits.sort((a, b) => b.cosine - a.cosine);
+        return hits.slice(0, topK);
+    }
+}
+exports.MemoryVectorStore = MemoryVectorStore;
+function norm(vec) {
+    let sum = 0;
+    for (const v of vec)
+        sum += v * v;
+    return Math.sqrt(sum);
+}
+class EmbeddingIndexer {
+    queue = new Map();
+    vectors;
+    provider;
+    getTextForId;
+    batchSize;
+    /** Re-entry guard: backfill and scheduled flushes must not run concurrently
+     *  (two ORT batches at once double the CPU spike the thread cap limits). */
+    flushing = null;
+    constructor(deps) {
+        this.vectors = deps.vectors;
+        this.provider = deps.provider;
+        this.getTextForId = deps.getTextForId;
+        this.batchSize = deps.batchSize ?? 16;
+    }
+    /**
+     * Embeddable text = the retrieval domain: primary_abstraction + cue_anchors.
+     * Deliberately NOT memory_value — (a) RRF channels stay aligned with BM25,
+     * which indexes the same domain; (b) abstract-level inputs are short
+     * (<50 tokens), keeping CPU ONNX attention cost trivial and the memory
+     * arena flat. Anchors carry the entity names, so specifics still reach
+     * the dense channel.
+     */
+    static documentText(unit, textCap = 2000) {
+        const abs = (unit.primary_abstraction || '').trim();
+        const anchors = (unit.cue_anchors || []).join(' ').trim();
+        const text = (abs + (anchors ? ' ' + anchors : '')).trim();
+        return text.slice(0, textCap);
+    }
+    onUnitWritten(unit) {
+        if (!unit?.id)
+            return;
+        this.queue.set(unit.id, {
+            id: unit.id,
+            text: EmbeddingIndexer.documentText(unit),
+        });
+    }
+    removeUnit(id) {
+        this.queue.delete(id);
+        this.vectors.remove(id);
+    }
+    /**
+     * Embed everything queued (document kind) and upsert into the vector store.
+     * Fail-open: an embedding error drops the batch item and logs — the dense
+     * channel converges on a later flush/backfill instead of blocking writes.
+     */
+    async flushQueue() {
+        if (this.flushing)
+            return this.flushing;
+        this.flushing = this.flushQueueInner().finally(() => { this.flushing = null; });
+        return this.flushing;
+    }
+    async flushQueueInner() {
+        if (this.queue.size === 0)
+            return { indexed: 0, failed: 0 };
+        const items = [...this.queue.values()];
+        this.queue.clear();
+        let indexed = 0;
+        let failed = 0;
+        for (let i = 0; i < items.length; i += this.batchSize) {
+            const batch = items.slice(i, i + this.batchSize);
+            try {
+                const vectors = await this.provider.embed(batch.map(b => b.text), 'document');
+                for (let j = 0; j < batch.length; j++) {
+                    this.vectors.upsert(batch[j].id, vectors[j]);
+                    indexed++;
+                }
+            }
+            catch (err) {
+                failed += batch.length;
+                logger_1.log.warn(`[EmbeddingIndexer] batch embed failed (${batch.length} items): ${err?.message || err}`);
+            }
+        }
+        if (indexed > 0)
+            this.vectors.flush();
+        return { indexed, failed };
+    }
+    /**
+     * Index entries that lack vectors (startup backfill / model migration).
+     * Entries whose text can't be resolved count as `missing`.
+     */
+    async backfill(ids) {
+        const pending = [];
+        let skipped = 0;
+        let missing = 0;
+        for (const id of ids) {
+            if (this.vectors.get(id)) {
+                skipped++;
+                continue;
+            }
+            const text = this.getTextForId ? await this.getTextForId(id) : null;
+            if (!text) {
+                missing++;
+                continue;
+            }
+            pending.push({ id, text });
+        }
+        for (const item of pending)
+            this.queue.set(item.id, item);
+        const { indexed, failed } = await this.flushQueue();
+        return { indexed, skipped, missing: missing + failed };
+    }
+}
+exports.EmbeddingIndexer = EmbeddingIndexer;

package/gateway/dist/memory/write-queue.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriteQueue = void 0;
+class WriteQueue {
+    queue = [];
+    processing = false;
+    async enqueue(fn) {
+        return new Promise((resolve, reject) => {
+            this.queue.push(async () => {
+                try {
+                    await fn();
+                    resolve();
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+            if (!this.processing)
+                this.process();
+        });
+    }
+    async process() {
+        this.processing = true;
+        while (this.queue.length > 0) {
+            const fn = this.queue.shift();
+            await fn();
+        }
+        this.processing = false;
+    }
+}
+exports.WriteQueue = WriteQueue;

package/gateway/dist/metrics/collector.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Metrics Collector — Gateway 运行时指标收集
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsCollector = void 0;
+const config_1 = require("../config");
+class MetricsCollector {
+    metrics = [];
+    async record(data) {
+        this.metrics.push(data);
+        // 限制内存中的指标数量
+        if (this.metrics.length > config_1.config.metrics.maxInMemory) {
+            this.metrics = this.metrics.slice(-config_1.config.metrics.pruneRetainCount);
+        }
+    }
+    async getSnapshot() {
+        return {
+            totalGoals: new Set(this.metrics.map(m => m.goalId)).size,
+            activePhases: this.metrics.reduce((acc, m) => {
+                acc[m.phase] = (acc[m.phase] || 0) + 1;
+                return acc;
+            }, {}),
+            recent: this.metrics.slice(-config_1.config.metrics.recentSnapshotSize)
+        };
+    }
+}
+exports.MetricsCollector = MetricsCollector;