@acedatacloud/skills 2026.703.2 → 2026.703.4

package/AGENTS.md

@@ -31,6 +31,7 @@ Skills are located in the `skills/` directory (also mirrored to `.agents/skills/
 - **face-transform** — Face analysis, beautification, age/gender transform, swap, cartoon
 - **short-url** — Create and manage short URLs
 - **onepage-pdf** — Convert an HTML page into one tall single-page PDF (local; no API token; needs Python + pymupdf + Chrome/Edge)
+- **apple-notes** — Manage Apple Notes on macOS: create, search, read, export, organize notes (macOS-only; local; no API token; drives Notes.app via AppleScript)
 - **acedatacloud** — Manage your AceDataCloud account — balance, usage/spend, API keys, services, orders, announcements
 
 ## Authentication

package/README.md

@@ -12,7 +12,7 @@
 
 Compatible with **30+ AI coding agents** via the [agentskills.io](https://agentskills.io/) open standard: Claude Code, GitHub Copilot, Gemini CLI, OpenAI Codex, Cursor, Roo Code, Goose, and more.
 
-## Available Skills (29)
+## Available Skills (30)
 
 ### AI Music & Audio
 
@@ -50,6 +50,7 @@ Compatible with **30+ AI coding agents** via the [agentskills.io](https://agents
 | [face-transform](skills/face-transform/) | Face analysis, beautification, age/gender transform, swap, cartoon |
 | [short-url](skills/short-url/) | Create and manage short URLs |
 | [onepage-pdf](skills/onepage-pdf/) | Convert an HTML page into one tall single-page PDF — no pagination breaks (local, no token) |
+| [apple-notes](skills/apple-notes/) | Manage Apple Notes on macOS — create, search, read, export, and organize notes (macOS-only, local, no token) |
 | [acedatacloud](skills/acedatacloud/) | Manage your AceDataCloud account — balance, usage/spend, API keys, services, orders, announcements |
 
 ### Connectors
@@ -70,6 +71,7 @@ These skills drive third-party connectors users wire up at [auth.acedata.cloud/u
 | [slack](skills/slack/) | Read Slack channels, messages, and user info via Web API | `slack` |
 | [wechat-official-account](skills/wechat-official-account/) | Manage WeChat MP — drafts, publishing, materials, user tags | `wechat` (BYOC) |
 | [personal-wechat](skills/personal-wechat/) | Operate a personal WeChat account through a self-hosted Wisdom service | `personalwechat` (BYOC) |
+| [didi-ride](skills/didi-ride/) | Book DiDi rides, estimate fares, query/cancel orders, plan routes via the DiDi MCP | `didi` (BYOC) |
 | [wecom](skills/wecom/) | WeCom (企业微信) self-built app — contacts, app messages, WeDoc, schedules, meetings | `wecom` (BYOC) |
 | [tencent-docs](skills/tencent-docs/) | Create / read / list / search / manage Tencent Docs — docs, sheets, slides, mind maps, flowcharts | `tencentdocs` (BYOC) |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acedatacloud/skills",
-  "version": "2026.703.2",
+  "version": "2026.703.4",
   "description": "Agent Skills for AceDataCloud AI services — music, image, video generation, LLM chat, web search. Compatible with Claude Code, GitHub Copilot, Gemini CLI, OpenAI Codex, and 30+ AI coding agents.",
   "keywords": [
     "agent-skills",

package/skills/apple-notes/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: apple-notes
+description: Manage Apple Notes on macOS — list, search, read, create, append, move, delete, and export notes, and manage folders. Use when the user mentions Apple Notes / 备忘录, "add a note", "my notes", searching their notes, organizing folders, or exporting a note to Markdown/HTML. macOS-only; runs locally against Notes.app — no cloud API, no token.
+when_to_use: |
+  Trigger for anything on the user's local Apple Notes (Notes.app on macOS):
+  list / search / read / export a note, create a new one, append to an existing
+  one, move it between folders, or manage folders. There is no cloud API for
+  Apple Notes, so this runs on the user's own Mac (Claude Code on macOS, or
+  driven remotely through a CodingBridge node). Writes act on the user's REAL
+  notes, so create / append / move / delete are GATED behind an explicit
+  confirmation.
+allowed_tools: [Bash]
+license: Apache-2.0
+compatibility: macOS-only. No API token, no connector — Apple Notes has no cloud API. Drives the local Notes.app via AppleScript (osascript); zero external dependencies (Python 3 standard library only). Requires granting Automation access to Notes.app on first run. Does not call api.acedata.cloud.
+metadata:
+  author: acedatacloud
+  version: "1.0"
+---
+
+# apple-notes — manage Apple Notes locally via AppleScript
+
+Drives the user's **real** Apple Notes through `Notes.app` on macOS. Apple never
+shipped a cloud API for Notes, so there is nothing to OAuth into and no token to
+inject — this skill runs **on the user's own Mac** and talks to Notes.app with
+AppleScript (`osascript`). It works when Claude Code runs on macOS directly, or
+remotely through a CodingBridge node running on the user's Mac.
+
+The skill ships [`scripts/notes.py`](scripts/notes.py) — self-contained, Python
+**standard library only** (it shells out to `osascript`; no `pip install`, no
+`brew`). Dynamic values are passed as environment variables, never interpolated
+into the AppleScript source, so note content can't break the script or inject
+commands.
+
+## Requirements
+
+- **macOS** with the Notes app. `python3` (system Python is fine).
+- **Automation permission.** The first call triggers a macOS prompt: *"Terminal
+  wants to control Notes."* Approve it, or enable it under **System Settings ›
+  Privacy & Security › Automation ›** (your terminal / agent) **› Notes**. On an
+  authorization error the CLI tells the user exactly this — do **not** loop-retry.
+- Referencing Notes launches the app in the background (no window is forced open).
+
+```sh
+NOTES="${SKILL_DIR:-.}/scripts/notes.py"   # run from this skill's directory
+python3 "$NOTES" folders                    # smoke-test the connection
+```
+
+## Commands
+
+| Command | Read/Write | Purpose |
+| --- | --- | --- |
+| `folders` | read | List folders with note counts |
+| `list [--folder F] [--limit N]` | read | List notes (newest first): id, title, folder, dates |
+| `search QUERY [--folder F] [--limit N]` | read | Case-insensitive substring match on title + body |
+| `view NOTE_ID [--format json\|text\|html]` | read | Show one note (metadata + body) |
+| `export NOTE_ID [--format md\|html\|text] [-o FILE]` | read | Export one note to Markdown/HTML/text |
+| `create --title T [--body B \| --body-file F] [--folder F]` | **write** | Create a note |
+| `append NOTE_ID [--body B \| --body-file F]` | **write** | Append text to an existing note |
+| `move NOTE_ID --folder F` | **write** | Move a note to another folder |
+| `new-folder NAME` | **write** | Create a folder |
+| `delete NOTE_ID` | **write** | Move a note to *Recently Deleted* (recoverable) |
+
+Most commands print JSON (and errors are always JSON: `{"error": ...}`). The
+exceptions print raw note content to stdout: `view --format text|html` and
+`export` without `-o`. `NOTE_ID` is the opaque `x-coredata://…` id returned by
+`list` / `search` — always fetch a fresh id first; do not guess one.
+
+## Read examples
+
+```sh
+python3 "$NOTES" folders
+python3 "$NOTES" list --limit 20
+python3 "$NOTES" list --folder "Work" --limit 50
+python3 "$NOTES" search "invoice" --limit 20
+python3 "$NOTES" view "x-coredata://…/p42"
+python3 "$NOTES" export "x-coredata://…/p42" --format md -o note.md
+```
+
+## Writes are GATED (dry-run unless trailing `--confirm`)
+
+`create`, `append`, `move`, `new-folder`, and `delete` change the user's real
+notes. Without a trailing `--confirm` they **dry-run** and print what they would
+do. `--confirm` is honored **only as the very last argument**. Always show the
+dry-run, get an explicit "yes", then re-run with `--confirm` appended.
+
+```sh
+# Create — dry-run, then confirm
+python3 "$NOTES" create --title "Groceries" --body "milk\neggs"                # preview
+python3 "$NOTES" create --title "Groceries" --body "milk\neggs" --confirm      # writes
+
+# Create in a folder, body from a file
+python3 "$NOTES" create --title "Spec" --body-file draft.md --folder "Work" --confirm
+
+# Append to an existing note
+python3 "$NOTES" append "x-coredata://…/p42" --body "one more line" --confirm
+
+# Move / organize
+python3 "$NOTES" new-folder "Archive" --confirm
+python3 "$NOTES" move "x-coredata://…/p42" --folder "Archive" --confirm
+
+# Delete → goes to Recently Deleted (recoverable ~30 days)
+python3 "$NOTES" delete "x-coredata://…/p42" --confirm
+```
+
+Content is treated as **plain text** (each line becomes a paragraph; the
+`--title` is the note's first line, which Notes shows as the title). HTML in the
+input is escaped, so it can't inject markup. Use `\n` for line breaks in
+`--body`, or pass a file with `--body-file`.
+
+## Gotchas
+
+- **This is the user's real Notes account.** Confirm before any write.
+- **`list` scans the whole library** — for large accounts it can take a few
+  seconds. Narrow with `--folder`, and cap with `--limit` (default 50). `search`
+  filters inside Notes and is faster.
+- **Attachments / images:** notes containing images or attachments can be read
+  and exported as text, but `append` may not preserve embedded attachments —
+  avoid editing attachment notes here; open them in Notes instead.
+- **Export → Markdown** converts common Notes formatting (headings, bold/italic,
+  lists, links, line breaks). Rich objects (tables, drawings, scanned docs)
+  degrade to plain text.
+- **`move` stays within one account** (e.g. iCloud). Cross-account moves fail.
+- **Never assume a `NOTE_ID`** — ids are store-specific; always get them from
+  `list` / `search` first.
+- On a persistent authorization error, the Automation permission is missing —
+  tell the user to grant it (see Requirements) and stop; do not retry in a loop.

package/skills/apple-notes/scripts/notes.py

@@ -0,0 +1,572 @@
+#!/usr/bin/env python3
+"""
+apple-notes — manage Apple Notes on macOS via AppleScript (osascript).
+
+Standard library only. There is no cloud API for Apple Notes, so this drives the
+local Notes.app through `osascript`. Dynamic values (titles, bodies, ids, folder
+names, queries) are passed as ENVIRONMENT VARIABLES and read inside AppleScript
+with `system attribute` — they are never interpolated into the script source, so
+note content cannot break the script or inject AppleScript/shell commands.
+
+Read commands run directly. Writes (create / append / move / new-folder /
+delete) are GATED by a trailing `--confirm` (honored only as the last arg);
+without it they dry-run. `delete` moves the note to Recently Deleted (recoverable).
+
+Examples:
+  python3 notes.py folders
+  python3 notes.py list --limit 20
+  python3 notes.py search "invoice" --limit 10
+  python3 notes.py view <note-id>
+  python3 notes.py export <note-id> --format md -o note.md
+  python3 notes.py create --title "Groceries" --body "milk\neggs" --confirm
+"""
+
+from __future__ import annotations
+
+import argparse
+import html as _html
+import json
+import os
+import re
+import subprocess
+import sys
+from html.parser import HTMLParser
+
+# Field / record separators used to pack AppleScript output (U+001F / U+001E).
+US = "\x1f"
+RS = "\x1e"
+
+TIMEOUT = 90  # overridden by --timeout in main()
+
+# GATED-write handling: a trailing "--confirm" arms writes; it is stripped before
+# argparse so it is never a real flag (and is honored ONLY as the last argument).
+_RAW = sys.argv[1:]
+CONFIRM = bool(_RAW) and _RAW[-1] == "--confirm"
+ARGV = _RAW[:-1] if CONFIRM else list(_RAW)
+
+
+def out(obj) -> None:
+    print(json.dumps(obj, ensure_ascii=False, indent=2, default=str))
+
+
+def die(msg: str, code: int = 1) -> None:
+    out({"error": msg})
+    sys.exit(code)
+
+
+def _int(s) -> int:
+    try:
+        return int(str(s).strip())
+    except (TypeError, ValueError):
+        return 0
+
+
+# ── AppleScript ─────────────────────────────────────────────────────
+
+# ISO-8601 date helpers (locale-independent: build the string from integers).
+_HANDLERS = r"""
+on isoDate(d)
+  return (pad(year of d, 4)) & "-" & (pad((month of d) as integer, 2)) & "-" & (pad(day of d, 2)) & "T" & (pad(hours of d, 2)) & ":" & (pad(minutes of d, 2)) & ":" & (pad(seconds of d, 2))
+end isoDate
+on pad(n, w)
+  set s to ((n as integer) as string)
+  repeat while (length of s) < w
+    set s to "0" & s
+  end repeat
+  return s
+end pad
+"""
+
+_EMIT = (
+    '      set fol to ""\n'
+    "      try\n"
+    "        set fol to name of container of n\n"
+    "      end try\n"
+    "      set outText to outText & (id of n) & US & (name of n) & US & fol"
+    " & US & (my isoDate(modification date of n)) & US & (my isoDate(creation date of n)) & RS\n"
+)
+
+_SCRIPT_FOLDERS = r"""
+set US to (character id 31)
+set RS to (character id 30)
+set outText to ""
+tell application "Notes"
+  repeat with f in folders
+    set outText to outText & (name of f) & US & ((count of notes of f) as string) & RS
+  end repeat
+end tell
+return outText
+"""
+
+_SCRIPT_LIST = _HANDLERS + (
+    'set US to (character id 31)\n'
+    'set RS to (character id 30)\n'
+    'set folderName to system attribute "ANOTE_FOLDER"\n'
+    'set outText to ""\n'
+    'tell application "Notes"\n'
+    '  if folderName is "" then\n'
+    '    set theNotes to every note\n'
+    '  else\n'
+    '    set theNotes to every note of folder folderName\n'
+    '  end if\n'
+    '  repeat with n in theNotes\n'
+    + _EMIT +
+    '  end repeat\n'
+    'end tell\n'
+    'return outText\n'
+)
+
+_SCRIPT_SEARCH = _HANDLERS + (
+    'set US to (character id 31)\n'
+    'set RS to (character id 30)\n'
+    'set q to system attribute "ANOTE_QUERY"\n'
+    'set folderName to system attribute "ANOTE_FOLDER"\n'
+    'set outText to ""\n'
+    'tell application "Notes"\n'
+    '  if folderName is "" then\n'
+    '    set theNotes to (every note whose (name contains q) or (body contains q))\n'
+    '  else\n'
+    '    set theNotes to (every note of folder folderName whose (name contains q) or (body contains q))\n'
+    '  end if\n'
+    '  repeat with n in theNotes\n'
+    + _EMIT +
+    '  end repeat\n'
+    'end tell\n'
+    'return outText\n'
+)
+
+_SCRIPT_VIEW = _HANDLERS + (
+    'set US to (character id 31)\n'
+    'set theId to system attribute "ANOTE_ID"\n'
+    'tell application "Notes"\n'
+    '  set n to first note whose id is theId\n'
+    '  set fol to ""\n'
+    '  try\n'
+    '    set fol to name of container of n\n'
+    '  end try\n'
+    '  set outText to (id of n) & US & (name of n) & US & fol & US'
+    ' & (my isoDate(creation date of n)) & US & (my isoDate(modification date of n)) & US & (body of n)\n'
+    'end tell\n'
+    'return outText\n'
+)
+
+_SCRIPT_CREATE = r"""
+set theBody to system attribute "ANOTE_BODY"
+set folderName to system attribute "ANOTE_FOLDER"
+tell application "Notes"
+  if folderName is "" then
+    set newNote to make new note with properties {body:theBody}
+  else
+    tell folder folderName
+      set newNote to make new note with properties {body:theBody}
+    end tell
+  end if
+  return id of newNote
+end tell
+"""
+
+_SCRIPT_APPEND = r"""
+set theId to system attribute "ANOTE_ID"
+set extra to system attribute "ANOTE_BODY"
+tell application "Notes"
+  set n to first note whose id is theId
+  set body of n to (body of n) & extra
+  return id of n
+end tell
+"""
+
+_SCRIPT_MOVE = r"""
+set theId to system attribute "ANOTE_ID"
+set destFolder to system attribute "ANOTE_FOLDER"
+tell application "Notes"
+  set n to first note whose id is theId
+  move n to folder destFolder
+  return id of n
+end tell
+"""
+
+_SCRIPT_NEWFOLDER = r"""
+set folderName to system attribute "ANOTE_FOLDER"
+tell application "Notes"
+  make new folder with properties {name:folderName}
+end tell
+return folderName
+"""
+
+_SCRIPT_DELETE = r"""
+set theId to system attribute "ANOTE_ID"
+tell application "Notes"
+  set n to first note whose id is theId
+  delete n
+end tell
+return theId
+"""
+
+
+def _map_error(err: str) -> None:
+    low = err.lower()
+    if "-1743" in err or "not authoriz" in low or "not allowed to send" in low:
+        die(
+            "Not authorized to control Notes. Grant Automation access under "
+            "System Settings \u203a Privacy & Security \u203a Automation \u203a "
+            "(your terminal/agent) \u203a Notes, then retry."
+        )
+    if "-1728" in err or "can\u2019t get" in low or "can't get" in low or "-2753" in err:
+        die("Not found \u2014 check the note id or folder name (run `list` / `folders` for valid values).")
+    if "-600" in err or "isn\u2019t running" in low or "not running" in low:
+        die("Notes.app could not launch.")
+    die("AppleScript error: " + err if err else "osascript failed with no error message.")
+
+
+def osa(script: str, **env: str) -> str:
+    full = dict(os.environ)
+    for key, value in env.items():
+        full[key] = "" if value is None else str(value)
+    try:
+        proc = subprocess.run(
+            ["osascript", "-e", script],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            env=full,
+            timeout=TIMEOUT,
+        )
+    except FileNotFoundError:
+        die("osascript not found \u2014 this skill requires macOS.")
+    except subprocess.TimeoutExpired:
+        die(f"osascript timed out after {TIMEOUT}s \u2014 narrow with --folder / --limit.")
+    if proc.returncode != 0:
+        _map_error((proc.stderr or "").strip())
+    return proc.stdout
+
+
+# ── content helpers ─────────────────────────────────────────────────
+
+def text_to_html(title: str, body: str) -> str:
+    """Plain text -> Notes-safe HTML (one <div> per line). Input is escaped."""
+    parts = []
+    if title:
+        parts.append("<div>" + _html.escape(title) + "</div>")
+    for line in (body or "").split("\n"):
+        parts.append("<div><br></div>" if line.strip() == "" else "<div>" + _html.escape(line) + "</div>")
+    return "".join(parts)
+
+
+class _Converter(HTMLParser):
+    """Minimal Notes-HTML -> Markdown/plain-text converter (stdlib only)."""
+
+    def __init__(self, markdown: bool = True) -> None:
+        super().__init__(convert_charrefs=True)
+        self.md = markdown
+        self.buf: list[str] = []
+        self._href: str | None = None
+        self._list: list = []
+
+    def _nl(self) -> None:
+        if self.buf and not self.buf[-1].endswith("\n"):
+            self.buf.append("\n")
+
+    def handle_starttag(self, tag: str, attrs) -> None:
+        if tag == "br":
+            self.buf.append("\n")
+        elif tag in ("div", "p"):
+            self._nl()
+        elif tag in ("h1", "h2", "h3", "h4", "h5", "h6"):
+            self._nl()
+            if self.md:
+                self.buf.append("#" * int(tag[1]) + " ")
+        elif tag in ("b", "strong") and self.md:
+            self.buf.append("**")
+        elif tag in ("i", "em") and self.md:
+            self.buf.append("*")
+        elif tag == "ul":
+            self._list.append("ul")
+            self._nl()
+        elif tag == "ol":
+            self._list.append(["ol", 0])
+            self._nl()
+        elif tag == "li":
+            self._nl()
+            if self.md and self._list:
+                top = self._list[-1]
+                if top == "ul":
+                    self.buf.append("- ")
+                else:
+                    top[1] += 1
+                    self.buf.append(f"{top[1]}. ")
+        elif tag == "a":
+            self._href = dict(attrs).get("href")
+            if self.md and self._href:
+                self.buf.append("[")
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag in ("b", "strong") and self.md:
+            self.buf.append("**")
+        elif tag in ("i", "em") and self.md:
+            self.buf.append("*")
+        elif tag in ("div", "p", "h1", "h2", "h3", "h4", "h5", "h6", "li"):
+            self._nl()
+        elif tag in ("ul", "ol"):
+            if self._list:
+                self._list.pop()
+            self._nl()
+        elif tag == "a":
+            if self.md and self._href:
+                self.buf.append(f"]({self._href})")
+            self._href = None
+
+    def handle_data(self, data: str) -> None:
+        self.buf.append(data)
+
+    def result(self) -> str:
+        text = re.sub(r"\n{3,}", "\n\n", "".join(self.buf))
+        return text.strip() + "\n"
+
+
+def _convert(body_html: str, markdown: bool) -> str:
+    conv = _Converter(markdown=markdown)
+    conv.feed(body_html or "")
+    return conv.result()
+
+
+def _read_body(args) -> str:
+    body_file = getattr(args, "body_file", None)
+    if body_file:
+        try:
+            with open(body_file, "r", encoding="utf-8") as fh:
+                return fh.read()
+        except OSError as exc:
+            die(f"cannot read --body-file: {exc}")
+    body = getattr(args, "body", None)
+    if body is None:
+        return ""
+    return body.replace("\\n", "\n").replace("\\t", "\t")
+
+
+def _parse_notes(raw: str) -> list:
+    items = []
+    for rec in raw.split(RS):
+        rec = rec.strip("\n")
+        if not rec:
+            continue
+        parts = rec.split(US)
+        if len(parts) < 5:
+            continue
+        items.append(
+            {"id": parts[0], "title": parts[1], "folder": parts[2], "modified": parts[3], "created": parts[4]}
+        )
+    return items
+
+
+# ── commands ────────────────────────────────────────────────────────
+
+def cmd_folders(args) -> None:
+    raw = osa(_SCRIPT_FOLDERS)
+    items = []
+    for rec in raw.split(RS):
+        rec = rec.strip("\n")
+        if not rec:
+            continue
+        parts = rec.split(US)
+        if len(parts) < 2:
+            continue
+        items.append({"folder": parts[0], "count": _int(parts[1])})
+    out({"folders": items, "count": len(items)})
+
+
+def cmd_list(args) -> None:
+    items = _parse_notes(osa(_SCRIPT_LIST, ANOTE_FOLDER=args.folder or ""))
+    items.sort(key=lambda x: x.get("modified") or "", reverse=True)
+    if args.limit and args.limit > 0:
+        items = items[: args.limit]
+    out({"notes": items, "count": len(items)})
+
+
+def cmd_search(args) -> None:
+    query = (args.query or "").strip()
+    if not query:
+        die("search needs a non-empty query.")
+    items = _parse_notes(osa(_SCRIPT_SEARCH, ANOTE_QUERY=args.query, ANOTE_FOLDER=args.folder or ""))
+    items.sort(key=lambda x: x.get("modified") or "", reverse=True)
+    if args.limit and args.limit > 0:
+        items = items[: args.limit]
+    out({"query": args.query, "notes": items, "count": len(items)})
+
+
+def _fetch(note_id: str) -> dict:
+    raw = osa(_SCRIPT_VIEW, ANOTE_ID=note_id)
+    # maxsplit=5 so the HTML body (last field) keeps any US/RS chars it contains
+    parts = raw.split(US, 5)
+    if len(parts) < 6:
+        die("unexpected osascript output while reading the note.")
+    body = parts[5]
+    if body.endswith("\n"):
+        body = body[:-1]
+    return {
+        "id": parts[0],
+        "title": parts[1],
+        "folder": parts[2],
+        "created": parts[3],
+        "modified": parts[4],
+        "body_html": body,
+    }
+
+
+def cmd_view(args) -> None:
+    note = _fetch(args.note_id)
+    if args.format == "html":
+        print(note["body_html"])
+        return
+    if args.format == "text":
+        print(_convert(note["body_html"], markdown=False))
+        return
+    note["text"] = _convert(note["body_html"], markdown=False)
+    out(note)
+
+
+def cmd_export(args) -> None:
+    note = _fetch(args.note_id)
+    if args.format == "html":
+        content = note["body_html"]
+    else:
+        content = _convert(note["body_html"], markdown=(args.format == "md"))
+    if args.output:
+        try:
+            with open(args.output, "w", encoding="utf-8") as fh:
+                fh.write(content if content.endswith("\n") else content + "\n")
+        except OSError as exc:
+            die(f"cannot write output: {exc}")
+        out(
+            {
+                "exported": args.output,
+                "title": note["title"],
+                "format": args.format,
+                "bytes": len(content.encode("utf-8")),
+            }
+        )
+    else:
+        print(content)
+
+
+def _dry(action: str, **fields) -> None:
+    payload = {"dry_run": True, "action": action}
+    payload.update(fields)
+    payload["hint"] = "re-run with --confirm as the LAST argument to apply"
+    out(payload)
+
+
+def cmd_create(args) -> None:
+    body = _read_body(args)
+    if not CONFIRM:
+        preview = args.title + (("\n" + body) if body else "")
+        _dry("create", title=args.title, folder=args.folder or "(default)", preview=preview)
+        return
+    note_id = osa(_SCRIPT_CREATE, ANOTE_BODY=text_to_html(args.title, body), ANOTE_FOLDER=args.folder or "").strip()
+    out({"created": True, "id": note_id, "title": args.title, "folder": args.folder or "(default)"})
+
+
+def cmd_append(args) -> None:
+    body = _read_body(args)
+    if not body.strip():
+        die("nothing to append (empty body).")
+    if not CONFIRM:
+        _dry("append", note_id=args.note_id, preview=body)
+        return
+    note_id = osa(_SCRIPT_APPEND, ANOTE_ID=args.note_id, ANOTE_BODY=text_to_html("", body)).strip()
+    out({"appended": True, "id": note_id})
+
+
+def cmd_move(args) -> None:
+    if not CONFIRM:
+        _dry("move", note_id=args.note_id, to_folder=args.folder)
+        return
+    note_id = osa(_SCRIPT_MOVE, ANOTE_ID=args.note_id, ANOTE_FOLDER=args.folder).strip()
+    out({"moved": True, "id": note_id, "folder": args.folder})
+
+
+def cmd_new_folder(args) -> None:
+    if not CONFIRM:
+        _dry("new-folder", name=args.name)
+        return
+    name = osa(_SCRIPT_NEWFOLDER, ANOTE_FOLDER=args.name).strip()
+    out({"created_folder": True, "name": name})
+
+
+def cmd_delete(args) -> None:
+    if not CONFIRM:
+        _dry("delete", note_id=args.note_id, note="moves the note to Recently Deleted (recoverable)")
+        return
+    note_id = osa(_SCRIPT_DELETE, ANOTE_ID=args.note_id).strip()
+    out({"deleted": True, "id": note_id, "note": "moved to Recently Deleted (recoverable ~30 days)"})
+
+
+def main() -> None:
+    if sys.platform != "darwin":
+        die("apple-notes is macOS-only (it drives Notes.app via AppleScript).")
+
+    parser = argparse.ArgumentParser(prog="notes.py", description="Manage Apple Notes via AppleScript.")
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--timeout", type=int, default=90, help="osascript timeout in seconds (default 90)")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    sub.add_parser("folders", parents=[common], help="list folders with note counts").set_defaults(func=cmd_folders)
+
+    p = sub.add_parser("list", parents=[common], help="list notes (newest first)")
+    p.add_argument("--folder")
+    p.add_argument("--limit", type=int, default=50)
+    p.set_defaults(func=cmd_list)
+
+    p = sub.add_parser("search", parents=[common], help="search notes by title + body")
+    p.add_argument("query")
+    p.add_argument("--folder")
+    p.add_argument("--limit", type=int, default=50)
+    p.set_defaults(func=cmd_search)
+
+    p = sub.add_parser("view", parents=[common], help="show one note")
+    p.add_argument("note_id")
+    p.add_argument("--format", choices=["json", "text", "html"], default="json")
+    p.set_defaults(func=cmd_view)
+
+    p = sub.add_parser("export", parents=[common], help="export one note")
+    p.add_argument("note_id")
+    p.add_argument("--format", choices=["md", "html", "text"], default="md")
+    p.add_argument("-o", "--output")
+    p.set_defaults(func=cmd_export)
+
+    p = sub.add_parser("create", parents=[common], help="create a note (GATED)")
+    p.add_argument("--title", required=True)
+    grp = p.add_mutually_exclusive_group()
+    grp.add_argument("--body")
+    grp.add_argument("--body-file")
+    p.add_argument("--folder")
+    p.set_defaults(func=cmd_create)
+
+    p = sub.add_parser("append", parents=[common], help="append text to a note (GATED)")
+    p.add_argument("note_id")
+    grp = p.add_mutually_exclusive_group(required=True)
+    grp.add_argument("--body")
+    grp.add_argument("--body-file")
+    p.set_defaults(func=cmd_append)
+
+    p = sub.add_parser("move", parents=[common], help="move a note to a folder (GATED)")
+    p.add_argument("note_id")
+    p.add_argument("--folder", required=True)
+    p.set_defaults(func=cmd_move)
+
+    p = sub.add_parser("new-folder", parents=[common], help="create a folder (GATED)")
+    p.add_argument("name")
+    p.set_defaults(func=cmd_new_folder)
+
+    p = sub.add_parser("delete", parents=[common], help="move a note to Recently Deleted (GATED)")
+    p.add_argument("note_id")
+    p.set_defaults(func=cmd_delete)
+
+    args = parser.parse_args(ARGV)
+    global TIMEOUT
+    TIMEOUT = args.timeout
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

package/skills/didi-ride/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: didi-ride
+description: 通过滴滴出行 MCP 打车、查价、查询订单、取消订单、规划路线（驾车/公交/步行/骑行）和搜索地点。Use when the user mentions 滴滴, 打车, 叫车, 回家/上班要打车, 查一下从 A 到 B 多少钱/怎么走, 查询订单, 司机在哪/多久到, 预约叫车, 路线规划, DiDi, ride-hailing, or booking a taxi.
+when_to_use: |
+  Trigger for anything involving the user's DiDi (滴滴出行) account:
+  book a ride ("打车去…", "回家", "上班"), get a fare/route estimate,
+  query an existing order (driver location, ETA, trip progress), cancel
+  an order, plan a driving/transit/walking/cycling route, or search
+  places / reverse-geocode. Creating and cancelling orders act on real
+  money and a real driver, so those writes are gated behind explicit
+  confirmation.
+connections: [didi]
+allowed_tools: [Bash]
+license: Apache-2.0
+metadata:
+  author: acedatacloud
+  version: "1.0"
+---
+
+# DiDi Ride (滴滴出行)
+
+Drive the user's **DiDi (滴滴出行)** account through the DiDi MCP server:
+book rides, estimate fares, track orders, cancel, and plan routes.
+
+The `didi` BYOC connector injects one env var into the sandbox:
+
+- `DIDI_MCP_KEY` — the user's DiDi MCP key. **Secret — never echo, print, or log it.**
+
+If `DIDI_MCP_KEY` is missing, tell the user to connect the DiDi connector at
+[auth.acedata.cloud/user/connections](https://auth.acedata.cloud/user/connections)
+(they get the key by scanning the QR in the 滴滴出行 App or via
+<https://mcp.didichuxing.com/claw>).
+
+## CLI
+
+The skill ships a stdlib-only helper that speaks the MCP Streamable-HTTP
+protocol to DiDi. Point at it once:
+
+```bash
+DIDI=$SKILL_DIR/scripts/didi.py
+```
+
+Two commands:
+
+```bash
+python3 $DIDI list                        # list tools + their JSON input schemas
+python3 $DIDI call <tool> '<json-args>'   # call any tool
+```
+
+**Always check `references/api_references.md` for the exact tool + parameter
+names before calling.** When unsure, run `python3 $DIDI list` — it returns the
+authoritative input schema for every tool straight from DiDi. Do **not** guess
+parameter names (common mistakes: `keyword` → `keywords`, `region` → `city`,
+four coord fields → six `from_name/from_lat/from_lng/to_name/to_lat/to_lng`).
+
+All argument **values must be strings** (including coordinates and
+`product_category`), e.g. `{"product_category":"1"}` not `{"product_category":1}`.
+
+## Write gating (real money / real driver)
+
+`taxi_create_order` and `taxi_cancel_order` are **gated**: without a trailing
+`--confirm` the helper only DRY-RUNS and changes nothing. Run once without
+`--confirm` to preview, then re-run with `--confirm` as the **last** argument
+after the user approves:
+
+```bash
+python3 $DIDI call taxi_create_order '{"estimate_trace_id":"...","product_category":"1"}' --confirm
+```
+
+- Even when the user says "打车" / "取消订单", confirm the concrete details
+  (起终点、车型 for booking; the order for cancelling) before adding `--confirm`.
+- Cancel intent ≠ cancel confirmation — always ask "确认取消吗？" first.
+
+## Booking flow (最小可执行)
+
+1. **Resolve addresses** — `maps_textsearch` (never invent coordinates; don't
+   reuse coordinates from earlier turns — the user may have moved).
+   - If the user references an address alias (家 / 公司 / etc.) that you don't
+     have, ask them; this skill has no stored preferences.
+2. **Confirm start/end** — if `maps_textsearch` returns ≥2 candidates, list at
+   least the top 3 and let the user pick; a single exact match needs no
+   confirmation.
+3. **Estimate** — `taxi_estimate`; record the returned `traceId` /
+   `estimate_trace_id`. It expires (`-32021`) — re-estimate if stale.
+4. **Pick car type** — user's current message wins ("叫快车"→`product_category`
+   `1`, "专车"→`8`); otherwise ask. Only use categories present in the
+   `taxi_estimate` response; never silently substitute a different service level
+   (快车 `1` ≠ 特惠快车 `201`).
+5. **Create order** — `taxi_create_order` with the latest `estimate_trace_id`
+   (dry-run → confirm → `--confirm`).
+6. **Report** — order id, start/end, car type, estimated fare. Tell the user
+   they can send 「查询订单」 to check status.
+
+## Query an order
+
+Order id comes from (in priority): the user's message → the most recent order
+created this conversation → else ask.
+
+```bash
+python3 $DIDI call taxi_query_order '{"order_id":"ORDER_ID"}'
+```
+
+Status codes (`code`):
+
+| code | 含义 | 输出 |
+|------|------|------|
+| 0 | 匹配中 | ⏳ 正在为您匹配司机 |
+| 1 | 司机已接单 | 展示司机姓名、车型、车牌、电话、距离与预计到达时间 |
+| 2 | 司机已到达 | 🔔 司机已到达上车点 |
+| 4 | 行程进行中 | 🚗 行程已开始 |
+| 5 | 订单完成 | ✅ 行程结束（展示费用，如有） |
+| 6 | 系统取消 | ❌ 订单已被系统取消 |
+| 7 | 已取消 | ❌ 订单已取消 |
+| 3 / 8-12 | 其他终态 | 显示对应状态描述 |
+
+## Routes & places (no order needed)
+
+```bash
+python3 $DIDI call maps_direction_driving  '{"from_name":"...","from_lat":"...","from_lng":"...","to_name":"...","to_lat":"...","to_lng":"..."}'
+python3 $DIDI call maps_direction_transit  '{...}'   # 公交
+python3 $DIDI call maps_direction_walking  '{...}'   # 步行
+python3 $DIDI call maps_direction_bicycling '{...}'  # 骑行
+python3 $DIDI call maps_place_around '{"keywords":"咖啡","lat":"...","lng":"..."}'
+python3 $DIDI call maps_regeocode '{"lat":"...","lng":"..."}'
+```
+
+## Gotchas
+
+- **Never print the key or the raw endpoint URL** — the helper handles the
+  transport and keeps the key internal.
+- `taxi_create_order` takes only `estimate_trace_id`, `product_category`, and
+  optional `caller_car_phone`. Don't pass the estimate's coordinate/name fields.
+- No stored preferences: this skill doesn't remember home/work/car type — ask
+  the user, or wire richer memory in a higher layer.
+- Auth failure surfaces as `-32002` (or HTTP 401/403): the key is missing/expired
+  → have the user reconnect the connector.
+
+> **Setup:** See [authentication](../_shared/authentication.md). This skill uses
+> the `didi` connector's injected `DIDI_MCP_KEY`, not `ACEDATACLOUD_API_TOKEN`.

package/skills/didi-ride/references/api_references.md

@@ -0,0 +1,97 @@
+# DiDi MCP — Tool Reference
+
+Authoritative schemas come from `python3 $DIDI list` (the DiDi server returns
+each tool's `inputSchema`). This file summarizes the tools and the parameter
+names that are easy to get wrong. **All values are strings.**
+
+## Places & geocoding
+
+### `maps_textsearch` — search a place by text
+| param | required | notes |
+|-------|----------|-------|
+| `keywords` | yes | search text, e.g. `北京西站` (NOT `keyword`) |
+| `city` | no | city name to scope the search, e.g. `北京` (NOT `region`) |
+
+Returns candidate places with names + coordinates. Use these coordinates for
+`taxi_estimate` and the `maps_direction_*` tools.
+
+### `maps_regeocode` — coordinates → address
+| param | required |
+|-------|----------|
+| `lat` | yes |
+| `lng` | yes |
+
+## Routes
+
+`maps_direction_driving` / `maps_direction_transit` / `maps_direction_walking`
+/ `maps_direction_bicycling` — all take the same six fields:
+
+| param | required |
+|-------|----------|
+| `from_name` | yes |
+| `from_lat` | yes |
+| `from_lng` | yes |
+| `to_name` | yes |
+| `to_lat` | yes |
+| `to_lng` | yes |
+
+### `maps_place_around` — nearby POI search
+| param | required | notes |
+|-------|----------|-------|
+| `keywords` | yes | POI keyword, e.g. `咖啡` |
+| `lat` | yes | center latitude |
+| `lng` | yes | center longitude |
+
+## Ride hailing
+
+### `taxi_estimate` — price/ETA estimate (do this before ordering)
+Six coordinate/name fields (same as routes):
+`from_name`, `from_lat`, `from_lng`, `to_name`, `to_lat`, `to_lng`.
+
+Returns a list of available car types, each with a `productCategory` and price,
+plus a `traceId` / `estimate_trace_id` required by `taxi_create_order`. The
+trace id expires — a stale one returns `-32021`; re-estimate to refresh.
+
+Common `product_category` values:
+
+| code | 车型 |
+|------|------|
+| `1` | 快车 |
+| `8` | 专车 |
+| `201` | 特惠快车 |
+
+> Treat these as hints — always match against the `productCategory` values the
+> live `taxi_estimate` response actually returns. `1` (快车) and `201`
+> (特惠快车) are different service levels; never swap one for the other.
+
+### `taxi_create_order` — book the ride  ⚠️ WRITE (needs `--confirm`)
+| param | required | notes |
+|-------|----------|-------|
+| `estimate_trace_id` | yes | from the latest `taxi_estimate` |
+| `product_category` | yes | chosen car type code (string) |
+| `caller_car_phone` | no | omit unless the user gives a number |
+
+Only these three fields. Do **not** pass coordinate/name fields.
+
+### `taxi_query_order` — status + driver location
+| param | required |
+|-------|----------|
+| `order_id` | yes |
+
+Status `code`: `0` 匹配中 · `1` 司机已接单 · `2` 司机已到达 · `4` 行程中 ·
+`5` 完成 · `6` 系统取消 · `7` 已取消 · `3`/`8`-`12` 其他终态.
+
+### `taxi_cancel_order` — cancel  ⚠️ WRITE (needs `--confirm`)
+| param | required |
+|-------|----------|
+| `order_id` | yes |
+
+Always ask "确认取消吗？" before adding `--confirm`.
+
+## Errors
+
+| code | meaning | action |
+|------|---------|--------|
+| `-32002` / HTTP 401 / 403 | auth failed | key missing/expired → reconnect connector |
+| `-32021` | estimate trace expired | re-run `taxi_estimate` |
+| HTTP 400 | bad params | re-check parameter names against `didi.py list` |

package/skills/didi-ride/scripts/didi.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python3
+"""DiDi ride helper — talks to the DiDi MCP server over the MCP
+Streamable-HTTP transport using only the Python standard library.
+
+The `didi` BYOC connector injects one env var:
+
+    DIDI_MCP_KEY   the user's DiDi MCP key (secret — never printed)
+
+Usage:
+    python3 didi.py list                        # list available tools + schemas
+    python3 didi.py call <tool> '<json-args>'   # call any tool
+
+State-changing tools (`taxi_create_order`, `taxi_cancel_order`) are
+gated: without a trailing `--confirm` they only DRY-RUN and change
+nothing. `--confirm` is honored only as the LAST argument.
+
+Examples:
+    python3 didi.py call maps_textsearch '{"keywords":"北京西站","city":"北京"}'
+    python3 didi.py call taxi_estimate '{"from_name":"...","from_lat":"39.9","from_lng":"116.3","to_name":"...","to_lat":"39.9","to_lng":"116.4"}'
+    python3 didi.py call taxi_create_order '{"estimate_trace_id":"...","product_category":"1"}' --confirm
+    python3 didi.py call taxi_query_order '{"order_id":"..."}'
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+
+MCP_ENDPOINT = os.environ.get("DIDI_MCP_URL", "https://mcp.didichuxing.com/mcp-servers")
+MCP_KEY = os.environ.get("DIDI_MCP_KEY", "").strip()
+PROTOCOL_VERSION = "2025-06-18"
+
+# Tools that create or cancel a real ride — must be confirmed explicitly.
+WRITE_TOOLS = {"taxi_create_order", "taxi_cancel_order"}
+
+
+def die(payload: dict, code: int = 1) -> None:
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    sys.exit(code)
+
+
+class MCPClient:
+    """Minimal MCP Streamable-HTTP client (stdlib only).
+
+    Never logs or echoes the key; the endpoint URL (which carries the
+    key as a query param) is kept internal and never printed.
+    """
+
+    def __init__(self, endpoint: str, key: str) -> None:
+        sep = "&" if "?" in endpoint else "?"
+        self._url = f"{endpoint}{sep}key={urllib.parse.quote(key, safe='')}"
+        self._session_id: str | None = None
+        self._rid = 0
+
+    def _post(self, payload: dict, expect_id):
+        body = json.dumps(payload).encode("utf-8")
+        req = urllib.request.Request(self._url, data=body, method="POST")
+        req.add_header("Content-Type", "application/json")
+        req.add_header("Accept", "application/json, text/event-stream")
+        req.add_header("MCP-Protocol-Version", PROTOCOL_VERSION)
+        if self._session_id:
+            req.add_header("Mcp-Session-Id", self._session_id)
+        try:
+            resp = urllib.request.urlopen(req, timeout=90)
+        except urllib.error.HTTPError as exc:
+            detail = exc.read().decode("utf-8", "replace")[:600]
+            die(
+                {
+                    "error": f"HTTP {exc.code} from DiDi MCP",
+                    "detail": detail,
+                    "hint": "If 401/403, the DiDi connector key is missing or expired — "
+                    "reconnect at https://auth.acedata.cloud/user/connections",
+                }
+            )
+        except urllib.error.URLError as exc:
+            die({"error": "network error reaching DiDi MCP", "detail": str(exc.reason)})
+        except Exception as exc:  # noqa: BLE001
+            # Never let an unexpected traceback surface — self._url carries the
+            # key as a query param (DiDi mandates ?key=), so emit only the
+            # exception type, never its message or the URL.
+            die({"error": "unexpected error calling DiDi MCP", "detail": type(exc).__name__})
+        sid = resp.headers.get("Mcp-Session-Id")
+        if sid:
+            self._session_id = sid
+        ctype = (resp.headers.get("Content-Type") or "").lower()
+        raw = resp.read().decode("utf-8", "replace")
+        return _parse_response(raw, ctype, expect_id)
+
+    def initialize(self) -> None:
+        self._rid += 1
+        result = self._post(
+            {
+                "jsonrpc": "2.0",
+                "id": self._rid,
+                "method": "initialize",
+                "params": {
+                    "protocolVersion": PROTOCOL_VERSION,
+                    "capabilities": {},
+                    "clientInfo": {"name": "acedata-didi-skill", "version": "1.0"},
+                },
+            },
+            expect_id=self._rid,
+        )
+        if isinstance(result, dict) and result.get("error"):
+            die({"error": "DiDi MCP initialize failed", "detail": result["error"]})
+        # Fire-and-forget the initialized notification (no response expected).
+        self._post({"jsonrpc": "2.0", "method": "notifications/initialized"}, expect_id=None)
+
+    def list_tools(self):
+        self._rid += 1
+        return self._post(
+            {"jsonrpc": "2.0", "id": self._rid, "method": "tools/list"},
+            expect_id=self._rid,
+        )
+
+    def call_tool(self, name: str, arguments: dict):
+        self._rid += 1
+        return self._post(
+            {
+                "jsonrpc": "2.0",
+                "id": self._rid,
+                "method": "tools/call",
+                "params": {"name": name, "arguments": arguments},
+            },
+            expect_id=self._rid,
+        )
+
+
+def _parse_response(raw: str, ctype: str, expect_id):
+    """Return the JSON-RPC envelope for our request id.
+
+    Handles both plain application/json and text/event-stream (SSE),
+    where the response arrives as one or more `data: {...}` lines.
+    """
+    messages: list[dict] = []
+    if "text/event-stream" in ctype:
+        for line in raw.splitlines():
+            line = line.strip()
+            if not line.startswith("data:"):
+                continue
+            chunk = line[5:].strip()
+            if not chunk or chunk == "[DONE]":
+                continue
+            try:
+                messages.append(json.loads(chunk))
+            except json.JSONDecodeError:
+                continue
+    else:
+        raw = raw.strip()
+        if not raw:
+            return {}
+        try:
+            messages.append(json.loads(raw))
+        except json.JSONDecodeError:
+            die({"error": "unparseable response from DiDi MCP", "detail": raw[:600]})
+    if expect_id is not None:
+        for msg in messages:
+            if isinstance(msg, dict) and msg.get("id") == expect_id:
+                return msg
+    return messages[-1] if messages else {}
+
+
+def emit(envelope: dict) -> None:
+    if not isinstance(envelope, dict):
+        print(json.dumps(envelope, ensure_ascii=False, indent=2))
+        return
+    if envelope.get("error"):
+        die({"error": envelope["error"]})
+    result = envelope.get("result", envelope)
+    # tools/call results wrap text in a content[] array.
+    if isinstance(result, dict) and isinstance(result.get("content"), list):
+        texts = [
+            c.get("text", "")
+            for c in result["content"]
+            if isinstance(c, dict) and c.get("type") == "text"
+        ]
+        if texts:
+            print("\n".join(texts))
+            if result.get("isError"):
+                sys.exit(1)
+            return
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+
+def _format_tools(envelope: dict) -> None:
+    tools = (envelope.get("result") or {}).get("tools") if isinstance(envelope, dict) else None
+    if not tools:
+        emit(envelope)
+        return
+    slim = [
+        {
+            "name": t.get("name"),
+            "description": t.get("description"),
+            "inputSchema": t.get("inputSchema"),
+        }
+        for t in tools
+    ]
+    print(json.dumps(slim, ensure_ascii=False, indent=2))
+
+
+def main() -> None:
+    if not MCP_KEY:
+        die(
+            {
+                "error": "DIDI_MCP_KEY not set",
+                "hint": "Connect the DiDi connector at "
+                "https://auth.acedata.cloud/user/connections to inject the key.",
+            }
+        )
+
+    argv = sys.argv[1:]
+    confirm = bool(argv) and argv[-1] == "--confirm"
+    if confirm:
+        argv = argv[:-1]
+    if not argv:
+        die({"error": "usage: didi.py <list|call> ..."})
+
+    cmd, rest = argv[0], argv[1:]
+    client = MCPClient(MCP_ENDPOINT, MCP_KEY)
+
+    if cmd == "list":
+        client.initialize()
+        _format_tools(client.list_tools())
+        return
+
+    if cmd == "call":
+        if not rest:
+            die({"error": "call needs a tool name", "usage": "didi.py call <tool> '<json-args>'"})
+        tool = rest[0]
+        args_raw = rest[1] if len(rest) > 1 else "{}"
+        try:
+            arguments = json.loads(args_raw)
+        except json.JSONDecodeError as exc:
+            die({"error": "arguments must be valid JSON", "detail": str(exc), "got": args_raw})
+        if not isinstance(arguments, dict):
+            die({"error": "arguments JSON must be an object", "got": args_raw})
+
+        if tool in WRITE_TOOLS and not confirm:
+            print(
+                json.dumps(
+                    {
+                        "dry_run": True,
+                        "tool": tool,
+                        "arguments": arguments,
+                        "note": "state-changing call — re-run with --confirm as the LAST "
+                        "argument to actually perform it",
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            return
+
+        client.initialize()
+        emit(client.call_tool(tool, arguments))
+        return
+
+    die({"error": f"unknown command: {cmd}", "usage": "didi.py <list|call> ..."})
+
+
+if __name__ == "__main__":
+    main()