@heyamiko/amiko-cli 0.9.0-beta.14 → 0.9.0-beta.16

package/README.md

@@ -1,4 +1,4 @@
-# @heyamiko/amiko-cli (v0.9.0-beta.10)
+# @heyamiko/amiko-cli (v0.9.0-beta.15)
 
 Manage wallets, credits, swaps, MPP marketplace services, and your Amiko twin (identity, documents, voice, avatar, friends, feed, Composio apps) from the terminal. Works for both human users and AI agents running on OpenClaw.
 

package/dist/index.js

@@ -19839,7 +19839,8 @@ function registerSearchCommand(program2) {
           "Content-Type": "application/json",
           "X-Payment-Tx": txHash,
           "X-Payment-Amount": amount2,
-          "X-Payment-Token": token
+          "X-Payment-Token": token,
+          "X-Twin-Id": auth.twinId
         }
       });
       spinner.stop();
@@ -19962,7 +19963,8 @@ function registerImageCommand(program2) {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          "X-Payment-Tx": txHash
+          "X-Payment-Tx": txHash,
+          "X-Twin-Id": auth.twinId
         },
         body: JSON.stringify({
           prompt,
@@ -20060,7 +20062,7 @@ function registerAmazonCommand(program2) {
         q: `site:amazon.com ${query}`
       });
       const res = await fetch(`${mppBase2}/v1/search/google_shopping?${params}`, {
-        headers: { "X-Payment-Tx": txHash }
+        headers: { "X-Payment-Tx": txHash, "X-Twin-Id": auth.twinId }
       });
       spinner.stop();
       if (!res.ok) {
@@ -20208,7 +20210,8 @@ async function payAndCall(mppBase2, method, path2, auth, wallet, amountOrAuto, b
     throw new Error("Payment sent but no tx hash returned.");
   const headers = {
     "Content-Type": "application/json",
-    "X-Payment-Tx": txHash
+    "X-Payment-Tx": txHash,
+    "X-Twin-Id": auth.twinId
   };
   const fetchOpts = { method, headers };
   if (body && method !== "GET") {
@@ -21173,6 +21176,190 @@ Accept with: amiko friends accept <friendshipId>`));
       process.exit(1);
     }
   });
+  reports.command("pending").description("List pending-consent report requests (awaiting my consent + awaiting theirs)").option("--limit <n>", "Page size (1-50)", "50").option("--json", "Output as JSON").action(async (opts) => {
+    const auth = resolveAuth();
+    const me = auth.userId;
+    if (!me && !opts.json) {
+      console.error(error("Current user id unknown — cannot split requests. Run `amiko accounts` to check."));
+      process.exit(1);
+    }
+    const spinner = opts.json ? null : ora("Loading...").start();
+    try {
+      const data = await amikoWebFetch(auth, "/api/friends/reports", {
+        query: { page: "1", limit: opts.limit }
+      });
+      spinner?.stop();
+      const items = (data.items ?? []).filter((r) => r.status === "pending_consent");
+      const incoming = items.filter((r) => r.respondent_id === me);
+      const outgoing = items.filter((r) => r.initiator_id === me);
+      renderOutput({ incoming, outgoing }, () => {
+        console.log(heading(`Awaiting my consent (${incoming.length})`));
+        if (incoming.length === 0) {
+          console.log(dim("  none"));
+        } else {
+          const rows = [
+            [
+              dim("REPORT ID"),
+              dim("TYPE"),
+              dim("FROM"),
+              dim("HANDLE"),
+              dim("SENT")
+            ],
+            ...incoming.map((r) => [
+              r.id,
+              r.report_type ?? "-",
+              r.initiator?.name ?? "-",
+              r.initiator?.handle ?? "-",
+              r.created_at?.slice(0, 10) ?? "-"
+            ])
+          ];
+          console.log(table(rows));
+          console.log(dim(`
+Consent with: amiko friends reports consent <reportId>`));
+        }
+        console.log();
+        console.log(heading(`Awaiting their consent (${outgoing.length})`));
+        if (outgoing.length === 0) {
+          console.log(dim("  none"));
+        } else {
+          const rows = [
+            [
+              dim("REPORT ID"),
+              dim("TYPE"),
+              dim("TO"),
+              dim("HANDLE"),
+              dim("SENT")
+            ],
+            ...outgoing.map((r) => [
+              r.id,
+              r.report_type ?? "-",
+              r.respondent?.name ?? "-",
+              r.respondent?.handle ?? "-",
+              r.created_at?.slice(0, 10) ?? "-"
+            ])
+          ];
+          console.log(table(rows));
+          console.log(dim(`
+Cancel with: amiko friends reports cancel <reportId>`));
+        }
+      }, { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      console.error(error(e instanceof Error ? e.message : String(e)));
+      process.exit(1);
+    }
+  });
+  reports.command("request").description("Request a friend matching report (notifies the other user to consent)").requiredOption("--id <userId>", "Target user id (must be an accepted friend)").requiredOption("--type <friend|romantic|career>", "Report type").option("--yes", "Skip confirmation").option("--json", "Output as JSON").action(async (opts) => {
+    const allowed = ["friend", "romantic", "career"];
+    if (!allowed.includes(opts.type)) {
+      console.error(error(`--type must be one of: ${allowed.join(", ")}`));
+      process.exit(1);
+    }
+    await confirmDestructive({
+      action: `Request a ${opts.type} matching report with user ${opts.id} (they will be notified)`,
+      yes: opts.yes,
+      commandExample: `amiko friends reports request --id ${opts.id} --type ${opts.type}`
+    });
+    const auth = resolveAuth();
+    const spinner = opts.json ? null : ora("Requesting report...").start();
+    try {
+      const data = await amikoWebFetch(auth, "/api/friends/reports", {
+        method: "POST",
+        body: { friend_id: opts.id, report_type: opts.type }
+      });
+      spinner?.stop();
+      renderOutput(data, (d) => {
+        if (d.report) {
+          console.log(success(`Report requested (${d.report.report_type})`));
+          console.log(label("Report ID", d.report.id));
+          console.log(label("Status", d.report.status));
+          console.log(dim(`
+The other user will be notified and must consent before the report is generated.`));
+        }
+      }, { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      console.error(error(e instanceof Error ? e.message : String(e)));
+      process.exit(1);
+    }
+  });
+  for (const action of ["consent", "cancel", "retry"]) {
+    const desc = {
+      consent: "Consent to a report request (respondent only)",
+      cancel: "Cancel a pending report",
+      retry: "Retry a failed report generation"
+    };
+    reports.command(`${action} <id>`).description(desc[action]).option("--json", "Output as JSON").action(async (id, opts) => {
+      const auth = resolveAuth();
+      const spinner = opts.json ? null : ora(`${action}...`).start();
+      try {
+        const data = await amikoWebFetch(auth, `/api/friends/reports/${encodeURIComponent(id)}`, { method: "PATCH", body: { action } });
+        spinner?.stop();
+        renderOutput(data, (d) => {
+          console.log(success(`${action} ok`));
+          if (d.status)
+            console.log(label("Status", d.status));
+        }, { json: opts.json });
+      } catch (e) {
+        spinner?.stop();
+        console.error(error(e instanceof Error ? e.message : String(e)));
+        process.exit(1);
+      }
+    });
+  }
+  program2.command("find").description("Find matches for a custom relationship description (LLM-generated, on-demand)").requiredOption("--relationship <text>", 'Relationship description, e.g. "cofounder who is good at design"').option("--rationale <text>", "Optional extra context for the matcher").option("--limit <n>", "Max results (1-20)", "10").option("--json", "Output as JSON").action(async (opts) => {
+    const limitNum = Math.max(1, Math.min(20, Number(opts.limit) || 10));
+    const auth = resolveAuth();
+    const spinner = opts.json ? null : ora("Finding matches (may take ~10s)...").start();
+    try {
+      const data = await amikoWebFetch(auth, "/api/user/personality-profile/matches", {
+        method: "POST",
+        body: {
+          relationship_type: opts.relationship,
+          rationale: opts.rationale,
+          limit: limitNum
+        }
+      });
+      spinner?.stop();
+      renderOutput(data, (d) => {
+        const matches = d.matches ?? [];
+        if (matches.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})`));
+        const rows = [
+          [
+            dim("USER"),
+            dim("NAME"),
+            dim("SCORE"),
+            dim("STATUS"),
+            dim("PAIRING")
+          ],
+          ...matches.map((m) => [
+            m.user_id,
+            m.display_name ?? "-",
+            m.score.toFixed(3),
+            m.friendship_status ?? "none",
+            m.pairing_label ?? "-"
+          ])
+        ];
+        console.log(table(rows));
+        for (const m of matches) {
+          if (m.compatibility_highlights?.length) {
+            console.log();
+            console.log(label(m.display_name ?? m.user_id, m.compatibility_highlights.join("; ")));
+          }
+        }
+      }, { json: opts.json });
+    } catch (e) {
+      spinner?.stop();
+      console.error(error(e instanceof Error ? e.message : String(e)));
+      process.exit(1);
+    }
+  });
   program2.command("matches").description("List friend matches").option("--limit <n>", "Max results (1-50)", "10").option("--offset <n>", "Offset", "0").option("--relationship-type <type>", "Filter by relationship type").option("--dimension <dimension>", "Filter by match dimension").option("--json", "Output as JSON").action(async (opts) => {
     const auth = resolveAuth();
     const spinner = opts.json ? null : ora("Loading matches...").start();

package/package.json

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

package/skills/SKILL.md

@@ -51,7 +51,7 @@ Every paid command (`markets search`, `markets image`, `markets amazon search`,
 
 ## Critical Rules
 
-1. **Every paid / value-moving command is hard-gated on `--yes` in a non-interactive shell.** The CLI *refuses* to run `markets image`, `markets search`, `markets amazon search`, `markets service call`, `markets service tts`, `markets service stt`, `markets service chat`, `credits topup`, `wallets swap send`, or `wallets bridge send` unless `--yes` is passed. The refusal is loud: it prints the cost and the command you should re-run. **Quote the cost to the user, get explicit approval, THEN append `--yes`**. Same for destructive non-paid commands (`twin update --public`, `docs delete`, `friends remove`, `avatar update`, `voice reset`, `composio disconnect`).
+1. **Every paid / value-moving command is hard-gated on `--yes` in a non-interactive shell.** The CLI *refuses* to run `markets image`, `markets search`, `markets amazon search`, `markets service call`, `markets service tts`, `markets service stt`, `markets service chat`, `credits topup`, `wallets swap send`, or `wallets bridge send` unless `--yes` is passed. The refusal is loud: it prints the cost and the command you should re-run. **Quote the cost to the user, get explicit approval, THEN append `--yes`**. Same for destructive non-paid commands (`twin update --public`, `docs delete`, `friends remove`, `friends reports request`, `avatar update`, `voice reset`, `composio disconnect`).
 2. **After every paid command, report the remaining balance.** The CLI prints a `Balance: N credits` line at the end of every paid command — include that figure in your reply.
 3. **Never retry a failed command.** Report the error and stop. Every paid call costs tokens even on failure.
 4. **Never suggest `amiko login` or `amiko connect`.** These don't exist. Auth is automatic when you run from your workspace folder.
@@ -188,12 +188,48 @@ amiko friends requests --direction incoming
 amiko friends add --id <userId>
 amiko friends accept <friendshipId>
 amiko friends remove <friendshipId> --yes        # destructive
-amiko friends matches                            # personality match candidates
-amiko friends matches --relationship-type friend --dimension interest
-amiko friends reports list                       # friend matching reports
-amiko friends reports view <reportId>            # full id from `--json`
+amiko friends matches                            # pre-generated match candidates (from cron)
+amiko friends matches --dimension personality
+amiko friends find --relationship "cofounder with design taste"  # on-demand LLM match for a custom relationship
+amiko friends reports list                       # all reports (any status)
+amiko friends reports pending                    # pending-consent: awaiting mine + awaiting theirs
+amiko friends reports view <reportId>
+amiko friends reports request --id <userId> --type friend|romantic|career --yes
+amiko friends reports consent <reportId>         # respondent approves; report then generates
+amiko friends reports cancel <reportId>
+amiko friends reports retry <reportId>           # re-run a failed generation
 ```
 
+### Answering relationship questions ("how is my relationship with X?")
+
+When the user asks about their relationship / compatibility with a specific person (by name or handle), follow this playbook:
+
+1. **Resolve the person to a user id.** Check `amiko friends list --json` first. If not a friend, try `amiko users search "<name>" --json`. If still ambiguous, ask the user which one they mean.
+2. **Look for an existing report.** Run `amiko friends reports list --json` and filter by `initiator.id` or `respondent.id` matching the resolved user id. If one exists with `status=completed`, use `amiko friends reports view <id>` and summarize. If `status=pending_consent` or `generating`, tell the user it is in progress.
+3. **If none exists**, don't silently create one. Ask the user which of the three report types they want (`friend` / `romantic` / `career`), and confirm that the other user will be notified to consent. Only then run `amiko friends reports request --id <userId> --type <type> --yes`.
+4. **For "who is waiting on whom"**, use `amiko friends reports pending` — it splits `pending_consent` reports into *awaiting my consent* (I can `consent <id>`) vs *awaiting theirs* (I can `cancel <id>`). Use this before deciding to `request` — you cannot have two active reports of the same type between the same pair (the API returns 409).
+
+Both users must have a personality profile, otherwise the request returns 422.
+
+### Recommending interesting people ("who should I meet / connect with?")
+
+The discovery primitive is **`amiko friends matches`** — it returns personality-match candidates with a score (0–1), a match dimension, a pairing label, and compatibility highlights.
+
+**`friends find` vs `users search` — do not confuse them:**
+
+| Command | Purpose | Input | Backend |
+|---|---|---|---|
+| `users search <query>` | **Look up a specific known person** by name or handle ("find wendao", "search for someone called Sophie") | Exact/substring text against `name` / `handle` | Simple SQL lookup in `/api/search?type=people` |
+| `friends find --relationship <text>` | **Discover unknown people** whose personality matches a free-form relationship description ("cofounder with design taste", "someone to hike with") | Free-form relationship description | LLM-generated MatchingSpec + semantic matching across ~250 candidate profiles |
+
+Rule of thumb: if the user already has a name in mind → `users search`. If the user is describing what *kind of person* they want to meet → `friends find`. For already-curated ambient recommendations with no input required → `friends matches`.
+
+1. Start broad: `amiko friends matches --limit 20 --json`. Summarize the top few by `display_name`, `score`, `match_dimension`, `pairing_label`, and `recommendation_reason`. These are pre-generated by a cron job.
+2. If the user wants to narrow, filter by `--dimension personality` or `--dimension interest` (the only two dimensions the matching cron actually produces). `--relationship-type` also exists but takes free-form LLM-generated labels (often localized, e.g. `深度思维_对打手`) — usually not worth filtering on unless you first inspect the `--json` output to pick a known value.
+3. If the user describes a **specific kind of person** not covered by the cron matches ("a cofounder who is good at design", "a hiking buddy", "someone to debate philosophy with"), use `amiko friends find --relationship "<description>"`. This is an on-demand, LLM-backed matcher against ~250 candidates; may take ~10s and may return zero matches if nothing clears the internal score threshold.
+4. Skip anyone whose `friendship_status` is already `accepted` unless the user explicitly wants to revisit existing friends.
+5. Follow-ups: `amiko users profile <handle>` for a fuller view, `amiko friends add --id <matched_user_id>` (after explicit user approval) to send a friend request, and — once the friendship is accepted — `amiko friends reports request --type friend|romantic|career` for a deeper compatibility report. Note that report `--type` is a separate enum and has nothing to do with `match.relationship_type`.
+
 ## Users
 
 ```bash