@jack200714/mafw 4.8.0 → 4.10.2

package/README.md

@@ -19,8 +19,8 @@
 
 ## 这是什么
 
-MAFW 是一个以**谐波记忆（Harmonic Memory）**为核心的 AI Agent 工作平台。
-它不再只是某个编辑器的插件，而是由四个部分组成的完整系统：
+MAFW 是一个以**谐波记忆（Harmonic Memory）**为核心的 AI Agent 工作平台，
+由四个常驻部分组成（另可选项接入 opencode 编辑器）：
 
 | 组件 | 形态 | 作用 |
 |---|---|---|
@@ -81,6 +81,30 @@ Gateway 与 Agent runtime 之间是能力自声明契约（Tier 0-2）：内置
 external 托管模式可热切换，无需重启。契约能力面覆盖会话分支（fork / revert）、回合预算、
 结果信封（usage / finish）、三值审批回复（once / always / reject）、原生 question 通道等。
 
+### 🧩 统一插件包
+
+`~/.mafw/plugins/` 下**一个插件包可同时贡献多种能力**——usage 配额、media 引擎、agent runtime、
+UI 工具卡——不必按类型拆成多个文件丢进多个目录：
+
+```js
+// ~/.mafw/plugins/my-vendor.js —— 一个文件，一个厂商全家桶
+module.exports = {
+  name: "my-vendor",
+  usage:   { name: "my-vendor", type: "api", plan: "Pro", async fetch(ctx) { /* 余额/限额 */ } },
+  media:   { modalities: ["image"], engine: "pi", fixPayload(p) { /* 自定义 wire 格式 */ } },
+  runtime: { capabilities: { eventStream: true }, async createRuntime(ctx) { /* 接入自有 runtime */ } },
+  // 或 async activate(ctx) 拿统一 ctx 后返回贡献
+};
+```
+
+- **统一上下文**：`apiKey` / `fetch` / `pluginConfig` / `projectDir` / `gatewayPort` / `usage.modelStats` /
+  `emit`（向桌面/TUI/推送全通道广播自定义事件）——
+  三类插件 ctx 的超集，配置收敛在 `plugins.<name>.config`
+- **内置件同接口**：opencode runtime 与 media `pi` 引擎就是注册进同一体系的内置插件，
+  用户同名文件/包可直接覆盖
+- **优先级**：包 > legacy 目录文件 > 内置；旧 `usage-plugins/` 等四目录继续可用
+- **热重载**：改动即生效（顶层 + 每包子目录双 watcher），插件中心（Desktop Config→Plugins）可见全部包状态
+
 ## 基准
 
 LongMemEval-S（session 粒度，谐波记忆管线）：
@@ -106,7 +130,7 @@ LongMemEval-S（session 粒度，谐波记忆管线）：
         ┌──────────┬──────┴──────┬───────────┐
    谐波记忆系统   Goal 编排引擎   自动化引擎   媒体/内核/用量
    OKF + 索引    manager/plan/  cron 规则    A2A · Jupyter
-   能量·合并     execute/review 衰减·压缩    provider 插件
+   能量·合并     execute/review 衰减·压缩    统一插件包
 ```
 
 数据根目录 `~/.mafw/`：记忆 OKF 文件、统一数据库、日志、配置覆盖。

package/gateway/dist/core/manager/goal-snapshot.js

@@ -37,7 +37,7 @@ exports.collectActiveGoals = collectActiveGoals;
 exports.buildGoalSnapshot = buildGoalSnapshot;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const TERMINAL_ACTIONS = new Set(['COMPLETED', 'FAILED']);
+const TERMINAL_ACTIONS = new Set(['COMPLETED', 'FAILED', 'CANCELLED']);
 function collectActiveGoals(mafwDir) {
     const stateDir = path.join(mafwDir, 'state');
     if (!fs.existsSync(stateDir))
@@ -68,6 +68,6 @@ function buildGoalSnapshot(mafwDir, opts) {
     const goals = collectActiveGoals(mafwDir);
     if (goals.length === 0)
         return null;
-    const lines = goals.slice(0, maxGoals).map(g => `- ${g.goalId}: ${g.title} [phase=${g.phase} round=${g.round}${g.pendingQuestions > 0 ? ` pendingQ=${g.pendingQuestions}` : ''}]`);
+    const lines = goals.slice(0, maxGoals).map(g => `- ${g.title} (${g.goalId}) [phase=${g.phase} round=${g.round}${g.pendingQuestions > 0 ? ` pendingQ=${g.pendingQuestions}` : ''}]`);
     return `<goal-snapshot>\n${lines.join('\n')}\n</goal-snapshot>`;
 }

package/gateway/dist/core/manager/manager-session-runtime.js

@@ -0,0 +1,59 @@
+"use strict";
+// Runtime ownership of manager-session kv entries — per-runtime SLOTS.
+// The manager "topic" exists separately in each runtime's storage (opencode
+// SQLite 'ses_*' vs pi SessionManager 'pi_*'), so the kv value keeps one slot
+// per runtime and switching runtimes never drops a topic: switching back
+// resumes the previous manager. Legacy v1 entries ({sessionId, createdAt})
+// are migrated by session-id prefix on read/write. Unknown origin is kept
+// conservatively (deletion is irreversible).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.managerEntryRuntime = managerEntryRuntime;
+exports.readManagerSlot = readManagerSlot;
+exports.writeManagerSlot = writeManagerSlot;
+/** Which runtime does this entry belong to? Explicit tag wins, then id-prefix inference, then null. */
+function managerEntryRuntime(value) {
+    if (value?.runtime)
+        return value.runtime;
+    const sid = value?.sessionId || '';
+    if (sid.startsWith('pi_'))
+        return 'pi';
+    if (sid.startsWith('ses_'))
+        return 'opencode';
+    return null;
+}
+/**
+ * Read the slot for `currentRuntime`.
+ * v2 value → byRuntime[currentRuntime]; v1 legacy → its prefix-inferred slot
+ * when it matches, else null (the entry stays dormant, never deleted).
+ */
+function readManagerSlot(value, currentRuntime) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const v = value;
+    if (v.byRuntime && typeof v.byRuntime === 'object') {
+        return v.byRuntime[currentRuntime] ?? null;
+    }
+    // v1 legacy: belongs to exactly one runtime (prefix-inferred).
+    const owner = managerEntryRuntime(v);
+    return owner === currentRuntime ? { sessionId: v.sessionId, createdAt: v.createdAt } : null;
+}
+/**
+ * Write the slot for `currentRuntime`, preserving all other runtimes' slots.
+ * v1 legacy input is migrated into its prefix-inferred slot first.
+ */
+function writeManagerSlot(existing, currentRuntime, slot) {
+    const byRuntime = {};
+    if (existing && typeof existing === 'object') {
+        const v = existing;
+        if (v.byRuntime && typeof v.byRuntime === 'object') {
+            Object.assign(byRuntime, v.byRuntime);
+        }
+        else {
+            const owner = managerEntryRuntime(v);
+            if (owner && v.sessionId)
+                byRuntime[owner] = { sessionId: v.sessionId, createdAt: v.createdAt };
+        }
+    }
+    byRuntime[currentRuntime] = slot;
+    return { byRuntime };
+}

package/gateway/dist/core/manager/milestone-push.js

@@ -30,21 +30,19 @@ class MilestonePushNotifier {
         const key = milestoneDedupeKey(data.goalId, data.phase, state?.stateVersion ?? data.loop);
         if (this.deps.wasNotified(key))
             return;
-        this.deps.markNotified(key);
-        this.enqueue(data.projectDir, formatMilestoneLine(data.goalId, state?.title || data.goalId, data.phase, state?.reviewVerdict));
+        this.enqueue(data.projectDir, { key, line: formatMilestoneLine(data.goalId, state?.title || data.goalId, data.phase, state?.reviewVerdict) });
     }
     onArchived(goalId, projectDir, verdict) {
         const state = this.deps.readGoalState(goalId, projectDir);
         const key = milestoneDedupeKey(goalId, `ARCHIVED:${verdict}`, state?.stateVersion);
         if (this.deps.wasNotified(key))
             return;
-        this.deps.markNotified(key);
-        this.enqueue(projectDir, formatMilestoneLine(goalId, state?.title || goalId, `ARCHIVED(${verdict})`));
+        this.enqueue(projectDir, { key, line: formatMilestoneLine(goalId, state?.title || goalId, `ARCHIVED(${verdict})`) });
     }
     // Per-project coalescing: bursts of transitions collapse into one message.
-    enqueue(projectDir, line) {
+    enqueue(projectDir, item) {
         const q = this.queues.get(projectDir) || [];
-        q.push(line);
+        q.push(item);
         this.queues.set(projectDir, q);
         if (this.timers.has(projectDir))
             return;
@@ -52,21 +50,38 @@ class MilestonePushNotifier {
     }
     async flush(projectDir) {
         this.timers.delete(projectDir);
-        const lines = this.queues.get(projectDir) || [];
+        const items = this.queues.get(projectDir) || [];
         this.queues.delete(projectDir);
-        if (lines.length === 0)
+        if (items.length === 0)
             return;
         const session = this.deps.getManagerSession(projectDir);
-        if (!session?.sessionId)
+        if (!session?.sessionId) {
+            // Manager slot not ready yet (e.g. right after a runtime switch): retry
+            // with a slower cadence instead of silently dropping the milestone
+            // (marking before delivery would lose it permanently).
+            this.requeue(projectDir, items);
             return;
-        const text = `[MAFW GOAL 里程碑]\n${lines.join('\n')}\n(系统通知)`;
+        }
+        const text = `[MAFW GOAL 里程碑]\n${items.map((i) => i.line).join('\n')}\n(系统通知)`;
         try {
             await this.deps.promptNoReply(session.sessionId, text);
+            for (const item of items)
+                this.deps.markNotified(item.key);
         }
         catch (err) {
             logger_1.log.warn(`[MilestonePush] push failed (fail-open): ${err.message}`);
+            this.requeue(projectDir, items);
         }
     }
+    // Slower retry cadence than the coalescing flush — bounded noise while the
+    // manager session is being (re-)ensured on the active runtime.
+    requeue(projectDir, items) {
+        const q = (this.queues.get(projectDir) || []).concat(items);
+        this.queues.set(projectDir, q);
+        if (this.timers.has(projectDir))
+            return;
+        this.timers.set(projectDir, setTimeout(() => { void this.flush(projectDir); }, 60_000));
+    }
     dispose() {
         for (const t of this.timers.values())
             clearTimeout(t);