@heyamiko/amiko-cli 0.18.0 → 0.19.0

package/README.md

@@ -314,6 +314,10 @@ amiko chat send @sophie "made this 🎵" --audio <generated-url> --yes  # attach
 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 library --kind image                  # your Library (Create Studio creations) with refs
+amiko chat explore --search sunset               # public Explore media with refs
+amiko chat send @sophie "for review" --attach drive:<docId> --attach library:<id> --yes   # attach files you already have
+amiko chat send @sophie --attach explore:post:<postId>:0 --yes    # message optional with --attach
 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
@@ -324,7 +328,12 @@ amiko chat mark-read --all --yes                 # mark EVERY conversation as re
 - **`<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.
 - **Unread mentions & replies**: rows whose unread messages **concern you directly** get an `@you` marker next to the unread count, and `chat list --mentions` filters to just those. The flag is server-computed over your unread messages and covers three cases: a direct **@mention** of you, a permitted **@all** in a group, and a **reply to one of your messages**. Composes with `--limit`/`--archived`/`--raw` (the raw payload is filtered too). Requires the amiko-web `has_unread_mention` deploy. On an older server the field is absent and reads as **false for every conversation**: plain `chat list` still shows unread counts, just without `@you`, and `chat list --mentions` returns no matches.
-- **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.)
+- **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 of those per message (image *or* audio *or* gif) — `--image` can also be combined with `--attach` below. **Local video files aren't supported in chat yet** (Library/Explore videos are, via `--attach`). 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.)
+- **Attach from Drive, Library or Explore**: `--attach <ref>` (repeatable, up to 6 per message including `--image`) sends files you already have on Amiko — the same sources as the web composer's "Add from Drive" and "Add from Library or Explore". Nothing is re-uploaded.
+  - `drive:<docId>` — an **image or document** (pdf, docx, …, ≤25MB) from your Drive; ids from `amiko drive list --json` / `drive search`. Audio/video Drive files are refused. Sent as a file attachment that keeps its Drive `doc_id`.
+  - `library:<id>` — one of your Create Studio creations (image, video or audio); refs from `amiko chat library` (`--kind`, `--search`, `--limit`, `--cursor`, `--raw`).
+  - `explore:post:<postId>:<n>` — media from a public post on Explore; refs from `amiko chat explore` (same flags, minus `--twin`).
+  - Drive and Library use your current twin; `--twin <id>` picks another. The message text is optional with `--attach` (recipients see an "Image"/"Video"/"Audio"/"File" label). Library/Explore refs are checked before the confirmation; Drive files are validated and signed only after you approve, so a declined send leaves nothing behind. `--attach` can't be combined with `--audio` or `--gif`.
 - **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.
@@ -998,7 +1007,7 @@ Your conversations (DMs + group chats) as the owner — list, read, send, manage
 |---|---|
 | `chat list` | List your conversations (DMs and group chats) |
 | `chat read` | Read recent messages in a conversation (conversation id, user id, @handle, or name) |
-| `chat send` | 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. |
+| `chat send` | 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 or --attach. |
 | `chat react` | 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. |
 | `chat unreact` | Remove your (the owner's) reaction from a message. Get the message id from `amiko chat read`. |
 | `chat reactions` | Show the reactions on a message. Get the message id from `amiko chat read`. |
@@ -1008,6 +1017,8 @@ Your conversations (DMs + group chats) as the owner — list, read, send, manage
 | `chat pinned` | List a conversation's pinned messages, oldest first (conversation id, user id, @handle, or name) |
 | `chat mark-read` | Mark ALL conversations as read (requires --all). Clears every unread badge on the owner's devices; senders see read ticks. |
 | `chat gifs` | Search Klipy GIFs (trending when no query) — pass a result URL to `amiko chat send --gif` |
+| `chat library` | List your Library (Create Studio creations) — pass a ref to `amiko chat send --attach` |
+| `chat explore` | List recent public media from Explore — pass a ref to `amiko chat send --attach` |
 | `chat group` | Group chats — create, list, info, rename, add/remove members, @all permission, leave |
 | `chat lists` | Your chat lists (private folders of conversations) — run bare to see them; create, rename, add/remove conversations, delete |
 | `chat poll` | Chat polls — create, show, vote, retract your vote, close (as the owner) |
@@ -1034,13 +1045,15 @@ Read recent messages in a conversation (conversation id, user id, @handle, or na
 
 #### `amiko chat send <target> [message]`
 
-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.
+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 or --attach.
 
 | Flag | Default | Description |
 |---|---|---|
 | `--image <pathOrUrl>` |  | Attach an image: local file (jpg/png/webp/gif, ≤10MB) or an Amiko URL (e.g. from `amiko create`) |
 | `--audio <pathOrUrl>` |  | Attach audio as a voice note: local file (≤25MB) or an Amiko URL |
 | `--gif <queryOrUrl>` |  | Attach a GIF: search words (sends the top Klipy result) or a Klipy URL from `amiko chat gifs` |
+| `--attach <ref>` |  | Attach a file you already have on Amiko (repeatable, up to 6): drive:<docId> (image or document from `amiko drive list`), library:<id> (from `amiko chat library`), explore:post:<postId>:<n> (from `amiko chat explore`). Combines with --image. |
+| `--twin <id>` |  | Twin whose Drive/Library --attach reads (default: your current twin) |
 | `--all` |  | Mention @all — notifies every member of the group (admins/owners always; others only when enabled via `amiko chat group mention-all`) |
 | `--yes` |  | Skip the confirmation (required in non-interactive shells) |
 | `--raw` |  | Output raw JSON |
@@ -1125,6 +1138,31 @@ Search Klipy GIFs (trending when no query) — pass a result URL to `amiko chat
 | `--limit <n>` | `10` | Max results shown (1-24) |
 | `--raw` |  | Output raw JSON |
 
+#### `amiko chat library`
+
+List your Library (Create Studio creations) — pass a ref to `amiko chat send --attach`
+
+| Flag | Default | Description |
+|---|---|---|
+| `--twin <id>` |  | Twin whose Library to list (default: current twin) |
+| `--kind <kind>` |  | Only image, video, or audio |
+| `--search <text>` |  | Filter by prompt text |
+| `--limit <n>` | `20` | Items to fetch (1-50) |
+| `--cursor <cursor>` |  | Continue from a previous page |
+| `--raw` |  | Output raw JSON |
+
+#### `amiko chat explore`
+
+List recent public media from Explore — pass a ref to `amiko chat send --attach`
+
+| Flag | Default | Description |
+|---|---|---|
+| `--kind <kind>` |  | Only image, video, or audio |
+| `--search <text>` |  | Filter by title |
+| `--limit <n>` | `20` | Posts to fetch (1-96) |
+| `--cursor <cursor>` |  | Continue from a previous page |
+| `--raw` |  | Output raw JSON |
+
 #### `amiko chat group`
 
 Group chats — create, list, info, rename, add/remove members, @all permission, leave

package/dist/index.js

@@ -28902,6 +28902,392 @@ function registerChatGroupCommand(group) {
   });
 }
 
+// src/lib/chat-attachments.ts
+var MAX_CHAT_ATTACHMENTS = 6;
+var LIBRARY_PAGE_SIZE = 50;
+var MAX_LIBRARY_PAGES = 10;
+var REF_HELP = "Use drive:<docId> (ids from `amiko drive list --json`), library:<id> (from `amiko chat library`), or explore:post:<postId>:<n> (from `amiko chat explore`).";
+var REF_RE = /^(drive|library|explore):(.+)$/i;
+var EXPLORE_ID_RE = /^(?:post:)?(.+):(\d+)$/i;
+function parseAttachRef(raw) {
+  const value = raw.trim();
+  const match = REF_RE.exec(value);
+  const rest = match?.[2]?.trim() ?? "";
+  if (!match || !rest) {
+    throw new Error(`Unknown attachment "${raw}". ${REF_HELP}`);
+  }
+  const source = match[1].toLowerCase();
+  if (source === "drive")
+    return { source, raw: value, docId: rest };
+  if (source === "library")
+    return { source, raw: value, mediaId: rest };
+  const explore = EXPLORE_ID_RE.exec(rest);
+  if (!explore || !explore[1].trim()) {
+    throw new Error(`"${raw}" is not an Explore item. Explore refs look like explore:post:<postId>:<n> — copy one from \`amiko chat explore\`.`);
+  }
+  return {
+    source: "explore",
+    raw: value,
+    postId: explore[1].trim(),
+    index: Number.parseInt(explore[2], 10)
+  };
+}
+function refKey(ref) {
+  switch (ref.source) {
+    case "drive":
+      return `drive:${ref.docId}`;
+    case "library":
+      return `library:${ref.mediaId}`;
+    case "explore":
+      return `explore:${ref.postId}:${ref.index}`;
+  }
+}
+function parseAttachRefs(raws, extra = 0) {
+  const refs = [];
+  const seen = new Set;
+  for (const raw of raws) {
+    const ref = parseAttachRef(raw);
+    const key = refKey(ref);
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    refs.push(ref);
+  }
+  if (refs.length + extra > MAX_CHAT_ATTACHMENTS) {
+    throw new Error(`A message can carry at most ${MAX_CHAT_ATTACHMENTS} attachments (got ${refs.length + extra}).`);
+  }
+  return refs;
+}
+var VIDEO_EXT_RE = /\.(mp4|webm|mov|m4v)(\?|#|$)/i;
+var AUDIO_EXT_RE = /\.(mp3|wav|ogg|oga|m4a|aac|flac|opus|weba)(\?|#|$)/i;
+function mediaKindFromUrl(url2) {
+  if (VIDEO_EXT_RE.test(url2))
+    return "video";
+  if (AUDIO_EXT_RE.test(url2))
+    return "audio";
+  return "image";
+}
+var AUDIO_SERVICES = new Set(["audio", "tts", "music", "sfx"]);
+function libraryItemKind(item) {
+  const mime = item.mime_type?.toLowerCase() ?? "";
+  if (item.service === "video" || mime.startsWith("video/"))
+    return "video";
+  if (AUDIO_SERVICES.has(item.service) || mime.startsWith("audio/")) {
+    return "audio";
+  }
+  if (mime.startsWith("image/"))
+    return "image";
+  return mediaKindFromUrl(item.url);
+}
+function isHttpsUrl(url2) {
+  if (!url2 || !URL.canParse(url2))
+    return false;
+  return new URL(url2).protocol === "https:";
+}
+var FALLBACK_NAME = {
+  image: "Image",
+  video: "Video",
+  audio: "Audio",
+  file: "File"
+};
+function attachmentMessageType(parts) {
+  if (parts.images.length > 0)
+    return "image";
+  if (parts.videos.length > 0)
+    return "video";
+  if (parts.audios.length > 0)
+    return "audio";
+  return "file";
+}
+function attachmentFallbackContent(type) {
+  return FALLBACK_NAME[type];
+}
+function fetchLibraryPage(auth, twinId, query) {
+  return amikoWebFetch(auth, `/api/agents/${encodeURIComponent(twinId)}/media`, {
+    query: {
+      limit: query.limit,
+      cursor: query.cursor,
+      service: query.service
+    },
+    timeoutMs: 15000
+  });
+}
+function fetchExplorePage(auth, query) {
+  return amikoWebFetch(auth, "/api/design/explore", {
+    query: { limit: query.limit, cursor: query.cursor },
+    timeoutMs: 15000
+  });
+}
+async function resolveLibraryRefs(auth, twinId, refs) {
+  const wanted = new Set(refs.map((r) => r.mediaId));
+  const found = new Map;
+  let cursor;
+  for (let page = 0;page < MAX_LIBRARY_PAGES && wanted.size > 0; page++) {
+    const data = await fetchLibraryPage(auth, twinId, {
+      limit: LIBRARY_PAGE_SIZE,
+      cursor
+    });
+    for (const item of data.items ?? []) {
+      if (wanted.delete(item.id))
+        found.set(item.id, item);
+    }
+    if (!data.nextCursor)
+      break;
+    cursor = data.nextCursor;
+  }
+  const missing = refs.find((r) => !found.has(r.mediaId));
+  if (missing) {
+    throw new Error(`"${missing.raw}" wasn't found in twin ${twinId}'s Library (the ${MAX_LIBRARY_PAGES * LIBRARY_PAGE_SIZE} most recent creations are searched). Copy a ref from \`amiko chat library\`, or pass --twin for another twin's Library.`);
+  }
+  return found;
+}
+async function resolveExploreRef(auth, ref) {
+  const notExplore = () => new Error(`"${ref.raw}" is not an Explore item (the post is missing, not public, or has no media #${ref.index}). Copy a ref from \`amiko chat explore\`.`);
+  let data;
+  try {
+    data = await amikoWebFetch(auth, `/api/posts/${encodeURIComponent(ref.postId)}`, { timeoutMs: 15000 });
+  } catch (e5) {
+    if (e5.status === 404)
+      throw notExplore();
+    throw e5;
+  }
+  const post = data.post;
+  if (!post || post.visibility !== "public" || post.media_status && post.media_status !== "ready") {
+    throw notExplore();
+  }
+  const urls = (post.media_urls ?? []).filter(isHttpsUrl);
+  const url2 = urls[ref.index];
+  if (!url2)
+    throw notExplore();
+  const kind = mediaKindFromUrl(url2);
+  return {
+    ref,
+    kind,
+    record: {
+      url: url2,
+      name: post.title?.trim() || post.twin?.name?.trim() || FALLBACK_NAME[kind]
+    }
+  };
+}
+async function resolveAssetRefs(auth, refs, twinId) {
+  const libraryRefs = refs.filter((r) => r.source === "library");
+  const library = libraryRefs.length > 0 ? await resolveLibraryRefs(auth, twinId, libraryRefs) : new Map;
+  const resolved = [];
+  for (const ref of refs) {
+    if (ref.source === "library") {
+      const item = library.get(ref.mediaId);
+      if (!isHttpsUrl(item.url)) {
+        throw new Error(`"${ref.raw}" has no https URL, so it can't be sent.`);
+      }
+      const kind = libraryItemKind(item);
+      resolved.push({
+        ref,
+        kind,
+        record: {
+          url: item.url,
+          name: item.prompt?.trim() || FALLBACK_NAME[kind],
+          ...item.mime_type ? { contentType: item.mime_type } : {}
+        }
+      });
+    } else if (ref.source === "explore") {
+      resolved.push(await resolveExploreRef(auth, ref));
+    }
+  }
+  const seen = new Set;
+  return resolved.filter((a) => {
+    if (seen.has(a.record.url))
+      return false;
+    seen.add(a.record.url);
+    return true;
+  });
+}
+function driveError(e5, twinId) {
+  const body = e5.body;
+  let parsed = {};
+  try {
+    parsed = body ? JSON.parse(body) : {};
+  } catch {}
+  const which = parsed.name ? `"${parsed.name}"${parsed.docId ? ` (drive:${parsed.docId})` : ""}` : parsed.docId ? `drive:${parsed.docId}` : "A Drive file";
+  switch (parsed.code) {
+    case "NOT_FOUND":
+      return new Error(`${which} wasn't found in twin ${twinId}'s Drive. Get ids from \`amiko drive list --json\` for that same twin (use --twin to pick another).`);
+    case "UNSUPPORTED":
+      return new Error(`${which} can't be attached to a chat — only images and documents (pdf, docx, …) can be sent from Drive.`);
+    case "FILE_TOO_LARGE":
+      return new Error(`${which} is over the 25MB chat attachment limit.`);
+    case "INVALID_BODY":
+      return new Error(parsed.error ?? "Invalid Drive attachment request.");
+    default:
+      return e5 instanceof Error ? e5 : new Error(String(e5));
+  }
+}
+async function signDriveRefs(auth, refs, twinId) {
+  const docIds = refs.flatMap((r) => r.source === "drive" ? [r.docId] : []);
+  if (docIds.length === 0)
+    return [];
+  let data;
+  try {
+    data = await amikoWebFetch(auth, `/api/agents/${encodeURIComponent(twinId)}/docs/chat-attachments`, { method: "POST", body: { docIds }, timeoutMs: 30000 });
+  } catch (e5) {
+    throw driveError(e5, twinId);
+  }
+  const files = data.files ?? [];
+  if (files.length !== docIds.length) {
+    throw new Error("Drive returned an incomplete set of attachments.");
+  }
+  return files.map((f) => ({
+    url: f.url,
+    name: f.name,
+    contentType: f.contentType,
+    size: f.size,
+    doc_id: f.docId
+  }));
+}
+function buildAttachmentParts(assets, files, leadingImages = []) {
+  const byKind = (kind) => assets.filter((a) => a.kind === kind).map((a) => a.record);
+  return {
+    images: [...leadingImages, ...byKind("image")],
+    videos: byKind("video"),
+    audios: byKind("audio"),
+    files
+  };
+}
+function attachmentMetadata(parts) {
+  const out = {};
+  if (parts.images.length)
+    out.images = parts.images;
+  if (parts.videos.length)
+    out.videos = parts.videos;
+  if (parts.audios.length)
+    out.audios = parts.audios;
+  if (parts.files.length)
+    out.files = parts.files;
+  return out;
+}
+function plural(n, word) {
+  return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+function describeAttachments(refs, assets) {
+  const counts = new Map;
+  const bump = (label2) => counts.set(label2, (counts.get(label2) ?? 0) + 1);
+  for (const ref of refs)
+    if (ref.source === "drive")
+      bump("drive file");
+  for (const a of assets)
+    bump(`${a.ref.source} ${a.kind}`);
+  return [...counts].map(([label2, n]) => plural(n, label2)).join(", ");
+}
+
+// src/commands/chat-assets.ts
+var DEFAULT_LIMIT = 20;
+var MAX_TITLE = 48;
+var KINDS = new Set(["image", "video", "audio"]);
+function clampLimit(raw, max) {
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n))
+    return DEFAULT_LIMIT;
+  return Math.min(max, Math.max(1, n));
+}
+function truncate(text, max) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+function shortDate(iso) {
+  return iso ? iso.slice(0, 16).replace("T", " ") : "-";
+}
+function parseKind(raw) {
+  if (!raw)
+    return;
+  const kind = raw.toLowerCase();
+  if (!KINDS.has(kind)) {
+    console.error(error(`--kind must be image, video, or audio (got "${raw}").`));
+    process.exit(1);
+  }
+  return kind;
+}
+function matches(title, search) {
+  const q = search.trim().toLowerCase();
+  return !q || (title ?? "").toLowerCase().includes(q);
+}
+function registerChatAssetsCommands(chat) {
+  chat.command("library").description("List your Library (Create Studio creations) — pass a ref to `amiko chat send --attach`").option("--twin <id>", "Twin whose Library to list (default: current twin)").option("--kind <kind>", "Only image, video, or audio").option("--search <text>", "Filter by prompt text").option("--limit <n>", "Items to fetch (1-50)", String(DEFAULT_LIMIT)).option("--cursor <cursor>", "Continue from a previous page").option("--raw", "Output raw JSON").action(async (opts) => {
+    const auth = authOrExit();
+    const kind = parseKind(opts.kind);
+    const twinId = opts.twin || auth.twinId || "";
+    let data;
+    try {
+      data = await fetchLibraryPage(auth, twinId, {
+        limit: clampLimit(opts.limit, 50),
+        cursor: opts.cursor,
+        service: kind === "image" || kind === "video" ? kind : undefined
+      });
+    } catch (e5) {
+      console.error(error(e5 instanceof Error ? e5.message : "Library lookup failed"));
+      process.exit(1);
+    }
+    const items = (data.items ?? []).filter((it) => (!kind || libraryItemKind(it) === kind) && matches(it.prompt, opts.search ?? ""));
+    renderOutput({ items, nextCursor: data.nextCursor ?? null }, (d) => {
+      if (d.items.length === 0) {
+        console.log(dim("No matching Library items."));
+      } else {
+        console.log(heading(`Library (${d.items.length})`));
+        const rows = [
+          [dim("REF"), dim("KIND"), dim("CREATED"), dim("PROMPT")],
+          ...d.items.map((it) => [
+            `library:${it.id}`,
+            libraryItemKind(it),
+            shortDate(it.created_at),
+            truncate(it.prompt || "-", MAX_TITLE)
+          ])
+        ];
+        console.log(table(rows));
+        console.log(dim(`
+Attach: amiko chat send <target> "…" --attach <ref>`));
+      }
+      if (d.nextCursor) {
+        console.log(dim(`More: --cursor ${JSON.stringify(d.nextCursor)}`));
+      }
+    }, { json: opts.raw });
+  });
+  chat.command("explore").description("List recent public media from Explore — pass a ref to `amiko chat send --attach`").option("--kind <kind>", "Only image, video, or audio").option("--search <text>", "Filter by title").option("--limit <n>", "Posts to fetch (1-96)", String(DEFAULT_LIMIT)).option("--cursor <cursor>", "Continue from a previous page").option("--raw", "Output raw JSON").action(async (opts) => {
+    const auth = authOrExit();
+    const kind = parseKind(opts.kind);
+    let data;
+    try {
+      data = await fetchExplorePage(auth, {
+        limit: clampLimit(opts.limit, 96),
+        cursor: opts.cursor
+      });
+    } catch (e5) {
+      console.error(error(e5 instanceof Error ? e5.message : "Explore lookup failed"));
+      process.exit(1);
+    }
+    const items = (data.items ?? []).filter((it) => (!kind || it.kind.toLowerCase() === kind) && matches(it.title, opts.search ?? ""));
+    renderOutput({ items, nextCursor: data.nextCursor ?? null }, (d) => {
+      if (d.items.length === 0) {
+        console.log(dim("No matching Explore items."));
+      } else {
+        console.log(heading(`Explore (${d.items.length})`));
+        const rows = [
+          [dim("REF"), dim("KIND"), dim("BY"), dim("TITLE")],
+          ...d.items.map((it) => [
+            `explore:${it.id}`,
+            it.kind.toLowerCase(),
+            it.author?.handle ? `@${it.author.handle}` : it.author?.name ?? "-",
+            truncate(it.title || "-", MAX_TITLE)
+          ])
+        ];
+        console.log(table(rows));
+        console.log(dim(`
+Attach: amiko chat send <target> "…" --attach <ref>`));
+      }
+      if (d.nextCursor) {
+        console.log(dim(`More: --cursor ${JSON.stringify(d.nextCursor)}`));
+      }
+    }, { json: opts.raw });
+  });
+}
+
 // src/lib/gifs.ts
 function parseUrl(url2) {
   try {
@@ -28951,19 +29337,19 @@ function gifToMetadata(gif) {
 }
 
 // src/commands/chat-gifs.ts
-var DEFAULT_LIMIT = 10;
-var MAX_TITLE = 40;
-function clampLimit(raw) {
+var DEFAULT_LIMIT2 = 10;
+var MAX_TITLE2 = 40;
+function clampLimit2(raw) {
   const n = Number.parseInt(raw, 10);
   if (!Number.isFinite(n))
-    return DEFAULT_LIMIT;
+    return DEFAULT_LIMIT2;
   return Math.min(24, Math.max(1, n));
 }
-function truncate(text, max) {
+function truncate2(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) => {
+  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_LIMIT2)).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);
@@ -28975,7 +29361,7 @@ function registerChatGifsCommand(chat) {
       process.exit(1);
     }
     renderOutput(data, (d) => {
-      const items = (d.items ?? []).slice(0, clampLimit(opts.limit));
+      const items = (d.items ?? []).slice(0, clampLimit2(opts.limit));
       if (items.length === 0) {
         console.log(dim(q ? `No GIFs found for "${q}".` : "No trending GIFs."));
         console.log(dim("Powered by KLIPY"));
@@ -28985,7 +29371,7 @@ function registerChatGifsCommand(chat) {
       const rows = [
         [dim("TITLE"), dim("SIZE"), dim("URL")],
         ...items.map((gif) => [
-          truncate(gif.title || "GIF", MAX_TITLE),
+          truncate2(gif.title || "GIF", MAX_TITLE2),
           gif.width && gif.height ? `${gif.width}x${gif.height}` : "-",
           gif.gifUrl
         ])
@@ -29027,15 +29413,15 @@ async function resolveList(auth, target) {
   }
   const lower = t.toLowerCase();
   const exact = all.filter((l) => l.name.toLowerCase() === lower);
-  const matches = exact.length ? exact : all.filter((l) => l.name.toLowerCase().includes(lower));
-  if (matches.length === 0) {
+  const matches2 = exact.length ? exact : all.filter((l) => l.name.toLowerCase().includes(lower));
+  if (matches2.length === 0) {
     throw new Error(`No chat list matching "${t}". Run \`amiko chat lists\` to see them.`);
   }
-  if (matches.length > 1) {
-    const names = matches.map((l) => `"${l.name}" (${l.id})`).join(", ");
+  if (matches2.length > 1) {
+    const names = matches2.map((l) => `"${l.name}" (${l.id})`).join(", ");
     throw new Error(`"${t}" is ambiguous — matches: ${names}. Use the list's id.`);
   }
-  return matches[0];
+  return matches2[0];
 }
 async function resolveListOrExit(auth, target) {
   try {
@@ -29413,7 +29799,7 @@ function optionTexts(poll, ids) {
   const byId = new Map(poll.options.map((o3) => [o3.id, o3.text]));
   return ids.map((id) => byId.get(id) ?? id);
 }
-function plural(n, word) {
+function plural2(n, word) {
   return `${n} ${word}${n === 1 ? "" : "s"}`;
 }
 function renderPoll(poll, opts = {}) {
@@ -29426,7 +29812,7 @@ function renderPoll(poll, opts = {}) {
   sortedOptions(poll).forEach((option, i) => {
     const marker = mine.has(option.id) ? "●" : "○";
     const pct = poll.total_voters > 0 ? Math.round(option.vote_count / poll.total_voters * 100) : 0;
-    const result = state.resultsVisible ? dim(`  ${plural(option.vote_count, "vote")} · ${pct}%`) : "";
+    const result = state.resultsVisible ? dim(`  ${plural2(option.vote_count, "vote")} · ${pct}%`) : "";
     const correct = option.is_correct ? "  ✓ correct" : "";
     lines.push(`${marker} ${i + 1}. ${option.text}${result}${correct}`);
     if (!opts.compact && opts.nameFor && state.resultsVisible && option.voter_ids?.length) {
@@ -29435,7 +29821,7 @@ function renderPoll(poll, opts = {}) {
   });
   if (poll.explanation)
     lines.push(dim(`Explanation: ${poll.explanation}`));
-  const footer = [plural(poll.total_voters, "voter")];
+  const footer = [plural2(poll.total_voters, "voter")];
   if (!state.resultsVisible)
     footer.push("results hidden until you answer");
   lines.push(dim(footer.join(" · ")));
@@ -29927,15 +30313,28 @@ 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). 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) => {
+  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 or --attach.").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("--attach <ref>", "Attach a file you already have on Amiko (repeatable, up to 6): drive:<docId> (image or document from `amiko drive list`), library:<id> (from `amiko chat library`), explore:post:<postId>:<n> (from `amiko chat explore`). Combines with --image.", (value, previous) => [...previous, value], []).option("--twin <id>", "Twin whose Drive/Library --attach reads (default: your current twin)").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();
     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)."));
+    const attachRaw = opts.attach ?? [];
+    if (attachRaw.length > 0 && (opts.audio || opts.gif)) {
+      console.error(error("--attach can't be combined with --audio or --gif — send those as their own message (--attach does combine with --image)."));
+      process.exit(1);
+    }
+    let attachRefs = [];
+    try {
+      attachRefs = parseAttachRefs(attachRaw, opts.image ? 1 : 0);
+    } catch (e5) {
+      console.error(error(e5 instanceof Error ? e5.message : String(e5)));
+      process.exit(1);
+    }
+    const hasAttach = attachRefs.length > 0;
+    if (message === undefined && !opts.gif && !hasAttach) {
+      console.error(error("A message is required (it may only be omitted when sending a GIF with --gif or files with --attach)."));
       process.exit(1);
     }
     let resolved;
@@ -30005,14 +30404,36 @@ function registerChatCommand(chat) {
         process.exit(1);
       }
     }
-    const media = opts.image ? `image ${opts.image}` : opts.audio ? `audio ${opts.audio}` : gifAttachment ? `gif "${gifAttachment.name.slice(0, 40)}"` : "";
+    const attachTwinId = opts.twin || auth.twinId || "";
+    let attachAssets = [];
+    if (hasAttach) {
+      try {
+        attachAssets = await resolveAssetRefs(auth, attachRefs, attachTwinId);
+      } catch (e5) {
+        console.error(error(e5 instanceof Error ? e5.message : "Could not resolve the attachments"));
+        process.exit(1);
+      }
+    }
+    const media = [
+      opts.image ? `image ${opts.image}` : opts.audio ? `audio ${opts.audio}` : gifAttachment ? `gif "${gifAttachment.name.slice(0, 40)}"` : "",
+      hasAttach ? describeAttachments(attachRefs, attachAssets) : ""
+    ].filter(Boolean).join(", ");
     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)}${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" : ""}`
+      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)}` : ""}${attachRaw.map((r) => ` --attach ${JSON.stringify(r)}`).join("")}${opts.twin ? ` --twin ${JSON.stringify(opts.twin)}` : ""}${opts.all ? " --all" : ""}`
     });
+    let driveFiles = [];
+    if (hasAttach) {
+      try {
+        driveFiles = await signDriveRefs(auth, attachRefs, attachTwinId);
+      } catch (e5) {
+        console.error(error(e5 instanceof Error ? e5.message : "Could not attach the Drive files"));
+        process.exit(1);
+      }
+    }
     let convId;
     try {
       convId = resolved.kind === "user" ? await findOrCreateDm(auth, resolved.userId) : resolved.id;
@@ -30038,6 +30459,20 @@ function registerChatCommand(chat) {
             image_caption: outgoing || null
           }
         });
+      } else if (hasAttach) {
+        const leading = opts.image ? [
+          HTTPS_RE.test(opts.image) ? { url: opts.image, name: urlName(opts.image) } : await uploadChatImage(auth, convId, opts.image)
+        ] : [];
+        const parts = buildAttachmentParts(attachAssets, driveFiles, leading);
+        const messageType = attachmentMessageType(parts);
+        data = await post({
+          content: outgoing || attachmentFallbackContent(messageType),
+          message_type: messageType,
+          metadata: {
+            ...attachmentMetadata(parts),
+            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({
@@ -30066,7 +30501,9 @@ function registerChatCommand(chat) {
       console.log(JSON.stringify(data, null, 2));
       return;
     }
-    const what = opts.image ? "Message + image sent" : opts.audio ? "Message + voice note sent" : gifAttachment ? outgoing ? "Message + GIF sent" : "GIF sent" : "Message sent";
+    const attachCount = attachAssets.length + driveFiles.length + (opts.image ? 1 : 0);
+    const attachLabel = `${attachCount} attachment${attachCount === 1 ? "" : "s"}`;
+    const what = hasAttach ? outgoing ? `Message + ${attachLabel} sent` : `${attachLabel} sent` : 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) => {
@@ -30382,6 +30819,7 @@ function registerChatCommand(chat) {
     }
   });
   registerChatGifsCommand(chat);
+  registerChatAssetsCommands(chat);
   const group = chat.command("group").description("Group chats — create, list, info, rename, add/remove members, @all permission, leave");
   registerChatGroupCommand(group);
   const lists = chat.command("lists").description("Your chat lists (private folders of conversations) — run bare to see them; create, rename, add/remove conversations, delete");
@@ -32052,15 +32490,15 @@ async function resolveFriend(auth, target) {
   }
   const lower = t.toLowerCase();
   const exact = all.filter((f) => f.friend.name?.toLowerCase() === lower || f.friend.handle?.toLowerCase() === lower || f.nickname?.toLowerCase() === lower);
-  const matches = exact.length ? exact : all.filter((f) => f.friend.name?.toLowerCase().includes(lower) || f.friend.handle?.toLowerCase().includes(lower) || f.nickname?.toLowerCase().includes(lower));
-  if (matches.length === 0) {
+  const matches2 = exact.length ? exact : all.filter((f) => f.friend.name?.toLowerCase().includes(lower) || f.friend.handle?.toLowerCase().includes(lower) || f.nickname?.toLowerCase().includes(lower));
+  if (matches2.length === 0) {
     throw new Error(`No friend matching "${t}". Nicknames only work for accepted friends — run \`amiko friends list\`.`);
   }
-  if (matches.length > 1) {
-    const names = matches.map((f) => `${friendLabel(f)} (${f.friend.id})`).join(", ");
+  if (matches2.length > 1) {
+    const names = matches2.map((f) => `${friendLabel(f)} (${f.friend.id})`).join(", ");
     throw new Error(`"${t}" is ambiguous — matches: ${names}. Use the friend's @handle or user id.`);
   }
-  return matches[0];
+  return matches2[0];
 }
 async function resolveFriendOrExit(auth, target) {
   try {
@@ -32666,14 +33104,14 @@ The other user will be notified and must consent before the report is generated.
       });
       spinner?.stop();
       renderOutput(data, (d) => {
-        const matches = d.matches ?? [];
-        if (matches.length === 0) {
+        const matches2 = d.matches ?? [];
+        if (matches2.length === 0) {
           console.log(dim("No matches."));
           if (d.no_match_reason)
             console.log(dim(d.no_match_reason));
           return;
         }
-        console.log(heading(`Matches for "${opts.relationship}" (${matches.length})`));
+        console.log(heading(`Matches for "${opts.relationship}" (${matches2.length})`));
         const rows = [
           [
             dim("USER"),
@@ -32682,7 +33120,7 @@ The other user will be notified and must consent before the report is generated.
             dim("STATUS"),
             dim("PAIRING")
           ],
-          ...matches.map((m) => [
+          ...matches2.map((m) => [
             m.user_id,
             m.display_name ?? "-",
             m.score.toFixed(3),
@@ -32691,7 +33129,7 @@ The other user will be notified and must consent before the report is generated.
           ])
         ];
         console.log(table(rows));
-        for (const m of matches) {
+        for (const m of matches2) {
           if (m.compatibility_highlights?.length) {
             console.log();
             console.log(label(m.display_name ?? m.user_id, m.compatibility_highlights.join("; ")));

package/package.json

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

package/skills/SKILL.md

@@ -266,7 +266,12 @@ MiniMax Hailuo (02/2.3) is silent — there is no CLI mux step to attach a separ
 - `amiko chat list` — all conversations, **DMs and group chats** (id, type, peer/title, last message, unread). Rows with unread messages that concern the owner directly show an **`@you` marker**, and `--mentions` filters to just those. `@you` / `--mentions` means the unread messages include a **direct @mention of the owner, a permitted @all in a group, or a reply to one of the owner's messages** — so "did anyone reply to me?" is also answered here, not just literal mentions. No `@you` rows under `--mentions` = nothing unread needs the owner's attention specifically. (On servers that predate the flag it reads as false for every conversation: unread counts still show, `@you` never does, and `--mentions` matches nothing — an empty result there is NOT proof nobody mentioned or replied.)
 - `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), `--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.
+- **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 of those per message (image XOR audio XOR gif); `--image` may be combined with `--attach`. **Local video files are not supported** on chat yet — a Library/Explore video goes through `--attach`. To share a generated asset, pass its URL from `amiko create status` (no re-upload) or its `library:<id>` ref. A local audio file is sent as a voice note with the text as a separate message.
+- **Attach from Drive / Library / Explore** — `amiko chat send <target> "text" --attach <ref> [--attach <ref>…]`, up to **6 attachments per message** (a `--image` counts). Use this whenever the owner asks to send something that already lives on Amiko — "send Sophie the report from my drive", "share my latest creation", "send that sunset post from Explore". Refs:
+  - `drive:<docId>` — **images and documents only** (pdf, docx, …, ≤25MB); get the `id` from `amiko drive list --json` or `amiko drive search "<words>" --json`, matching by filename/title. Drive audio/video is refused (say so; offer the Library version if it's a creation).
+  - `library:<id>` — the owner's Create Studio creations; list with `amiko chat library` (`--kind image|video|audio`, `--search "<prompt words>"`, `--raw` for JSON). The owner's creations are *their* Library — don't use Explore for them.
+  - `explore:post:<postId>:<n>` — public media other people published; list with `amiko chat explore` (`--kind`, `--search "<title words>"`, `--cursor` to page). Copy the `REF` column as-is.
+  - Drive and Library read the current twin; `--twin <id>` targets another twin's. Text is optional with `--attach`. `--attach` can't be combined with `--audio`/`--gif`. Errors like "wasn't found", "can't be attached to a chat" or "over the 25MB chat attachment limit" are final for that ref — report them, don't retry blindly. `chat library`/`chat explore` are free, ungated reads; the send stays `--yes`-gated.
 - **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_*`.