@jack200714/mafw 4.5.1

package/gateway/dist/mcp/handlers/manager-list-goals.js

@@ -0,0 +1,60 @@
+"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.handleManagerListGoals = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const handleManagerListGoals = async (_args, services) => {
+    try {
+        const mafwDir = services.mafwDir ?? (process.env.MAFW_PROJECT_DIR ? path.join(process.env.MAFW_PROJECT_DIR, '.mafw') : undefined) ?? path.join(process.cwd(), '.mafw');
+        const stateDir = path.join(mafwDir, 'state');
+        if (!fs.existsSync(stateDir))
+            return { content: [{ type: 'text', text: JSON.stringify({ success: true, goals: [] }) }] };
+        const goals = fs.readdirSync(stateDir).filter(f => f.endsWith('.json')).map(f => {
+            try {
+                const s = JSON.parse(fs.readFileSync(path.join(stateDir, f), 'utf-8'));
+                return { goalId: s.goalId || f.replace('.json', ''), phase: s.phase, round: s.round, verdict: s.reviewVerdict, updatedAt: s.updatedAt };
+            }
+            catch {
+                return null;
+            }
+        }).filter(Boolean);
+        return { content: [{ type: 'text', text: JSON.stringify({ success: true, goals }) }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: err.message }) }], isError: true };
+    }
+};
+exports.handleManagerListGoals = handleManagerListGoals;

package/gateway/dist/mcp/handlers/manager-list-pending-questions.js

@@ -0,0 +1,67 @@
+"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.handleManagerListPendingQuestions = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const handleManagerListPendingQuestions = async (_args, services) => {
+    try {
+        const mafwDir = services.mafwDir ?? (process.env.MAFW_PROJECT_DIR ? path.join(process.env.MAFW_PROJECT_DIR, '.mafw') : undefined) ?? path.join(process.cwd(), '.mafw');
+        const ledgerPath = path.join(mafwDir, 'question-ledger.jsonl');
+        if (!fs.existsSync(ledgerPath)) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: true, questions: [] }) }] };
+        }
+        const lines = fs.readFileSync(ledgerPath, 'utf-8').trim().split('\n');
+        const events = lines.map(l => { try {
+            return JSON.parse(l);
+        }
+        catch {
+            return null;
+        } }).filter(Boolean);
+        const lastByQid = new Map();
+        for (const e of events)
+            lastByQid.set(e.questionId, e);
+        const askedEvents = events.filter((e) => e.type === 'asked');
+        const pending = askedEvents.filter((e) => {
+            const last = lastByQid.get(e.questionId);
+            return last && last.type === 'asked';
+        }).map((e) => ({ questionId: e.questionId, goalId: e.goalId, node: e.node, loop: e.loop, questions: e.questions, askedAt: e.askedAt }));
+        return { content: [{ type: 'text', text: JSON.stringify({ success: true, questions: pending }) }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: err.message }) }], isError: true };
+    }
+};
+exports.handleManagerListPendingQuestions = handleManagerListPendingQuestions;

package/gateway/dist/mcp/handlers/manager-set-goal.js

@@ -0,0 +1,78 @@
+"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.handleManagerSetGoal = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const event_bus_1 = require("../../event-bus");
+const handleManagerSetGoal = async (args, services) => {
+    try {
+        const goalId = args.goalId;
+        const title = args.title;
+        const charter = args.charter;
+        const source = args.source || 'manager';
+        const metrics = args.metrics || {};
+        const boundaries = args.boundaries || [];
+        const priority = args.priority || 'medium';
+        const maxLoops = args.maxLoops || 5;
+        const budget = args.budget;
+        const hasBudget = !!budget && (typeof budget.maxTurns === 'number' || typeof budget.maxCostUsd === 'number');
+        const mafwDir = services.mafwDir ?? (process.env.MAFW_PROJECT_DIR ? path.join(process.env.MAFW_PROJECT_DIR, '.mafw') : undefined) ?? path.join(process.cwd(), '.mafw');
+        const projectDir = path.resolve(mafwDir, '..');
+        const goalsDir = path.join(mafwDir, 'goals');
+        const requestsDir = path.join(mafwDir, 'requests');
+        fs.mkdirSync(goalsDir, { recursive: true });
+        fs.mkdirSync(requestsDir, { recursive: true });
+        const charterPath = path.join(goalsDir, `${goalId}.md`);
+        if (fs.existsSync(charterPath)) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: `Goal ${goalId} already exists` }) }], isError: true };
+        }
+        fs.writeFileSync(charterPath, charter, 'utf-8');
+        const request = {
+            version: '2', goalId, title, state: 'draft',
+            createdAt: new Date().toISOString(), confirmedAt: new Date().toISOString(),
+            source, projectDir, mafwDir, goalCharter: charterPath,
+            metrics, boundaries, priority, maxLoops, parallel: false,
+            ...(hasBudget ? { budget } : {}),
+        };
+        fs.writeFileSync(path.join(requestsDir, `${goalId}.json`), JSON.stringify(request, null, 2), 'utf-8');
+        event_bus_1.eventBus.emit('goal_created', { type: 'goal_created', goalId, projectDir });
+        return { content: [{ type: 'text', text: JSON.stringify({ success: true, goalId, message: `Goal ${goalId} created. Verification pending.` }) }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: err.message }) }], isError: true };
+    }
+};
+exports.handleManagerSetGoal = handleManagerSetGoal;

package/gateway/dist/mcp/handlers/merge-memory.js

@@ -0,0 +1,184 @@
+"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.handleMergeMemory = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../../config");
+const harmonic_file_store_js_1 = require("../../memory/harmonic-file-store.js");
+const minhash_merger_1 = require("../../core/memory/minhash-merger");
+const harmonic_types_1 = require("../../core/memory/harmonic-types");
+const handleMergeMemory = async (args, { memory }) => {
+    try {
+        const sourceWorktree = args.sourceWorktree;
+        const resolveStrategy = args.resolveStrategy || "manual";
+        if (!sourceWorktree) {
+            return { content: [{ type: "text", text: JSON.stringify({ success: false, error: "sourceWorktree is required" }) }], isError: true };
+        }
+        const targetMafwDir = config_1.config.resolvePath();
+        const sourceMafwDir = path.join(sourceWorktree, config_1.config.paths.mafwDir);
+        const targetStore = new harmonic_file_store_js_1.HarmonicUnitFileStore(targetMafwDir);
+        const targetIndex = targetStore.indexManager_().getIndex();
+        const targetUnits = [];
+        for (const entry of targetIndex.entries) {
+            const unit = await targetStore.read(entry.id);
+            if (unit)
+                targetUnits.push(unit);
+        }
+        let sourceUnits = [];
+        try {
+            const sourceStore = new harmonic_file_store_js_1.HarmonicUnitFileStore(sourceMafwDir);
+            const sourceIndex = sourceStore.indexManager_().getIndex();
+            for (const entry of sourceIndex.entries) {
+                const unit = await sourceStore.read(entry.id);
+                if (unit)
+                    sourceUnits.push(unit);
+            }
+        }
+        catch {
+            return { content: [{ type: "text", text: JSON.stringify({ success: false, error: `No memories found at ${sourceMafwDir}` }) }], isError: true };
+        }
+        const updatedIds = new Set();
+        const minhash = new minhash_merger_1.MinHashMerger();
+        const added = [];
+        const conflicts = [];
+        const skipped = [];
+        for (const srcUnit of sourceUnits) {
+            const srcSig = minhash.generateSignature(srcUnit.primary_abstraction || "");
+            let bestMatch = null;
+            let bestSim = 0;
+            for (const tgtUnit of targetUnits) {
+                const tgtSig = minhash.generateSignature(tgtUnit.primary_abstraction || "");
+                const sim = minhash.similarity(srcSig, tgtSig);
+                if (sim > bestSim) {
+                    bestSim = sim;
+                    bestMatch = tgtUnit;
+                }
+            }
+            if (bestSim > 0.6) {
+                if (bestMatch.memory_value !== srcUnit.memory_value) {
+                    conflicts.push({
+                        source: { id: srcUnit.id, primary_abstraction: srcUnit.primary_abstraction, memory_value: srcUnit.memory_value, energy: srcUnit.energy },
+                        target: { id: bestMatch.id, primary_abstraction: bestMatch.primary_abstraction, memory_value: bestMatch.memory_value, energy: bestMatch.energy },
+                        similarity: bestSim,
+                    });
+                    if (resolveStrategy === "higher_energy") {
+                        if (srcUnit.energy > (bestMatch.energy || 0)) {
+                            bestMatch.memory_value = srcUnit.memory_value;
+                            bestMatch.energy = Math.max(bestMatch.energy || 0, srcUnit.energy);
+                            bestMatch.merged_from = [...(bestMatch.merged_from || []), srcUnit.id];
+                            bestMatch.updated_at = new Date().toISOString();
+                            updatedIds.add(bestMatch.id);
+                        }
+                    }
+                    else if (resolveStrategy === "newer") {
+                        if (new Date(srcUnit.updated_at || srcUnit.created_at) > new Date(bestMatch.updated_at || bestMatch.created_at)) {
+                            bestMatch.memory_value = srcUnit.memory_value;
+                            bestMatch.merged_from = [...(bestMatch.merged_from || []), srcUnit.id];
+                            bestMatch.updated_at = new Date().toISOString();
+                            updatedIds.add(bestMatch.id);
+                        }
+                    }
+                }
+                else {
+                    skipped.push(srcUnit.id);
+                }
+            }
+            else {
+                const now = new Date().toISOString();
+                const newUnit = {
+                    id: (0, harmonic_types_1.generateHarmonicId)(),
+                    type: srcUnit.type || "semantic",
+                    primary_abstraction: srcUnit.primary_abstraction,
+                    cue_anchors: srcUnit.cue_anchors || [],
+                    memory_value: srcUnit.memory_value,
+                    energy: 0.4,
+                    salience: srcUnit.salience || 1.0,
+                    merged_from: [srcUnit.id],
+                    created_at: now,
+                    updated_at: now,
+                };
+                targetUnits.push(newUnit);
+                added.push(newUnit);
+            }
+        }
+        if (added.length > 0 || conflicts.length > 0) {
+            for (const unit of added) {
+                await targetStore.write(unit);
+            }
+            for (const id of updatedIds) {
+                const unit = targetUnits.find(u => u.id === id);
+                if (unit) {
+                    targetStore.indexManager_().removeEntry(id);
+                    await targetStore.write(unit);
+                }
+            }
+            // Append to fusion log
+            const fusionLogPath = path.join(targetMafwDir, "fusion-log.jsonl");
+            const logEntry = JSON.stringify({
+                timestamp: new Date().toISOString(),
+                source_worktree: sourceWorktree,
+                added: added.map(u => ({ id: u.id, primary_abstraction: u.primary_abstraction })),
+                conflicts: conflicts.map(c => ({
+                    primary_abstraction: c.source.primary_abstraction,
+                    source_value: c.source.memory_value,
+                    target_value: c.target.memory_value,
+                    similarity: c.similarity,
+                })),
+            });
+            fs.appendFileSync(fusionLogPath, logEntry + "\n", "utf-8");
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        added: added.length,
+                        conflicts: conflicts.length,
+                        skipped: skipped.length,
+                        details: {
+                            added: added.map(u => ({ id: u.id, primary_abstraction: u.primary_abstraction, energy: u.energy })),
+                            conflicts: resolveStrategy === "manual" ? conflicts : [],
+                            strategy: resolveStrategy,
+                        },
+                    }),
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: err.message }) }], isError: true };
+    }
+};
+exports.handleMergeMemory = handleMergeMemory;

package/gateway/dist/mcp/handlers/pin-memory.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePinMemory = void 0;
+const config_1 = require("../../config");
+const handlePinMemory = async (args, { memory, mafwDir }) => {
+    try {
+        const id = String(args.id || '');
+        const hasPinned = typeof args.pinned === 'boolean';
+        const hasSticky = typeof args.sticky === 'boolean';
+        if (!id) {
+            return { content: [{ type: "text", text: JSON.stringify({ success: false, error: 'id required' }) }], isError: true };
+        }
+        if (!hasPinned && !hasSticky) {
+            return { content: [{ type: "text", text: JSON.stringify({ success: false, error: 'pinned or sticky required' }) }], isError: true };
+        }
+        const resolvedDir = mafwDir ?? config_1.config.resolvePath();
+        const { HarmonicUnitFileStore } = await import("../../memory/harmonic-file-store.js");
+        const sharedIndex = memory?.harmonicIndex;
+        const sharedGraph = memory?.harmonicIndex?.getAnchorGraphStore?.()
+            ?? memory?.getAnchorGraphStore?.() ?? undefined;
+        const store = sharedIndex
+            ? new HarmonicUnitFileStore(resolvedDir, sharedIndex, sharedGraph)
+            : new HarmonicUnitFileStore(resolvedDir, undefined, sharedGraph);
+        const result = { success: true, id };
+        if (hasPinned) {
+            const pinned = args.pinned === true;
+            const ok = store.setPinned(id, pinned);
+            if (!ok) {
+                return { content: [{ type: "text", text: JSON.stringify({ success: false, error: `memory not found: ${id}` }) }], isError: true };
+            }
+            result.pinned = pinned;
+        }
+        if (hasSticky) {
+            // sticky: true sticks/renews the note-board TTL (default 7 days,
+            // stickyDays overrides); sticky: false removes the note from the board.
+            // Board membership expires — the memory itself is never touched.
+            const stickyDays = typeof args.stickyDays === 'number' && args.stickyDays > 0 ? args.stickyDays : 7;
+            const until = args.sticky === true ? new Date(Date.now() + stickyDays * 86400e3).toISOString() : null;
+            const ok = store.setSticky(id, until);
+            if (!ok) {
+                return { content: [{ type: "text", text: JSON.stringify({ success: false, error: `memory not found: ${id}` }) }], isError: true };
+            }
+            result.sticky = args.sticky === true;
+            if (until)
+                result.sticky_until = until;
+        }
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: false, error: err.message }) }], isError: true };
+    }
+};
+exports.handlePinMemory = handlePinMemory;

package/gateway/dist/mcp/handlers/propose-triage-decision.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleProposeTriageDecision = void 0;
+const handleProposeTriageDecision = async (args, { automation, ledger }) => {
+    try {
+        if (!automation)
+            throw new Error('Automation engine not available');
+        const triageId = args.triage_id;
+        const suggestion = args.suggestion;
+        const reason = args.reason;
+        const priority = args.priority || 'medium';
+        if (!['confirm', 'reject'].includes(suggestion)) {
+            throw new Error('suggestion must be "confirm" or "reject"');
+        }
+        const result = automation.proposeTriageDecision(triageId, suggestion, reason, priority);
+        ledger?.append({
+            timestamp: new Date().toISOString(),
+            event: 'AUTOMATION_TRIGGERED',
+            source: 'llm',
+            reason: `proposed_${suggestion}_for_${triageId}`,
+            details: { triageId, suggestion, priority, reasonLength: reason.length },
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        status: result.success ? 'suggestion_submitted' : 'error',
+                        message: result.message,
+                        note: 'Triage item remains PENDING_CONFIRMATION — user will review your suggestion',
+                    }),
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }], isError: true };
+    }
+};
+exports.handleProposeTriageDecision = handleProposeTriageDecision;

package/gateway/dist/mcp/handlers/record-feedback.js

@@ -0,0 +1,59 @@
+"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.handleRecordFeedback = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const event_bus_1 = require("../../event-bus");
+const projectDir = process.env.MAFW_PROJECT_DIR || process.cwd();
+const handleRecordFeedback = async (args) => {
+    try {
+        const targetId = args.targetId;
+        const type = args.type;
+        const goalId = args.goalId;
+        const loopNum = args.loopNum;
+        const comment = args.comment;
+        const feedback = { targetId, type, goalId, loopNum, comment, createdAt: new Date().toISOString() };
+        const feedbackDir = path.join(projectDir, ".mafw/feedback");
+        fs.mkdirSync(feedbackDir, { recursive: true });
+        fs.writeFileSync(path.join(feedbackDir, `${targetId}-${Date.now()}.json`), JSON.stringify(feedback, null, 2), "utf-8");
+        event_bus_1.eventBus.emit("user_feedback", { type: "user_feedback", goalId, targetId, feedbackType: type });
+        return { content: [{ type: "text", text: JSON.stringify({ success: true }) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ error: err.message }) }], isError: true };
+    }
+};
+exports.handleRecordFeedback = handleRecordFeedback;

package/gateway/dist/mcp/handlers/resolve-merge.js

@@ -0,0 +1,92 @@
+"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.handleResolveMerge = void 0;
+const path = __importStar(require("path"));
+const harmonic_file_store_1 = require("../../memory/harmonic-file-store");
+const abstraction_matcher_1 = require("../../memory/abstraction-matcher");
+const harmonic_types_1 = require("../../core/memory/harmonic-types");
+const handleResolveMerge = async (args, { memory }) => {
+    try {
+        const conflictingId = args.conflictingId;
+        const newAbstraction = args.newAbstraction;
+        const action = args.action;
+        if (!conflictingId || !newAbstraction || !action) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'conflictingId, newAbstraction, and action required' }) }], isError: true };
+        }
+        const projectDir = process.env.MAFW_PROJECT_DIR || process.cwd();
+        const mafwDir = path.join(projectDir, '.mafw');
+        const store = new harmonic_file_store_1.HarmonicUnitFileStore(mafwDir);
+        const existing = await store.read(conflictingId);
+        if (!existing) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: `Unit ${conflictingId} not found` }) }], isError: true };
+        }
+        const match = (0, abstraction_matcher_1.matchAbstraction)(newAbstraction, existing.primary_abstraction);
+        if (action === 'merge') {
+            existing.memory_value = existing.memory_value + '\n---\n(' + newAbstraction + ' merge)';
+            existing.merged_from = [...(existing.merged_from || []), conflictingId + '-merged'];
+            existing.updated_at = new Date().toISOString();
+            await store.write(existing);
+        }
+        else if (action === 'link') {
+            existing.memory_value = existing.memory_value + `\n\nRelated: [[${newAbstraction}]]`;
+            existing.updated_at = new Date().toISOString();
+            await store.write(existing);
+        }
+        else if (action === 'abstract') {
+            const parentId = (0, harmonic_types_1.generateHarmonicId)();
+            const parent = {
+                id: parentId,
+                type: 'semantic',
+                granularity: 'architecture',
+                primary_abstraction: newAbstraction,
+                cue_anchors: [...existing.cue_anchors],
+                memory_value: `Merged from [[${existing.id}]] and [[${conflictingId}-merged]]`,
+                energy: Math.min(1.0, existing.energy + 0.1),
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+                merged_from: [existing.id, conflictingId],
+            };
+            await store.write(parent);
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ success: true, action, similarity: match.similarity }) }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: err.message }) }], isError: true };
+    }
+};
+exports.handleResolveMerge = handleResolveMerge;

package/gateway/dist/mcp/handlers/restart-agent.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRestartAgent = void 0;
+const handleRestartAgent = async (_args, { restartAgent }) => {
+    try {
+        if (!restartAgent) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: "Agent restart not available (runtime does not support agentProcessApi)" }) }],
+                isError: true,
+            };
+        }
+        const result = await restartAgent();
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: JSON.stringify({ error: err.message }) }],
+            isError: true,
+        };
+    }
+};
+exports.handleRestartAgent = handleRestartAgent;