@memfork/cli 0.1.51 → 0.1.53

package/dist/commands/install.js

@@ -200,9 +200,12 @@ network_access = true
     // ── Summary (Codex) ────────────────────────────────────────────────────────
     console.log("");
     console.log(tip("The agent now has:"));
-    console.log(dim("    memwal_recall / memwal_remember  — memory storage via MemWal MCP"));
-    console.log(dim("    memwal_analyze                   — extract facts from conversation"));
-    console.log(dim("    memfork commit / merge           — on-chain DAG anchoring"));
+    console.log(dim("    memwal_recall          — semantic memory recall via MemWal MCP"));
+    console.log(dim("    memfork commit / merge — the only write path: MemWal + on-chain anchor"));
+    console.log("");
+    console.log(dim("    Raw MemWal writes (remember / remember_bulk / analyze) are disabled"));
+    console.log(dim("    so every saved memory is anchored on Sui. Want raw, unanchored notes?"));
+    console.log(dim("    Install the standalone MemWal plugin alongside MemForks."));
     console.log("");
     console.log(tip("memfork doctor   — verify the full setup"));
     console.log("");
@@ -216,14 +219,23 @@ function upsertCodexMcp(tomlPath, creds) {
     if (fs.existsSync(tomlPath)) {
         existing = fs.readFileSync(tomlPath, "utf8");
     }
+    // `disabled_tools` denies the raw MemWal write tools so the agent cannot
+    // bypass the on-chain DAG. All persistence is forced through `memfork commit`
+    // (which writes MemWal *and* anchors on Sui). Recall + health + restore stay
+    // enabled. Users who want raw, unanchored memory can install the standalone
+    // MemWal plugin instead.
     const block = `
 [mcp_servers.memwal]
 url = "${creds.relayerUrl}"
 http_headers = { Authorization = "Bearer ${creds.delegateKey}", x-memwal-account-id = "${creds.accountId}" }
+disabled_tools = ["memwal_remember", "memwal_remember_bulk", "memwal_analyze"]
 `;
     if (existing.includes("[mcp_servers.memwal]")) {
-        // Replace the existing block — find from the header to the next blank line / EOF.
-        existing = existing.replace(/\[mcp_servers\.memwal\][^\[]*/s, block.trimStart());
+        // Replace the existing block — from the header through every following line
+        // that is NOT a new TOML table header (`[...]` at line start). This keeps
+        // inline arrays like `disabled_tools = [...]` intact instead of truncating
+        // at the first `[`.
+        existing = existing.replace(/^\[mcp_servers\.memwal\]\n(?:(?!\[)[^\n]*\n?)*/m, block.trimStart());
     }
     else {
         existing = existing.trimEnd() + "\n" + block;

package/dist/commands/ops.js

@@ -161,25 +161,26 @@ export async function cmdCommit(opts) {
         ...(artifacts.length > 0 ? { artifacts } : {}),
     });
     const out = { blobId, branch, artifacts: refs };
-    if (process.stdout.isTTY) {
+    // Always print the human-readable confirmation so agents and CI can recognise
+    // success without parsing JSON. In non-TTY contexts (subprocesses, pipes) we
+    // additionally emit the JSON on the following line for machine consumption.
+    console.log("");
+    console.log(chalk.green("✓") + " Committed to " + chalk.bold(branch));
+    console.log(chalk.dim(`  blob: ${blobId}`));
+    if (refs.length > 0) {
         console.log("");
-        console.log(chalk.green("✓") + " Committed to " + chalk.bold(branch));
-        console.log(chalk.dim(`  blob: ${blobId}`));
-        if (refs.length > 0) {
-            console.log("");
-            console.log(chalk.bold("  Artifacts:"));
-            for (const ref of refs) {
-                console.log(`    ${chalk.cyan(ref.path)}  ` +
-                    chalk.dim(`${(ref.size / 1024).toFixed(1)} KiB  `) +
-                    chalk.dim(`blob: ${ref.blobId.slice(0, 16)}…  `) +
-                    chalk.dim(`sha256: ${ref.sha256.slice(0, 16)}…`));
-                console.log(chalk.dim(`    Retrieve with: `) +
-                    chalk.white(`memfork cat ${ref.blobId} --output ${ref.path} --sha256 ${ref.sha256}`));
-            }
+        console.log(chalk.bold("  Artifacts:"));
+        for (const ref of refs) {
+            console.log(`    ${chalk.cyan(ref.path)}  ` +
+                chalk.dim(`${(ref.size / 1024).toFixed(1)} KiB  `) +
+                chalk.dim(`blob: ${ref.blobId.slice(0, 16)}…  `) +
+                chalk.dim(`sha256: ${ref.sha256.slice(0, 16)}…`));
+            console.log(chalk.dim(`    Retrieve with: `) +
+                chalk.white(`memfork cat ${ref.blobId} --output ${ref.path} --sha256 ${ref.sha256}`));
         }
-        console.log("");
     }
-    else {
+    console.log("");
+    if (!process.stdout.isTTY) {
         console.log(JSON.stringify(out));
     }
 }
@@ -695,12 +696,29 @@ export async function cmdBranch(name, opts = {}) {
     const { client, cfg } = await getClient();
     const from = resolveBranch({ explicit: opts.from, configDefault: cfg.defaultBranch });
     process.stdout.write(chalk.dim(`Creating branch ${chalk.green(name)} from ${chalk.green(from)} …  `));
-    const digest = await client.branch(name, { from });
-    console.log(chalk.green("done"));
-    console.log("");
-    console.log(chalk.dim(`  tx: ${digest}`));
-    console.log(chalk.dim(`  Run ${chalk.white("memfork checkout " + name)} to switch to it.`));
-    console.log("");
+    try {
+        const digest = await client.branch(name, { from });
+        console.log(chalk.green("done"));
+        console.log("");
+        console.log(chalk.dim(`  tx: ${digest}`));
+        console.log(chalk.dim(`  Run ${chalk.white("memfork checkout " + name)} to switch to it.`));
+        console.log("");
+    }
+    catch (err) {
+        // E_BRANCH_EXISTS (Move abort code 7) — treat as success so `memfork branch`
+        // is safe to run idempotently in scripts and runbooks.
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("MoveAbort") && msg.match(/,\s*7\)/)) {
+            console.log(chalk.dim("already exists"));
+            console.log("");
+            console.log(chalk.dim(`  Branch "${name}" is already on this tree — no action needed.`));
+            console.log(chalk.dim(`  Run ${chalk.white("memfork checkout " + name)} to switch to it.`));
+            console.log("");
+        }
+        else {
+            throw err;
+        }
+    }
 }
 // ─── checkout ─────────────────────────────────────────────────────────────────
 export async function cmdCheckout(name, opts = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memfork/cli",
-  "version": "0.1.51",
+  "version": "0.1.53",
   "description": "MemForks CLI — init, commit, recall, merge, install plugins",
   "repository": {
     "type": "git",

package/plugins/codex/plugins/memforks/.codex-plugin/plugin.json

@@ -19,7 +19,7 @@
     "agent-memory",
     "memwal"
   ],
-  "skills": "../skills/",
+  "skills": "./skills/",
   "interface": {
     "displayName": "MemForks",
     "shortDescription": "On-chain, branch-aware memory DAG",

package/plugins/codex/plugins/memforks/skills/memory-commit/SKILL.md

@@ -17,9 +17,11 @@ finding — **always use `memfork commit --facts`**, not `memwal_remember`.
 1. Indexes the facts in MemWal for semantic recall (same as `memwal_remember`)
 2. Anchors them on-chain on Sui, tagged to the current Git branch
 
-`memwal_remember` alone does only step 1. It saves to `namespace=default`
-with no branch scoping and no on-chain anchor. Use it only for transient,
-throwaway notes that don't warrant a permanent record.
+The raw MemWal write tools (`memwal_remember`, `memwal_remember_bulk`,
+`memwal_analyze`) are **disabled** under MemForks — they save to
+`namespace=default` with no branch scoping and no on-chain anchor, which
+defeats the purpose of a version-controlled memory DAG. `memfork commit` is
+the only write path, so every saved memory is provably anchored on Sui.
 
 ## Procedure
 
@@ -63,7 +65,8 @@ Do not print the full CLI output. One line is enough.
 
 ## Rules
 
-- Never use `memwal_remember` for facts the user explicitly asks to save.
+- The raw `memwal_remember*` / `memwal_analyze` tools are disabled — `memfork
+  commit` is the only way to persist memory. Never look for a workaround.
 - Never commit task state, in-progress work, or temporary findings.
 - If `memfork commit` fails (e.g. no tree initialised), tell the user to
   run `memfork init` first and offer to retry.

package/plugins/cursor/rules/memforks.mdc

@@ -55,8 +55,10 @@ a different branch.
 Use this after any significant turn: architectural decisions, resolved problems,
 project conventions, key constraints.
 
-Only use `memwal_remember` directly for a quick lightweight note that does **not**
-warrant an on-chain entry (e.g. a transient preference noted mid-task).
+Always persist memory with `memfork commit` — never `memwal_remember`. The raw
+MemWal write tools save to `namespace=default` with no branch scoping and no
+on-chain anchor, which bypasses the DAG. `memfork commit` indexes the same
+facts in MemWal *and* anchors them on Sui, so every memory is verifiable.
 
 Do **not** save: current task state, in-progress work, temporary findings.