@xqli02/mneme 0.1.0

package/src/commands/status.mjs

@@ -0,0 +1,164 @@
+/**
+ * mneme status — Unified dashboard for all three memory layers.
+ *
+ * Shows:
+ *   Layer 1 (OpenClaw): Facts files summary (count, total lines)
+ *   Layer 2 (Beads):    Task counts by status, ready tasks
+ *   Layer 3 (OpenCode): Git working tree state, unpushed commits
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { run, log, color } from "../utils.mjs";
+
+// ── Layer 1: OpenClaw ───────────────────────────────────────────────────────
+
+function showOpenClaw() {
+  console.log(color.bold("\n  Layer 1 — OpenClaw (Long-term Facts)"));
+  console.log(color.dim("  ─────────────────────────────────────"));
+
+  const factsDir = ".openclaw/facts";
+  if (!existsSync(factsDir)) {
+    log.warn("  .openclaw/facts/ not found — run `mneme init`");
+    return;
+  }
+
+  const files = readdirSync(factsDir).filter((f) => f.endsWith(".md"));
+  if (files.length === 0) {
+    log.warn("  No facts files found");
+    return;
+  }
+
+  let totalLines = 0;
+  for (const file of files) {
+    const filePath = join(factsDir, file);
+    const content = readFileSync(filePath, "utf-8");
+    const lines = content.split("\n").length;
+    totalLines += lines;
+    const name = file.replace(/\.md$/, "");
+    console.log(`  ${color.green("●")} ${name} ${color.dim(`(${lines} lines)`)}`);
+  }
+
+  console.log(
+    color.dim(`\n  ${files.length} file(s), ${totalLines} total lines`),
+  );
+
+  // Warn if approaching the 800-line budget
+  if (totalLines > 600) {
+    log.warn(
+      `  Facts approaching size budget (${totalLines}/800 lines) — consider pruning`,
+    );
+  }
+}
+
+// ── Layer 2: Beads ──────────────────────────────────────────────────────────
+
+function showBeads() {
+  console.log(color.bold("\n  Layer 2 — Beads (Task State)"));
+  console.log(color.dim("  ────────────────────────────"));
+
+  if (!existsSync(".beads/config.yaml")) {
+    log.warn("  .beads/ not initialized — run `mneme init`");
+    return;
+  }
+
+  // Get counts by status
+  const openOut = run("bd list --status=open 2>&1");
+  const ipOut = run("bd list --status=in_progress 2>&1");
+  const blockedOut = run("bd blocked 2>&1");
+  const readyOut = run("bd ready 2>&1");
+
+  const countLines = (output) => {
+    if (!output || output.includes("No issues") || output.includes("Error")) return 0;
+    // Count lines that look like bead entries (start with ○, ◐, ●, ✓, or ❄, or contain mneme-/bd-)
+    return output
+      .split("\n")
+      .filter((l) => /^[○◐●✓❄]/.test(l.trim()) || /\b(mneme|bd)-[a-z0-9]+\b/.test(l))
+      .length;
+  };
+
+  const openCount = countLines(openOut);
+  const ipCount = countLines(ipOut);
+  const blockedCount = countLines(blockedOut);
+  const readyCount = countLines(readyOut);
+
+  console.log(`  ${color.green("○")} Open:        ${openCount}`);
+  console.log(`  ${color.yellow("◐")} In progress: ${ipCount}`);
+  console.log(`  ${color.red("●")} Blocked:     ${blockedCount}`);
+  console.log(`  ${color.blue("▶")} Ready:       ${readyCount}`);
+
+  // Show ready tasks
+  if (readyOut && !readyOut.includes("No issues") && readyCount > 0) {
+    console.log(color.dim("\n  Ready to work on:"));
+    const lines = readyOut.split("\n").filter((l) => /^[○◐]/.test(l.trim()));
+    for (const line of lines) {
+      console.log(`    ${line.trim()}`);
+    }
+  }
+}
+
+// ── Layer 3: OpenCode (Session Context) ─────────────────────────────────────
+
+function showOpenCode() {
+  console.log(color.bold("\n  Layer 3 — OpenCode (Session Context)"));
+  console.log(color.dim("  ─────────────────────────────────────"));
+
+  if (!existsSync(".git")) {
+    log.warn("  Not a git repository");
+    return;
+  }
+
+  // Working tree status
+  const status = run("git status --porcelain 2>&1");
+  if (status === null) {
+    log.warn("  Could not read git status");
+    return;
+  }
+
+  if (status === "") {
+    console.log(`  ${color.green("●")} Working tree clean`);
+  } else {
+    const lines = status.split("\n").filter(Boolean);
+    const modified = lines.filter((l) => l.startsWith(" M") || l.startsWith("M ")).length;
+    const added = lines.filter((l) => l.startsWith("A ") || l.startsWith("??")).length;
+    const deleted = lines.filter((l) => l.startsWith(" D") || l.startsWith("D ")).length;
+    const staged = lines.filter((l) => /^[MADRC]/.test(l)).length;
+
+    const parts = [];
+    if (modified > 0) parts.push(`${modified} modified`);
+    if (added > 0) parts.push(`${added} new`);
+    if (deleted > 0) parts.push(`${deleted} deleted`);
+    if (staged > 0) parts.push(`${staged} staged`);
+
+    console.log(`  ${color.yellow("●")} ${parts.join(", ")}`);
+  }
+
+  // Unpushed commits
+  const unpushed = run("git log @{u}..HEAD --oneline 2>&1");
+  if (unpushed === null || unpushed.includes("no upstream")) {
+    console.log(`  ${color.dim("●")} No remote tracking branch`);
+  } else if (unpushed === "") {
+    console.log(`  ${color.green("●")} Up to date with remote`);
+  } else {
+    const count = unpushed.split("\n").filter(Boolean).length;
+    console.log(`  ${color.yellow("●")} ${count} unpushed commit(s)`);
+  }
+
+  // Current branch
+  const branch = run("git branch --show-current 2>&1");
+  if (branch) {
+    console.log(`  ${color.dim("●")} Branch: ${branch}`);
+  }
+}
+
+// ── Main ────────────────────────────────────────────────────────────────────
+
+export async function status() {
+  console.log(`\n${color.bold("mneme status")} — three-layer memory dashboard`);
+
+  showOpenClaw();
+  showBeads();
+  showOpenCode();
+
+  console.log();
+}

package/src/opencode-client.mjs

@@ -0,0 +1,126 @@
+/**
+ * OpenCode HTTP client — zero-dependency wrapper around opencode serve API.
+ *
+ * Uses native fetch (Node 18+) and SSE parsing for event streams.
+ */
+
+/**
+ * Create an OpenCode HTTP client connected to a running server.
+ * @param {{ baseUrl: string }} opts
+ */
+export function createClient(baseUrl) {
+  const base = baseUrl.replace(/\/$/, "");
+
+  async function request(method, path, body) {
+    const url = `${base}${path}`;
+    const opts = {
+      method,
+      headers: { "Content-Type": "application/json" },
+    };
+    if (body !== undefined) {
+      opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url, opts);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`OpenCode API ${method} ${path}: ${res.status} ${text}`);
+    }
+    // 204 No Content
+    if (res.status === 204) return null;
+    const contentType = res.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      return res.json();
+    }
+    return res.text();
+  }
+
+  /**
+   * Subscribe to SSE event stream.
+   * Returns an async iterator of parsed events: { type, properties }.
+   */
+  async function* subscribeEvents(path = "/event") {
+    const url = `${base}${path}`;
+    const res = await fetch(url, {
+      headers: { Accept: "text/event-stream" },
+    });
+    if (!res.ok) {
+      throw new Error(`SSE connect failed: ${res.status}`);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentEvent = {};
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+
+      const lines = buffer.split("\n");
+      buffer = lines.pop(); // keep incomplete line
+
+      for (const line of lines) {
+        if (line.startsWith("event:")) {
+          currentEvent.type = line.slice(6).trim();
+        } else if (line.startsWith("data:")) {
+          const data = line.slice(5).trim();
+          try {
+            currentEvent.properties = JSON.parse(data);
+          } catch {
+            currentEvent.properties = data;
+          }
+        } else if (line === "") {
+          // Empty line = end of event
+          if (currentEvent.type || currentEvent.properties) {
+            yield currentEvent;
+            currentEvent = {};
+          }
+        }
+      }
+    }
+  }
+
+  return {
+    /** Health check */
+    health: () => request("GET", "/global/health"),
+
+    /** Session management */
+    session: {
+      list: () => request("GET", "/session"),
+      create: (body) => request("POST", "/session", body),
+      get: (id) => request("GET", `/session/${id}`),
+      delete: (id) => request("DELETE", `/session/${id}`),
+      abort: (id) => request("POST", `/session/${id}/abort`),
+      messages: (id) => request("GET", `/session/${id}/message`),
+      status: () => request("GET", "/session/status"),
+
+      /**
+       * Send a prompt (synchronous — waits for full response).
+       * @param {string} id - session ID
+       * @param {object} body - { parts: [{ type: "text", text: "..." }], model?, agent? }
+       */
+      prompt: (id, body) => request("POST", `/session/${id}/message`, body),
+
+      /**
+       * Send a prompt asynchronously (returns immediately, 204).
+       * Listen to events for progress.
+       */
+      promptAsync: (id, body) =>
+        request("POST", `/session/${id}/prompt_async`, body),
+    },
+
+    /** Config */
+    config: {
+      get: () => request("GET", "/config"),
+    },
+
+    /** Events */
+    events: {
+      subscribe: () => subscribeEvents("/event"),
+      subscribeGlobal: () => subscribeEvents("/global/event"),
+    },
+
+    /** Raw request for anything else */
+    request,
+  };
+}

package/src/templates/AGENTS.md

@@ -0,0 +1,259 @@
+# AGENTS.md — OpenCode Agent 行为规则
+
+## 身份与定位
+
+你是一个长期工程项目中的执行 agent。你**不承担长期记忆**，也**不承担任务管理**。你的记忆和任务状态分别由 OpenClaw 和 Beads 管理。
+
+---
+
+## Session 启动流程（必须严格遵守）
+
+每个新 session 开始时，按以下顺序执行：
+
+1. **读取 OpenClaw facts（长期事实）**
+   - 阅读 `.openclaw/facts/` 下的所有文件
+   - 这些内容优先级**高于**你的推理和对话历史
+   - 若发现 facts 与当前情况矛盾，**提出质疑**而非直接修改
+
+2. **读取 Beads 当前任务列表**
+   - 执行 `mneme ready` 查看当前可执行的任务
+   - 执行 `mneme list --status=open` 查看所有未完成任务
+   - 了解当前所有未完成任务及其状态和依赖关系
+
+3. **选择一个 bead 作为本 session 的 focus**
+   - 只选一个，不要同时推进多个不相关任务
+   - 优先从 `mneme ready` 的结果中选择（无阻塞依赖的 open 状态 bead）
+
+4. **开始执行**
+
+---
+
+## 执行过程中的规则
+
+### Beads 管理
+
+- 开始工作前先 claim 任务：`mneme update <id> --status=in_progress`
+- 完成一个阶段性目标后，更新对应 bead 的 `notes`：`mneme update <id> --notes="进度说明"`
+- **不要依赖对话历史记住进度**，所有进度必须写入 Beads
+- 新发现的子任务应创建为新的 bead：`mneme create --title="..." --description="..." --type=task -p 2`
+- 关联发现的工作：`mneme dep add <new-id> <parent-id>`
+- **WARNING**: 禁止使用 `bd edit`，它会打开交互式编辑器。始终使用 `mneme update` 加参数
+
+### OpenClaw 管理
+
+- 在执行过程中若发现新的长期事实（架构决策、红线、陷阱等），**提议**写入 OpenClaw
+- 提议需明确说明：
+  - 写入哪个 facts 文件
+  - 具体内容
+  - 为什么这是一个"长期事实"而非临时结论
+- **等待人工确认后才能写入**
+
+### 代码操作
+
+- 只负责代码分析、文件修改、命令执行等即时操作
+- 所有操作应服务于当前 focus bead 的目标
+
+---
+
+## 三层路由决策（自动分类）
+
+在工作过程中，你会不断产生新的信息。**你必须主动判断每条信息属于哪一层**，而不是等待用户指示。以下是决策逻辑：
+
+### 决策树
+
+```
+新信息产生
+  │
+  ├─ 问："6 个月后这条信息还有用吗？"
+  │    │
+  │    ├─ YES → 问："这是一个事实/约束/教训，还是一个待办/进度？"
+  │    │    │
+  │    │    ├─ 事实/约束/教训 → **OpenClaw**（提议写入，等待确认）
+  │    │    │
+  │    │    └─ 待办/进度 → **Beads**（直接写入）
+  │    │
+  │    └─ NO → 问："下个 session 需要这条信息吗？"
+  │         │
+  │         ├─ YES → **Beads**（写入 notes 或创建新 bead）
+  │         │
+  │         └─ NO → **OpenCode**（留在当前上下文，不持久化）
+```
+
+### 分类示例
+
+| 信息                                         | 分类      | 动作                                           |
+|----------------------------------------------|-----------|------------------------------------------------|
+| "这个项目用 Dolt 作为数据库后端"             | OpenClaw  | 提议写入 `facts/architecture.md`               |
+| "禁止在生产环境直接修改 Dolt 数据"           | OpenClaw  | 提议写入 `facts/invariants.md`                 |
+| "`bd edit` 会打开交互式编辑器导致 agent 卡住"| OpenClaw  | 提议写入 `facts/pitfalls.md`                   |
+| "需要实现用户认证模块"                       | Beads     | `mneme create --title="实现用户认证" ...`      |
+| "认证模块完成了 JWT 签发部分，还差验证"      | Beads     | `mneme update <id> --notes="JWT 签发完成..."` |
+| "这个函数的第 3 个参数是 timeout"            | OpenCode  | 不持久化，仅在当前操作中使用                   |
+| "正在对比两种实现方案的 trade-off"           | OpenCode  | 不持久化，除非最终选择成为架构决策             |
+
+### 自动路由规则
+
+1. **架构决策** → 一旦做出并确认，提议写入 `facts/architecture.md`
+2. **红线/约束** → 发现不可违反的规则时，提议写入 `facts/invariants.md`
+3. **踩坑经验** → 遇到非显而易见的陷阱时，提议写入 `facts/pitfalls.md`
+4. **性能基准** → 发现关键性能约束时，提议写入 `facts/performance_rules.md`
+5. **新任务/子任务** → 发现需要做的工作时，`mneme create` 创建 bead
+6. **进度更新** → 完成阶段性目标时，`mneme update --notes` 记录
+7. **临时分析** → 代码分析、调试过程、方案对比 → 留在 OpenCode，不持久化
+
+### 写入 OpenClaw 的门槛检查
+
+在提议写入 OpenClaw 前，必须通过以下所有检查：
+
+- [ ] 这条信息已被验证（不是假设或推测）
+- [ ] 这条信息在未来 session 中会被反复需要（不是一次性的）
+- [ ] 这条信息不会快速过时（不是某个临时状态）
+- [ ] 现有 facts 文件中没有等价信息（避免重复）
+
+只有全部通过才提议写入。提议后仍需等待人工确认。
+
+---
+
+## Compaction 前的固定动作
+
+当感知到上下文即将过长，或在完成阶段性目标后，执行以下步骤：
+
+1. **持久化已确认的结论**
+   - 将本 session 中已确认的结论更新到对应 bead：`mneme update <id> --notes="结论"`
+
+2. **提议新的长期事实**
+   - 若发现应加入 OpenClaw 的内容，提出提议
+
+3. **更新 bead 状态**
+   - 若当前 bead 已完成，关闭它：`mneme close <id> --reason="完成说明"`
+   - 若未完成，确保 `notes` 中记录了当前进度和卡点
+
+4. **允许 compaction**
+
+> 原则：**可以丢失推理过程，但不能丢失状态与事实**
+
+---
+
+## 禁止行为
+
+- 禁止跳过 session 启动流程直接开始工作
+- 禁止从对话历史恢复任务进度
+- 禁止单方面修改或删除 OpenClaw facts
+- 禁止在一个 session 中同时推进多个不相关的 bead
+- 禁止将未验证的假设写入 OpenClaw
+- 禁止创建模糊的、无法验证完成与否的 bead
+- 禁止使用 `bd edit`（会打开交互式编辑器）
+
+<!-- BEGIN BEADS INTEGRATION -->
+## Issue Tracking with mneme (beads)
+
+**IMPORTANT**: This project uses **mneme** (backed by bd/beads) for ALL issue tracking. Do NOT use markdown TODOs, task lists, or other tracking methods.
+
+### Why beads?
+
+- Dolt-Powered: Version-controlled SQL database with cell-level merge and native branching
+- Dependency-aware: Track blockers and relationships between issues
+- Agent-optimized: JSON output (`--json`), ready work detection, hash-based IDs
+- Zero conflict: Hash-based IDs (`bd-a1b2`) prevent merge collisions
+- Compaction: Semantic "memory decay" summarizes old closed tasks
+
+### Essential Commands
+
+**Finding work:**
+
+```bash
+mneme ready                           # Show issues with no open blockers
+mneme list --status=open              # All open issues
+mneme list --status=in_progress       # Your active work
+mneme show <id>                       # Detailed issue view with dependencies
+```
+
+**Creating issues:**
+
+```bash
+mneme create --title="Issue title" --description="Context" --type=task -p 2
+mneme create --title="Bug found" --description="Details" --type=bug -p 1
+```
+
+**Claiming and updating:**
+
+```bash
+mneme update <id> --status=in_progress      # Claim work
+mneme update <id> --notes="Progress notes"  # Add notes
+mneme update <id> --title="New title"       # Update title
+mneme update <id> --description="Updated"   # Update description
+```
+
+**Dependencies:**
+
+```bash
+mneme dep add <child> <parent>        # child depends on parent
+mneme blocked                         # Show all blocked issues
+```
+
+**Completing work:**
+
+```bash
+mneme close <id> --reason "Done"      # Close single issue
+mneme close <id1> <id2> ...           # Close multiple at once
+```
+
+### Issue Types
+
+- `bug` - Something broken
+- `feature` - New functionality
+- `task` - Work item (tests, docs, refactoring)
+- `epic` - Large feature with subtasks
+- `chore` - Maintenance (dependencies, tooling)
+
+### Priorities
+
+- `0` / `P0` - Critical (security, data loss, broken builds)
+- `1` / `P1` - High (major features, important bugs)
+- `2` / `P2` - Medium (default)
+- `3` / `P3` - Low (polish, optimization)
+- `4` / `P4` - Backlog (future ideas)
+
+### Workflow for AI Agents
+
+1. **Check ready work**: `mneme ready` shows unblocked issues
+2. **Claim your task**: `mneme update <id> --status=in_progress`
+3. **Work on it**: Implement, test, document
+4. **Discover new work?** Create linked issue with `mneme create` + `mneme dep add`
+5. **Complete**: `mneme close <id> --reason "Done"`
+
+### Important Rules
+
+- Use mneme for ALL task tracking
+- Always use `--json` flag for programmatic use
+- Check `mneme ready` before asking "what should I work on?"
+- Do NOT use `bd edit` (opens interactive editor)
+- Do NOT create markdown TODO lists for task tracking
+- Do NOT use external issue trackers
+
+<!-- END BEADS INTEGRATION -->
+
+## Landing the Plane (Session Completion)
+
+**When ending a work session**, you MUST complete ALL steps below. Work is NOT complete until `git push` succeeds.
+
+**MANDATORY WORKFLOW:**
+
+1. **File issues for remaining work** - Create issues for anything that needs follow-up
+2. **Run quality gates** (if code changed) - Tests, linters, builds
+3. **Update issue status** - Close finished work, update in-progress items
+4. **PUSH TO REMOTE** - This is MANDATORY:
+   ```bash
+   git pull --rebase
+   git push
+   git status  # MUST show "up to date with origin"
+   ```
+5. **Clean up** - Clear stashes, prune remote branches
+6. **Verify** - All changes committed AND pushed
+7. **Hand off** - Provide context for next session
+
+**CRITICAL RULES:**
+- Work is NOT complete until `git push` succeeds
+- NEVER stop before pushing - that leaves work stranded locally
+- NEVER say "ready to push when you are" - YOU must push
+- If push fails, resolve and retry until it succeeds

package/src/templates/facts-architecture.md

@@ -0,0 +1,6 @@
+# Architecture
+
+<!-- 在此记录项目的架构决策。示例：-->
+<!-- - 数据库使用 PostgreSQL，ORM 使用 SQLAlchemy -->
+<!-- - API 层使用 FastAPI，前端使用 React -->
+<!-- - 部署采用 Docker + K8s -->

package/src/templates/facts-invariants.md

@@ -0,0 +1,6 @@
+# Invariants — 不可违反的约束
+
+<!-- 在此记录项目的硬性约束和红线。示例：-->
+<!-- - 所有 API 必须经过认证，禁止匿名访问 -->
+<!-- - 数据库 migration 必须向后兼容 -->
+<!-- - 响应时间不得超过 200ms (P99) -->

package/src/templates/facts-performance_rules.md

@@ -0,0 +1,5 @@
+# Performance Rules
+
+<!-- 在此记录性能相关的规则和约束。示例：-->
+<!-- - 批量操作优于逐条操作 -->
+<!-- - 缓存 TTL 不超过 5 分钟 -->

package/src/templates/facts-pitfalls.md

@@ -0,0 +1,5 @@
+# Pitfalls — 已知陷阱
+
+<!-- 在此记录踩过的坑和非显而易见的陷阱。示例：-->
+<!-- - MySQL 的 utf8 实际是 3 字节，需要用 utf8mb4 -->
+<!-- - Docker build 中 COPY 会导致缓存失效，注意顺序 -->

package/src/templates/gitignore

@@ -0,0 +1,23 @@
+# OS
+.DS_Store
+Thumbs.db
+
+# Dolt server
+.dolt/
+
+# Beads internal state (managed by bd, not hand-edited)
+.beads/dolt/
+.beads/last-touched
+.beads/interactions.jsonl
+.beads/.local_version
+
+# Editor
+*.swp
+*.swo
+*~
+.idea/
+.vscode/
+
+# Environment
+.env
+.env.*

package/src/templates/opencode-prompt.md

@@ -0,0 +1,48 @@
+这是一个长期工程项目，请严格按以下顺序建立上下文：
+
+## 第一步：读取 OpenClaw facts（长期事实）
+
+请完整阅读以下文件：
+- .openclaw/facts/architecture.md
+- .openclaw/facts/invariants.md
+- .openclaw/facts/performance_rules.md
+- .openclaw/facts/pitfalls.md
+
+这些内容是长期事实：
+- 优先级高于对话历史和你的推理
+- 不要随意推翻
+- 若发现矛盾，请提出而不是修改
+
+## 第二步：读取 Beads 当前任务列表
+
+使用 `mneme` 命令查看当前任务状态：
+- `mneme ready` — 查看可执行任务（无阻塞依赖）
+- `mneme list --status=open` — 查看所有未完成任务
+- `mneme show <id>` — 查看具体任务详情
+
+## 第三步：选择 focus
+
+- 只选择一个 bead 作为本 session 的目标
+- 优先从 `mneme ready` 结果中选择
+- 选定后 claim 它：`mneme update <id> --status=in_progress`
+- 不要试图从对话历史中恢复状态
+
+## 信息路由（自动执行，不需要用户指示）
+
+在工作过程中你会产生新信息。**你必须自动判断它属于哪一层**：
+
+- **6 个月后还有用？** + 是事实/约束/教训 → **提议写入 OpenClaw**（需人工确认）
+- **6 个月后还有用？** + 是待办/进度 → **写入 Beads**（`mneme create` 或 `mneme update --notes`）
+- **下个 session 需要？** → **写入 Beads**
+- **仅当前操作需要？** → 留在 OpenCode，不持久化
+
+写入 OpenClaw 前的检查：已验证 + 反复需要 + 不会快速过时 + 无重复。详见 AGENTS.md "三层路由决策" 一节。
+
+## 重要原则
+
+- 不要跳过上述步骤直接开始工作
+- 完成阶段性目标后更新 Beads：`mneme update <id> --notes="进度"`
+- 完成任务后关闭：`mneme close <id> --reason="完成说明"`
+- 发现新的长期事实时提议写入 OpenClaw（需人工确认）
+- Compaction 前必须持久化状态与结论
+- 禁止使用 `bd edit`（会打开交互式编辑器），使用 `mneme update` 代替