@heyamiko/amiko-cli 0.9.9-beta.1 → 0.9.9-beta.4

package/dist/index.js

@@ -22013,7 +22013,7 @@ function registerNotificationsCommand(program2) {
 }
 
 // src/commands/memory.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "node:fs";
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
 import { dirname, isAbsolute, normalize, resolve as resolve2 } from "node:path";
 var VALID_CATEGORIES = ["fact", "preference", "pattern", "decision", "context"];
 var VALID_SOURCES = ["chat", "file", "manual"];
@@ -22184,13 +22184,18 @@ function registerMemoryCommand(program2) {
       fail(e instanceof Error ? e.message : String(e));
     }
   });
-  memory.command("sync").description("Sync MEMORY.md and referenced files to the platform (one-way: local → server)").option("--path <dir>", `Workspace dir containing MEMORY.md (default ${DEFAULT_WORKSPACE})`).option("--dry-run", "Print what would be synced without uploading").option("--prune", "Delete server-side memory files that no longer exist locally").option("--json", "Output as JSON").action(async (opts) => {
+  memory.command("sync").description("Sync MEMORY.md, its referenced files, and every .md under <workspace>/memory/ (one-way: local → server)").option("--path <dir>", `Workspace dir (default ${DEFAULT_WORKSPACE}). Looks for MEMORY.md, memory/MEMORY.md, and memory/**/*.md`).option("--dry-run", "Print what would be synced without uploading").option("--prune", "Delete server-side memory files that no longer exist locally").option("--json", "Output as JSON").action(async (opts) => {
     const root = resolve2(opts.path || DEFAULT_WORKSPACE);
-    const indexPath = resolve2(root, "MEMORY.md");
-    if (!existsSync3(indexPath)) {
-      fail(`MEMORY.md not found at ${indexPath}`);
-    }
-    const collected = collectMemoryFiles(root, indexPath);
+    const candidateIndexes = [
+      resolve2(root, "MEMORY.md"),
+      resolve2(root, "memory", "MEMORY.md")
+    ].filter((p) => existsSync3(p));
+    const memoryDir = resolve2(root, "memory");
+    const memoryDirExists = existsSync3(memoryDir) && statSync(memoryDir).isDirectory();
+    if (!candidateIndexes.length && !memoryDirExists) {
+      fail(`No MEMORY.md or memory/ folder found under ${root}. Expected ${root}/MEMORY.md or ${root}/memory/.`);
+    }
+    const collected = collectMemoryFiles(root, candidateIndexes, memoryDirExists ? memoryDir : null);
     if (collected.errors.length && !opts.json) {
       for (const e of collected.errors)
         console.error(error(e));
@@ -22273,37 +22278,72 @@ function registerMemoryCommand(program2) {
     }
   });
 }
-function collectMemoryFiles(root, indexPath) {
+function collectMemoryFiles(root, indexPaths, memoryDir) {
   const errors2 = [];
   const seen = new Set;
   const files = [];
-  const indexContent = safeRead(indexPath, errors2);
-  if (indexContent === null)
-    return { files, errors: errors2 };
-  pushFile(files, seen, indexPath, indexContent, root);
-  const indexDir = dirname(indexPath);
-  for (const ref of extractMarkdownLinks(indexContent)) {
-    if (isExternal(ref))
-      continue;
-    const abs = normalize(isAbsolute(ref) ? ref : resolve2(indexDir, ref));
-    if (!abs.startsWith(root)) {
-      errors2.push(`Skipping ${ref}: outside workspace ${root}`);
+  for (const indexPath of indexPaths) {
+    const indexContent = safeRead(indexPath, errors2);
+    if (indexContent === null)
       continue;
+    pushFile(files, seen, indexPath, indexContent, root);
+    const indexDir = dirname(indexPath);
+    for (const ref of extractMarkdownLinks(indexContent)) {
+      if (isExternal(ref))
+        continue;
+      const abs = normalize(isAbsolute(ref) ? ref : resolve2(indexDir, ref));
+      if (!abs.startsWith(root)) {
+        errors2.push(`Skipping ${ref}: outside workspace ${root}`);
+        continue;
+      }
+      if (!existsSync3(abs)) {
+        errors2.push(`Referenced file missing: ${ref}`);
+        continue;
+      }
+      const st = statSync(abs);
+      if (!st.isFile())
+        continue;
+      const content = safeRead(abs, errors2);
+      if (content === null)
+        continue;
+      pushFile(files, seen, abs, content, root);
     }
-    if (!existsSync3(abs)) {
-      errors2.push(`Referenced file missing: ${ref}`);
-      continue;
+  }
+  if (memoryDir) {
+    for (const abs of walkMarkdown(memoryDir, errors2)) {
+      const content = safeRead(abs, errors2);
+      if (content === null)
+        continue;
+      pushFile(files, seen, abs, content, root);
     }
-    const st = statSync(abs);
-    if (!st.isFile())
-      continue;
-    const content = safeRead(abs, errors2);
-    if (content === null)
-      continue;
-    pushFile(files, seen, abs, content, root);
   }
   return { files, errors: errors2 };
 }
+function walkMarkdown(dir, errors2) {
+  const out = [];
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch (e) {
+    errors2.push(`Failed to read ${dir}: ${e instanceof Error ? e.message : String(e)}`);
+    return out;
+  }
+  for (const name of names) {
+    const abs = resolve2(dir, name);
+    let st;
+    try {
+      st = statSync(abs);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) {
+      out.push(...walkMarkdown(abs, errors2));
+    } else if (st.isFile() && name.toLowerCase().endsWith(".md")) {
+      out.push(abs);
+    }
+  }
+  return out;
+}
 function pushFile(files, seen, abs, content, root) {
   const key = relativeKey(abs, root);
   if (seen.has(key))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heyamiko/amiko-cli",
-  "version": "0.9.9-beta.1",
+  "version": "0.9.9-beta.4",
   "description": "Amiko CLI — swap tokens, manage credits, bridge cross-chain, and call marketplace agents",
   "type": "module",
   "bin": {

package/skills/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: amiko-cli
-description: The Amiko CLI lets an agent act on the Amiko platform end-to-end — read and send platform DMs with other users (conversations list/find/read/send, the right tool when the owner asks "did X message me?" or "check my chat history with Y" — NOT the built-in sessions_list/sessions_history, which only see the agent's own local sessions), read platform notifications (friend requests, mentions, system alerts), manage Solana/Base wallets (create, swap via Jupiter, bridge USDC via Across, transfer tokens to external addresses), top up and spend credits, call paid MPP marketplace services (X/Twitter search, image generation, Amazon product search, TTS/STT, AI chat, SFX/music), manage the twin's identity and RAG documents, voice and avatar, social graph (friends, posts, comments, feed), and Composio OAuth connections. Auth is automatic when run from the agent's workspace folder; payments are platform-custodied (no keys on disk). Use this skill whenever the user asks about their Amiko inbox/DMs/notifications or to do anything that would show up in their Amiko account or cost AMIKO/credits.
+description: The Amiko CLI lets an agent act on the Amiko platform end-to-end — read and send platform DMs with other users (conversations list/find/read/send, the right tool when the owner asks "did X message me?" or "check my chat history with Y" — NOT the built-in sessions_list/sessions_history, which only see the agent's own local sessions), read platform notifications (friend requests, mentions, system alerts), search and write **cross-agent memories** about the owner (what other agents already know — preferences, decisions, facts), manage Solana/Base wallets (create, swap via Jupiter, bridge USDC via Across, transfer tokens to external addresses), top up and spend credits, call paid MPP marketplace services (X/Twitter search, image generation, Amazon product search, TTS/STT, AI chat, SFX/music), manage the twin's identity and RAG documents, voice and avatar, social graph (friends, posts, comments, feed), and Composio OAuth connections. Auth is automatic when run from the agent's workspace folder; payments are platform-custodied (no keys on disk). Use this skill whenever the user asks about their Amiko inbox/DMs/notifications or to do anything that would show up in their Amiko account or cost AMIKO/credits.
 homepage: https://platform.heyamiko.com
 metadata: {"openclaw":{"emoji":"🤖","requires":{"bins":["node"]}}}
 ---
@@ -34,6 +34,7 @@ Each row is a first-level command group or command. Start here when the user ask
 | `amiko composio <cmd>` | Connect / disconnect third-party OAuth apps (Gmail, GitHub, …) |
 | `amiko conversation <cmd>` | DM/chat — list, find, create, send messages |
 | `amiko notifications <cmd>` | Platform notifications — list, mark as read |
+| `amiko memory <cmd>` | Cross-agent memory — `search` before answering personal questions, `add` what's worth remembering, `list` / `rm` / `status` / `sync` local memory files |
 | `amiko accounts` | Show the resolved identity (authenticated, userId, twinId, platform) |
 | `amiko info` | Show the active twin (name, description, public, voice, avatar) |
 | `amiko config <cmd>` | Show resolved config |
@@ -298,6 +299,81 @@ amiko notifications read --all                        # mark all read
 
 Platform notifications cover friend requests, mentions, system alerts, and other activity that doesn't belong to any conversation. Use this when the user asks "any notifications?" or "what's new on the platform?". Notifications belonging to a conversation (new DM, comment on your post) still show up here when the platform writes one — they don't replace `conversation read` for actual chat content.
 
+## Memory (cross-agent)
+
+Memories are scoped to the **owner's `user_id`**, not to your individual agent — every agent the owner runs reads and writes the same pool. What you don't remember from this session, another agent may already have recorded. Three commands cover almost everything:
+
+- `amiko memory search "<query>"` — natural-language hybrid search (vector + FTS). Query in any language.
+- `amiko memory add "<content>" --category <cat>` — save a durable memory for cross-agent recall.
+- `amiko memory sync` — upload local `MEMORY.md` + `memory/**/*.md` so the platform extracts granular memories from them.
+
+```bash
+amiko memory search "git workflow" --limit 5         # ranked results with score
+amiko memory list --limit 25                         # newest-first, paginate with --offset
+amiko memory list --category preference              # filter: fact | preference | pattern | decision | context
+amiko memory list --source chat|file|manual          # filter by origin
+amiko memory add "Owner prefers terse PR descriptions" --category preference --tags pr,style
+amiko memory rm <memoryId>                           # soft-delete
+amiko memory status                                  # totals: memories + memory_files
+amiko memory sync                                    # one-way upload of local MEMORY.md + memory/**/*.md
+amiko memory sync --dry-run                          # show what would be uploaded
+amiko memory sync --prune                            # also delete server files that no longer exist locally
+```
+
+All `memory` commands support `--json`.
+
+### When to search — bias toward calling
+
+**Default assumption: the owner has stored context you don't have. Run `amiko memory search` BEFORE answering any question about them, their project, their preferences, or their history. A call that returns empty costs ~100ms; a missed hit makes you look amnesic and forces them to re-teach you every session.**
+
+The single most common failure mode is NOT calling `memory search` on abstract self-referential questions. If the owner's message has any of these shapes, you MUST search — no judgment, no exceptions:
+
+1. **Preference / habit questions**, even without a specific entity named.
+   Examples: "what do I usually use for X", "how do I normally do Y", "what's my preferred tool for Z", "what's my coding style". Pass a short paraphrase as the query.
+2. **Callbacks to prior context.** "as I mentioned", "like last time", "you know the one", "we discussed before", "what was that X we set up".
+3. **Named entities specific to this owner.** Their project / repo / service / team / tool name. A person by name.
+4. **Past bugs, decisions, investigations, design choices.**
+5. **Start of a new session** where they reference anything about themselves or their work.
+
+Do NOT search for:
+- Purely textbook programming questions with no owner-specific signal ("how does `useEffect` work", "what is the time complexity of quicksort").
+- Questions the current code or `git log` already answers directly.
+
+**When unsure, search.** Empty results cost you nothing. Missing the owner's context costs you their trust.
+
+### When to save
+
+Use `amiko memory add` after:
+
+- Fixing a non-obvious bug → save root cause + fix as `pattern` or `fact`
+- Making an architecture decision → save reasoning as `decision`
+- Discovering a useful pattern or workaround → `pattern`
+- Owner explicitly says "remember this" / "save this" / "from now on..." → match the category to the content
+- Learning a preference you'd otherwise have to re-ask ("I prefer rg", "I always use pnpm") → `preference`
+
+Write memories as **standalone sentences with full context** — include names, not pronouns. A future session will read this without knowing today's conversation. Bad: "He prefers it that way." Good: "William prefers terse PR descriptions in the Amiko-Layer repo."
+
+Categories:
+
+| Category | Use for |
+|----------|---------|
+| `fact` | Technical facts, API details, config values, stable facts about the owner |
+| `preference` | How they like things done (tone, formats, tools, coding style) |
+| `pattern` | Recurring patterns, pitfalls, team conventions, workarounds |
+| `decision` | Architecture decisions and their reasoning |
+| `context` | Project context, deadlines, ongoing work, transient state |
+
+Do NOT save:
+- Trivial facts obvious from the code itself or generic programming knowledge.
+- Ephemeral state already captured by `git log` / the current diff.
+- Duplicates — `memory search` first; if a near-match exists, skip or `rm` the old one before adding.
+
+### `source` and `sync` semantics
+
+`source` is set automatically: `manual` for `memory add`, `chat` for cron-extracted conversation memories, `file` for memories the platform extracted from a synced `MEMORY.md`/file.
+
+`sync` walks `<workspace>/MEMORY.md`, every markdown link inside it, **and** every `.md` under `<workspace>/memory/` (recursively). Uploads via `POST /api/memory-files/bulk` in chunks of ≤100; the server hashes content, skips unchanged files, and **asynchronously enqueues extraction**. Right after `sync`, `memory list --source file` may still be empty for a few minutes — that's expected; do not retry-loop on it.
+
 ## Composio
 
 ```bash