@heyamiko/amiko-cli 0.14.0-beta.20 → 0.14.0-beta.21

package/README.md

@@ -259,6 +259,9 @@ amiko chat send "Trip planning" "standup in 5 @all" --yes     # @all — notifie
 amiko chat send "Trip planning" "standup in 5" --all --yes    # same, via the explicit flag
 amiko chat send @sophie "look 👀" --image ./cat.png --yes         # attach a local image
 amiko chat send @sophie "made this 🎵" --audio <generated-url> --yes  # attach audio (e.g. from `amiko create`)
+amiko chat send @sophie --gif "happy dance" --yes                 # send the top Klipy GIF for a search (message optional)
+amiko chat gifs "happy dance"                    # browse GIFs first, then send a specific one:
+amiko chat send @sophie "we did it!" --gif <gifUrl> --yes         # attach an exact GIF by its Klipy URL
 amiko chat receipts <messageId>                  # who read your message + when (id from `chat read`)
 amiko chat pin <messageId> --yes                 # pin for everyone (id from `chat read`; groups: admins only)
 amiko chat unpin <messageId> --yes               # remove a pin for everyone
@@ -267,7 +270,8 @@ amiko chat pinned "Trip planning"                # list a conversation's pinned
 
 - **`<target>`** for `read`/`send` is a **conversation id** (from `chat list` — use this for groups), a **user id**, an **`@handle`**, or a **name**. Names resolve against your **friends first**, then people search; if ambiguous, the CLI lists candidates instead of guessing. A cuid that isn't one of your conversations is retried as a user id, so pasting a user id "just works".
 - `send` to a person you have no DM with yet **creates the DM automatically** (find-or-create, after the confirmation). `read` never creates one — it errors if no DM exists yet.
-- **Inline media**: `--image <pathOrUrl>` (jpg/png/webp/gif, local ≤10MB or an Amiko URL) and `--audio <pathOrUrl>` (local ≤25MB or an Amiko URL → sent as a voice note). One media block per message (image *or* audio). **Video isn't supported in chat yet.** A local file is uploaded; an Amiko URL (e.g. a generated asset from `amiko create`) attaches directly with no re-upload. (A local *audio* file is sent as a voice note, with your text as a separate message.)
+- **Inline media**: `--image <pathOrUrl>` (jpg/png/webp/gif, local ≤10MB or an Amiko URL), `--audio <pathOrUrl>` (local ≤25MB or an Amiko URL → sent as a voice note), and `--gif <queryOrUrl>` (search words send the **top Klipy result**; or pass an exact Klipy URL from `amiko chat gifs` — non-Klipy URLs are refused; to send another image, use `--image` with a local file or an Amiko URL). One media block per message (image *or* audio *or* gif). **General video files aren't supported in chat yet.** A local file is uploaded; an Amiko URL (e.g. a generated asset from `amiko create`) attaches directly with no re-upload. (A local *audio* file is sent as a voice note, with your text as a separate message.)
+- **GIFs**: `amiko chat gifs [query]` lists Klipy GIFs (trending with no query; `--page`/`--limit`/`--raw`) — read-only and ungated, powered by KLIPY. The message text is optional with `--gif` (a captionless GIF sends as just the GIF); a caption renders under the GIF on every client.
 - **@all in groups**: `--all` prepends an @all mention, and a standalone `@all` word typed in the message converts too — either way **every member** is notified. Group **admins/owners** can always use it; everyone else only after an admin runs `amiko chat group mention-all <group> on`. Without permission, `--all` fails with the fix named, while a typed `@all` is delivered as plain text (with a note). Incoming mention markup renders as plain `@name`/`@all` in `chat read` and `chat list`.
 - `chat send` messages a real person, so it's **gated on `--yes`** in non-interactive shells. Delivery is real-time. `--raw` prints raw JSON on any subcommand.
 - **`chat receipts <messageId>`** shows read receipts for **your own** messages (server-enforced; 403 otherwise): sent time, who read it with each person's first-read time, and who it was delivered to but hasn't read. Reads from before receipts tracking show as "exact time unknown". Read-only, ungated.
@@ -597,6 +601,10 @@ npm publish
 
 ## Changelog
 
+### 0.14.0-beta.21
+
+- **Chat GIFs: `amiko chat gifs [query]` + `amiko chat send --gif <queryOrUrl>`.** `chat gifs` browses Klipy GIFs via the platform proxy (`GET /api/gifs`; trending with no query, `--page`/`--limit`/`--raw`, "Powered by KLIPY") — read-only and ungated. `chat send --gif` attaches a GIF to a message: search words send the top result, a Klipy URL (from `chat gifs`) attaches exactly, and non-Klipy URLs are refused. Sends use the cross-client GIF contract — Klipy mp4/webm → `message_type: "video"` + `metadata.videos`, `.gif` → `"image"` + `metadata.images`, each record `{url, name, contentType, kind: "gif", width?, height?}` — so web/desktop/mobile render a looping watermarked GIF. The `<message>` positional is now optional when `--gif` is present (`content` falls back to `"GIF"`); captions ride as `metadata.image_caption`, which the `--image` path now also sets so image captions actually display in bubbles. One media block per message (`--image`/`--audio`/`--gif` are mutually exclusive). Requires the companion amiko-web `feat/chat-gif-picker` deploy (`GET /api/gifs`) — the twin token already authenticates against it, so no other backend work is needed.
+
 ### 0.14.0-beta.20
 
 - **Draft posts: `amiko post create --draft`, `amiko post drafts`, `amiko post publish <postId>`.** `--draft` saves via `POST /api/posts { status: "draft" }` — no side effects fire and no share URL is printed (drafts 404 by id until published; success copy says "Draft saved" with a publish hint, and `post_url` is omitted from `--json`). `drafts` lists the owner's draft posts (`GET /api/posts?status=draft`, offset pagination via `--limit`/`--offset`; owner-wide across all the owner's twins). `publish` PATCHes `{ status: "published" }`, stamps a fresh timestamp, fires mention/hashtag notifications, and prints the canonical share URL; a 404 points at `amiko post drafts` since drafts can't be fetched by id. Requires the amiko-web draft-posts API (`feat/draft-posts`).

package/dist/index.js

@@ -27671,6 +27671,102 @@ function registerChatGroupCommand(group) {
   });
 }
 
+// src/lib/gifs.ts
+function parseUrl(url2) {
+  try {
+    return new URL(url2);
+  } catch {
+    return null;
+  }
+}
+function isKlipyMediaUrl(url2) {
+  const parsed = parseUrl(url2);
+  if (!parsed)
+    return false;
+  return parsed.hostname === "klipy.com" || parsed.hostname.endsWith(".klipy.com");
+}
+var KLIPY_VIDEO_EXTENSION_RE = /\.(?:mp4|webm)(?:[?#].*)?$/i;
+function isKlipyVideoMediaUrl(url2) {
+  if (!isKlipyMediaUrl(url2))
+    return false;
+  const parsed = parseUrl(url2);
+  if (!parsed)
+    return false;
+  return KLIPY_VIDEO_EXTENSION_RE.test(parsed.pathname);
+}
+async function searchGifs(auth, q, page = 1) {
+  return amikoWebFetch(auth, "/api/gifs", {
+    query: { q, page }
+  });
+}
+function urlBasename(url2) {
+  const last = parseUrl(url2)?.pathname.split("/").pop();
+  if (!last)
+    return "GIF";
+  try {
+    return decodeURIComponent(last);
+  } catch {
+    return last;
+  }
+}
+function gifToMetadata(gif) {
+  return {
+    url: gif.url,
+    name: gif.title || urlBasename(gif.url),
+    contentType: isKlipyVideoMediaUrl(gif.url) ? "video/mp4" : "image/gif",
+    kind: "gif",
+    ...gif.width && gif.height ? { width: gif.width, height: gif.height } : {}
+  };
+}
+
+// src/commands/chat-gifs.ts
+var DEFAULT_LIMIT = 10;
+var MAX_TITLE = 40;
+function clampLimit(raw) {
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n))
+    return DEFAULT_LIMIT;
+  return Math.min(24, Math.max(1, n));
+}
+function truncate(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+function registerChatGifsCommand(chat) {
+  chat.command("gifs [query]").description("Search Klipy GIFs (trending when no query) — pass a result URL to `amiko chat send --gif`").option("--page <n>", "Result page (24 per page)", "1").option("--limit <n>", "Max results shown (1-24)", String(DEFAULT_LIMIT)).option("--raw", "Output raw JSON").action(async (query, opts) => {
+    const auth = authOrExit();
+    const q = query?.trim() ?? "";
+    const page = Math.max(1, Number.parseInt(opts.page, 10) || 1);
+    let data;
+    try {
+      data = await searchGifs(auth, q, page);
+    } catch (e5) {
+      console.error(error(e5 instanceof Error ? e5.message : "GIF search failed"));
+      process.exit(1);
+    }
+    renderOutput(data, (d) => {
+      const items = (d.items ?? []).slice(0, clampLimit(opts.limit));
+      if (items.length === 0) {
+        console.log(dim(q ? `No GIFs found for "${q}".` : "No trending GIFs."));
+        console.log(dim("Powered by KLIPY"));
+        return;
+      }
+      console.log(heading(q ? `GIFs matching "${q}" (page ${d.page})` : `Trending GIFs (page ${d.page})`));
+      const rows = [
+        [dim("TITLE"), dim("SIZE"), dim("URL")],
+        ...items.map((gif) => [
+          truncate(gif.title || "GIF", MAX_TITLE),
+          gif.width && gif.height ? `${gif.width}x${gif.height}` : "-",
+          gif.gifUrl
+        ])
+      ];
+      console.log(table(rows));
+      console.log(dim(`
+Send one: amiko chat send <target> --gif <url>${d.hasNext ? `  (more: --page ${d.page + 1})` : ""}`));
+      console.log(dim("Powered by KLIPY"));
+    }, { json: opts.raw });
+  });
+}
+
 // src/commands/chat.ts
 var PIN_LIMIT = 20;
 function pinErrorMessage(e5, fallback2) {
@@ -27789,6 +27885,7 @@ async function resolveConversation(auth, target) {
   return person({ id: p.userId, name: p.name, handle: p.handle });
 }
 var HTTPS_RE = /^https:\/\//i;
+var URL_SHAPED_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
 var CHAT_IMAGE_MIME = new Set([
   "image/jpeg",
   "image/jpg",
@@ -27921,10 +28018,15 @@ function registerChatCommand(chat) {
       }
     }
   });
-  chat.command("send <target> <message>").description("Send a message as yourself (the owner) to a conversation or person (conversation id, user id, @handle, or name — DMs are opened automatically)").option("--image <pathOrUrl>", "Attach an image: local file (jpg/png/webp/gif, ≤10MB) or an Amiko URL (e.g. from `amiko create`)").option("--audio <pathOrUrl>", "Attach audio as a voice note: local file (≤25MB) or an Amiko URL").option("--all", "Mention @all — notifies every member of the group (admins/owners always; others only when enabled via `amiko chat group mention-all`)").option("--yes", "Skip the confirmation (required in non-interactive shells)").option("--raw", "Output raw JSON").action(async (target, message, opts) => {
+  chat.command("send <target> [message]").description("Send a message as yourself (the owner) to a conversation or person (conversation id, user id, @handle, or name — DMs are opened automatically). The message is optional only with --gif.").option("--image <pathOrUrl>", "Attach an image: local file (jpg/png/webp/gif, ≤10MB) or an Amiko URL (e.g. from `amiko create`)").option("--audio <pathOrUrl>", "Attach audio as a voice note: local file (≤25MB) or an Amiko URL").option("--gif <queryOrUrl>", "Attach a GIF: search words (sends the top Klipy result) or a Klipy URL from `amiko chat gifs`").option("--all", "Mention @all — notifies every member of the group (admins/owners always; others only when enabled via `amiko chat group mention-all`)").option("--yes", "Skip the confirmation (required in non-interactive shells)").option("--raw", "Output raw JSON").action(async (target, message, opts) => {
     const auth = authOrExit();
-    if (opts.image && opts.audio) {
-      console.error(error("Attach either --image or --audio, not both (one media block per message)."));
+    const mediaFlagCount = [opts.image, opts.audio, opts.gif].filter(Boolean).length;
+    if (mediaFlagCount > 1) {
+      console.error(error("Attach only one of --image, --audio, or --gif (one media block per message)."));
+      process.exit(1);
+    }
+    if (message === undefined && !opts.gif) {
+      console.error(error("A message is required (it may only be omitted when sending a GIF with --gif)."));
       process.exit(1);
     }
     let resolved;
@@ -27935,9 +28037,10 @@ function registerChatCommand(chat) {
       process.exit(1);
     }
     const wantsAll = Boolean(opts.all);
-    let outgoing = message;
+    const messageText = message ?? "";
+    let outgoing = messageText;
     let mentionAllActive = false;
-    if (wantsAll || hasMentionAllLiteral(message) || hasMentionAllToken(message)) {
+    if (wantsAll || hasMentionAllLiteral(messageText) || hasMentionAllToken(messageText)) {
       const plainTextNote = "Note: @all only notifies people in group chats — sending it as plain text.";
       let conv = null;
       if (resolved.kind === "conversation") {
@@ -27961,19 +28064,45 @@ function registerChatCommand(chat) {
         }
         console.log(dim('Note: you don\'t have @all permission in this group — "@all" goes out as plain text. An admin can enable it with `amiko chat group mention-all <group> on`.'));
       } else {
-        outgoing = rewriteMentionAllLiteral(message);
+        outgoing = rewriteMentionAllLiteral(messageText);
         if (wantsAll)
           outgoing = applyMentionAll(outgoing);
         mentionAllActive = true;
       }
     }
-    const media = opts.image ? `image ${opts.image}` : opts.audio ? `audio ${opts.audio}` : "";
+    let gifAttachment = null;
+    if (opts.gif) {
+      try {
+        if (URL_SHAPED_RE.test(opts.gif)) {
+          if (!HTTPS_RE.test(opts.gif) || !isKlipyMediaUrl(opts.gif)) {
+            throw new Error("--gif accepts search words or an https Klipy URL (from `amiko chat gifs`). For other images use --image with a local file or an Amiko URL.");
+          }
+          gifAttachment = gifToMetadata({ url: opts.gif });
+        } else {
+          const results = await searchGifs(auth, opts.gif);
+          const top = results.items?.[0];
+          if (!top) {
+            throw new Error(`No GIFs found for "${opts.gif}" — try different words or browse with \`amiko chat gifs\`.`);
+          }
+          gifAttachment = gifToMetadata({
+            url: top.gifUrl,
+            title: top.title,
+            width: top.width,
+            height: top.height
+          });
+        }
+      } catch (e5) {
+        console.error(error(e5 instanceof Error ? e5.message : "Could not resolve the GIF"));
+        process.exit(1);
+      }
+    }
+    const media = opts.image ? `image ${opts.image}` : opts.audio ? `audio ${opts.audio}` : gifAttachment ? `gif "${gifAttachment.name.slice(0, 40)}"` : "";
     const shown = mentionMarkupToPlainText(outgoing);
     await requireApproval({
       free: "sends a message as you (the owner) — the recipients see it",
       summary: `Send to ${resolved.label}${media ? ` [+${media}]` : ""}${mentionAllActive ? " [@all — notifies every member]" : ""}: ${shown.slice(0, 80)}${shown.length > 80 ? "…" : ""}`,
       yes: opts.yes,
-      commandExample: `amiko chat send ${JSON.stringify(target)} ${JSON.stringify(message)}${opts.all ? " --all" : ""}`
+      commandExample: `amiko chat send ${JSON.stringify(target)}${message !== undefined ? ` ${JSON.stringify(message)}` : ""}${opts.image ? ` --image ${JSON.stringify(opts.image)}` : ""}${opts.audio ? ` --audio ${JSON.stringify(opts.audio)}` : ""}${opts.gif ? ` --gif ${JSON.stringify(opts.gif)}` : ""}${opts.all ? " --all" : ""}`
     });
     let convId;
     try {
@@ -27990,9 +28119,22 @@ function registerChatCommand(chat) {
     });
     let data;
     try {
-      if (opts.image) {
+      if (gifAttachment) {
+        const isVideo = isKlipyVideoMediaUrl(gifAttachment.url);
+        data = await post({
+          content: outgoing || "GIF",
+          message_type: isVideo ? "video" : "image",
+          metadata: {
+            [isVideo ? "videos" : "images"]: [gifAttachment],
+            image_caption: outgoing || null
+          }
+        });
+      } else if (opts.image) {
         const img = HTTPS_RE.test(opts.image) ? { url: opts.image, name: urlName(opts.image) } : await uploadChatImage(auth, convId, opts.image);
-        data = await post({ content: outgoing, metadata: { images: [img] } });
+        data = await post({
+          content: outgoing,
+          metadata: { images: [img], image_caption: outgoing || null }
+        });
       } else if (opts.audio) {
         if (HTTPS_RE.test(opts.audio)) {
           data = await post({
@@ -28015,7 +28157,7 @@ function registerChatCommand(chat) {
       console.log(JSON.stringify(data, null, 2));
       return;
     }
-    const what = opts.image ? "Message + image sent" : opts.audio ? "Message + voice note sent" : "Message sent";
+    const what = opts.image ? "Message + image sent" : opts.audio ? "Message + voice note sent" : gifAttachment ? outgoing ? "Message + GIF sent" : "GIF sent" : "Message sent";
     console.log(success(what) + dim(` (conversation ${convId.slice(0, 8)}…)`));
   });
   chat.command("react <messageId> <emoji>").description("React to a message as yourself (the owner). Get the message id from `amiko chat read`. One reaction per message — a new emoji replaces your previous one.").option("--yes", "Skip the confirmation (required in non-interactive shells)").option("--raw", "Output raw JSON").action(async (messageId, emojiArg, opts) => {
@@ -28296,6 +28438,7 @@ function registerChatCommand(chat) {
       }
     }
   });
+  registerChatGifsCommand(chat);
   const group = chat.command("group").description("Group chats — create, list, info, rename, add/remove members, @all permission, leave");
   registerChatGroupCommand(group);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heyamiko/amiko-cli",
-  "version": "0.14.0-beta.20",
+  "version": "0.14.0-beta.21",
   "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 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, generate media — images, video, speech, music, and SFX — via Create Studio (`amiko create`, async and charged on success), call paid MPP marketplace services (X/Twitter search, Amazon product search, TTS/STT, AI chat), manage the twin's identity and drive (files, folders, RAG), voice and avatar, and social graph (friends, posts, comments, feed). Auth is automatic when run from the agent's workspace folder; payments are platform-custodied (no keys on disk). The owner's DMs and group chats are `amiko chat` (list / read / send / create + manage group chats AS the owner, including sharing a group's invite/join link + QR and @all group announcements, 人对人); the agent's OWN sessions are the openhermit gateway's session_list / session_send (AS the agent) — different identities, different surfaces. Use this skill whenever the user asks about their Amiko notifications, chats/DMs, drive, memory, social graph, wallets, credits, or marketplace services — 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 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, generate media — images, video, speech, music, and SFX — via Create Studio (`amiko create`, async and charged on success), call paid MPP marketplace services (X/Twitter search, Amazon product search, TTS/STT, AI chat), manage the twin's identity and drive (files, folders, RAG), voice and avatar, and social graph (friends, posts, comments, feed). Auth is automatic when run from the agent's workspace folder; payments are platform-custodied (no keys on disk). The owner's DMs and group chats are `amiko chat` (list / read / send / create + manage group chats AS the owner, including sending GIFs (`chat gifs` search + `chat send --gif`), sharing a group's invite/join link + QR and @all group announcements, 人对人); the agent's OWN sessions are the openhermit gateway's session_list / session_send (AS the agent) — different identities, different surfaces. Use this skill whenever the user asks about their Amiko notifications, chats/DMs, drive, memory, social graph, wallets, credits, or marketplace services — anything that would show up in their Amiko account or cost AMIKO/credits.
 homepage: https://platform.heyamiko.com
 metadata: {"openclaw":{"emoji":"🤖","requires":{"bins":["node"]}}}
 ---
@@ -35,6 +35,7 @@ Call your shell tool (your runtime calls it `bash`, `shell`, `run`, or similar)
 | "publish that draft" | shell → `amiko post drafts` (copy the id) → `amiko post publish <postId>` |
 | "search memory for X" | shell → `amiko memory search "X"` |
 | "share the group's invite link" (asked by an admin) | shell → `amiko chat group info "<group>"` (confirm they're admin) → `amiko chat group invite "<group>"` |
+| "send Sophie a happy-dance GIF" | shell → `amiko chat send Sophie --gif "happy dance" --yes` (top result; to pick a specific one, browse `amiko chat gifs "happy dance"` first and pass its URL to `--gif`) |
 | "react to the latest message from Ava about the team with a heart" | shell → `amiko chat read "Ava"` (find that message, copy its `id`) → `amiko chat react <messageId> ❤️ --yes` |
 | "did Sophie read my message about the demo?" | shell → `amiko chat read "Sophie"` (find the owner's message, copy its `id`) → `amiko chat receipts <messageId>` |
 | "pin that hackathon message in the builders group" | shell → `amiko chat read "<group>"` (find the message, copy its `id`) → `amiko chat pin <messageId> --yes` |
@@ -150,7 +151,8 @@ MiniMax Hailuo is silent — there is no CLI mux step to attach a separate music
 - `amiko chat list` — all conversations, **DMs and group chats** (id, type, peer/title, last message, unread).
 - `amiko chat read <target>` — recent messages. `<target>` = a conversation id (from `list`), a **user id**, an `@handle`, or a name. Reading never creates a conversation — if there's no DM with that person yet, it says so.
 - `amiko chat send <target> "message"` — send **as the owner**. Delivered in real time. `--yes` required in non-interactive shells (it's an outward message to a real person). `<target>` = a conversation id, a **user id**, an `@handle`, or a name. A user id / @handle / unambiguous name opens (or reuses) the DM for you — but only **after** the owner approves the send (via the confirmation, or `--yes` in your shell); nothing is created if approval is refused. **The owner never needs to start the conversation first, and there is no platform authorization step for starting a DM.** For **group chats**, use the conversation id from `list`. **@all in groups:** add `--all` (or write a standalone `@all` word in the message) to notify **every member** — allowed for group admins/owners, or for everyone once an admin enables it (`amiko chat group mention-all <group> on`). The CLI pre-checks permission: `--all` without it fails and names the fix; a plain `@all` word still sends, as ordinary text, with a note. It pings the whole group — use it only when the owner clearly wants everyone notified.
-- **Inline media**: `--image <pathOrUrl>` (jpg/png/webp/gif, local ≤10MB or an Amiko URL — e.g. a generated image) and `--audio <pathOrUrl>` (local ≤25MB or an Amiko URL → sent as a voice note). One media block per message (image XOR audio). **Video is not supported** on chat yet. To share a generated asset, pass its URL from `amiko create status` (no re-upload). A local audio file is sent as a voice note with the text as a separate message.
+- **Inline media**: `--image <pathOrUrl>` (jpg/png/webp/gif, local ≤10MB or an Amiko URL — e.g. a generated image), `--audio <pathOrUrl>` (local ≤25MB or an Amiko URL → sent as a voice note), and `--gif <queryOrUrl>` (see GIFs below). One media block per message (image XOR audio XOR gif). **General video files are not supported** on chat yet. To share a generated asset, pass its URL from `amiko create status` (no re-upload). A local audio file is sent as a voice note with the text as a separate message.
+- **GIFs** — `amiko chat send <target> --gif "<search words>"` sends the **top Klipy result** for those words (the message text is optional with `--gif`; when present it becomes the GIF's caption). To send a *specific* GIF, browse first with `amiko chat gifs "<search words>"` (trending when no query; `--page`/`--limit`/`--raw`; read-only and ungated) and pass the chosen result's URL to `--gif`. Only Klipy URLs are accepted there — any other image must go through `--image` as a local file or an Amiko URL (arbitrary external URLs aren't supported). Recipients on web/desktop/mobile see a looping GIF (with the KLIPY watermark), so this is the right tool when the owner asks to "send a GIF" — don't generate media with `amiko create` for that. The send itself stays `--yes`-gated like every `chat send`.
 - Plain names resolve against the owner's **friends first**, then people search; if ambiguous the CLI errors listing the candidates — ask the owner which one, don't blind-send. A plain name that exactly matches one of the owner's group titles targets that **group**. If a send fails, surface the CLI's error verbatim — don't invent permission explanations or ask the owner to open the chat from the app.
 - **Reactions** — `amiko chat react <messageId> <emoji>`, `amiko chat unreact <messageId>`, `amiko chat reactions <messageId>`. The owner **won't give you a message id** — they'll say something like *"react to the latest Ava message about the team with a heart"*. Get ids from `amiko chat read <target>`: it prints each message's `id` and any existing reactions — match the message by its **content**, then act on that id. `react` adds (or replaces) your reaction — **one per message**, a new emoji replaces the previous one, and re-reacting the same emoji is a no-op (use `unreact` to remove). Pass the **actual emoji character** (`❤️`, `👍`, `😂`). `react`/`unreact` are outward (other people see them), so `--yes` is required in non-interactive shells and the confirmation shows a preview of the target message; `reactions` (read) is ungated. These act **as the owner** (人对人), just like `chat send` — not the twin's own `session_*`.
 - **Read receipts** — `amiko chat receipts <messageId>` shows when the message was sent, who has read it (with each person's first-read time), and who it was delivered to but hasn't read yet. **Only works for messages the owner sent** (server-enforced) — a 403 means it wasn't the owner's message; report that, don't retry. Get the id from `amiko chat read <target>`, matching the message by its **content**. Read-only and ungated, like `reactions`. Rows marked "exact time unknown" were read before receipts tracking existed — never invent a time for them.