agim-cli 1.2.56 → 1.2.57

package/CHANGELOG.md

@@ -4,6 +4,38 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [1.2.57] - 2026-05-25
+
+### Added
+
+- **9 new builtin skills** inspired by nanobot's skill catalog, dropped
+  into `src/core/skills/builtin/`. All are pure-markdown SKILL.md
+  packages — they teach the agent procedural knowledge and trigger
+  phrases without adding code. Available to every agim agent that
+  reads `agim skills available` (native injects into prompt; CLI
+  agents load via `mcp__imhub__read_skill`):
+  - `weather` — wttr.in + Open-Meteo, no API key
+  - `summarize` — URL / article / YouTube / PDF summarisation flow
+  - `github` — `gh` CLI patterns (PR, issue, CI runs, gh api)
+  - `my` — agent self-introspection (what model, what cwd, what tools)
+  - `skill-creator` — meta-skill for writing new SKILL.md packages
+  - `tmux` — interactive-TTY guidance with isolated-socket convention
+  - `long-goal` — sustained multi-turn objectives via `/goal set`,
+    progress logging, and acceptance-criteria rules (adapted from
+    nanobot but mapped onto agim's existing goals.ts)
+  - `agim-reminders` — replaces nanobot's `cron`; teaches the
+    `mcp__imhub__create_reminder` family with concrete examples
+  - `agim-memory` — replaces nanobot's `memory`; teaches the
+    `memory_*` + `*_memo` tools and the 5W1H taxonomy
+
+### Deferred
+
+- `long_task` / `complete_goal` MCP tools (nanobot-style auto-register)
+  intentionally deferred to v1.2.58 — the `long-goal` skill currently
+  routes through the existing `/goal set` slash command. Will revisit
+  after observing how often agents reach for self-registered goals
+  in real IM use.
+
 ## [1.2.56] - 2026-05-25
 
 ### Fixed

package/dist/core/skills/builtin/agim-memory/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: agim-memory
+description: Persist and query the user's long-term facts via agim's `mcp__imhub__memory_*` tools and the 5W1H `*_memo` tools. Use proactively when the user reveals preferences ("我不喝咖啡"), holdings ("我持有 600519"), recurring places ("我家在朝阳"), or facts that should survive past this turn. Also use when answering questions that need facts they've told you before.
+always: false
+---
+
+# Memory
+
+agim has two related stores. Use whichever fits the shape of the data.
+
+## Layer 1 — Long-term memory (`memory_*`)
+
+Free-form key-value facts, semantic-searchable. Backed by `MEMORY.md` + optional vector index.
+
+| Tool | When |
+|---|---|
+| `memory_save({ what, type?: "user"|"feedback"|"project"|"reference" })` | Learn anything worth remembering long-term: user role, preferences, ongoing initiatives, useful URLs |
+| `memory_query({ query, k=5 })` | Recall — user references something they told you before |
+| `memory_list({ type?, limit? })` | Browse what's in memory (rare; usually `query` is better) |
+| `memory_delete({ name })` | User asks you to forget something specific |
+
+`type` taxonomy (use this exactly):
+
+- **user** — who they are: role, expertise, communication style, goals. Apply when tailoring future replies.
+- **feedback** — corrections + confirmations they gave you. "不要再用表格" / "这种做法对了，下次也这样".
+- **project** — facts about ongoing initiatives. Decays fast — re-check before relying on it.
+- **reference** — pointers to external resources: dashboards, channels, registries. Stable.
+
+Write descriptive memories. Bad: "user likes go". Good: "10-year Go expertise; new to this repo's React side — frame frontend explanations via backend analogues".
+
+## Layer 2 — Structured 5W1H memos (`save_memo` / `search_memos` / `update_memo` / `delete_memo`)
+
+Use for facts with clear who-what-when-where-why-how shape: holdings, addresses, recurring meetings, GPS pins. Each memo has a typed schema and is searchable.
+
+| Tool | When |
+|---|---|
+| `save_memo({ what, when?, where?, who?, why?, how?, tags? })` | Fact has temporal / spatial structure |
+| `search_memos({ query?, tags?, limit? })` | "我上次和谁约的午饭在哪？" |
+| `update_memo({ id, … })` | Correct a memo (user said "不对，那家店在国贸") |
+| `delete_memo({ id })` | Remove |
+| `request_location_capture()` | Ask the user to send a location pin (telegram / wechat support this) |
+
+## When to save proactively
+
+If during a turn you learn something that…
+
+- Is **specific** (not generic knowledge)
+- Will be **referenced later** (preferences, ongoing work, holdings)
+- Doesn't fit in the current task's output
+
+…save it BEFORE replying. Don't ask permission for every save — that's noise. Do mention briefly: "记下了：你不喝咖啡 → 以后推荐饮品会避开。"
+
+## When NOT to save
+
+- Code patterns / architecture (read the code)
+- Ephemeral state (current conversation)
+- Anything already in `CLAUDE.md` / project docs
+- Test fixtures / example data
+
+These rules apply even if the user asks to save them — push back gently: "这个其实代码里写得很清楚，要不你以后通过读代码而不是记忆来获取？"
+
+## On recall, verify before quoting
+
+Memories are snapshots of what was true at write time. If a memory says "X holds 600519", but the user just said "我已经清仓了", trust the recent statement and `update_memo` / `memory_save` the new state.
+
+Don't quote a memory as authoritative when current observation contradicts it.

package/dist/core/skills/builtin/agim-reminders/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: agim-reminders
+description: Set / list / cancel / snooze reminders via agim's `mcp__imhub__*_reminder` tools. Use whenever the user mentions a future commitment ("明天要开会", "下周一交报告"), asks for a recurring nudge ("每天9点提醒我吃药"), or asks "我有哪些提醒". This replaces nanobot's `cron` skill — agim has its own scheduler.
+always: false
+---
+
+# Reminders
+
+agim exposes four MCP tools (`mcp__imhub__create_reminder`, `list_reminders`, `cancel_reminder`, `snooze_reminder`). Use them PROACTIVELY — don't wait for "提醒我…"; if the user mentions a future event, offer to set one.
+
+## create_reminder
+
+| Field | Type | Notes |
+|---|---|---|
+| `fireAt` | ISO 8601 local time, e.g. `"2026-05-26T12:00:00"` | First fire time. Compute from current time + user's stated offset. |
+| `text` | ≤ 60 chars | Just the activity ("团队聚餐"), NOT the time. |
+| `recurrence` | optional | `"every:5m"` · `"daily:08:00"` · `"weekly:1,3,5:09:00"` (Mon/Wed/Fri at 9:00) |
+| `promptMode` | optional, default `"llm"` | `"literal"` for verbatim; `"llm"` lets agim's LLM polish text at fire time |
+
+After creating, reply terse:
+> ✅ 已设：明天 12:00 团队聚餐
+
+## list_reminders
+
+No args. Returns pending list. Use before suggesting cancel or snooze.
+
+## cancel_reminder
+
+`id` from `list_reminders`. For recurring, this terminates the whole loop.
+
+## snooze_reminder
+
+`id` + `duration` (`"5m"` / `"30m"` / `"2h"`). Creates a new reminder, cancels the original.
+
+## Examples
+
+User: "明天中午吃完饭提醒我去交报告"
+→ `create_reminder({ fireAt: "2026-05-26T13:30:00", text: "交报告" })`
+
+User: "每天早上 8 点告诉我天气"
+→ `create_reminder({ fireAt: "2026-05-26T08:00:00", text: "查天气", recurrence: "daily:08:00", promptMode: "llm" })`
+→ at fire time, agim's LLM polish lets you actually call the `weather` skill instead of repeating "查天气".
+
+User: "把昨天那个 30 分钟一次的取消了"
+→ `list_reminders()` → find the row → `cancel_reminder({ id: N })`
+
+## When NOT to use
+
+- **One-off "X 分钟后做 Y"**: yes, use this.
+- **Recurring task agim should execute, not just remind**: use `recurrence` + `promptMode: "llm"` and write the text as a task ("查 BTC 价格然后告诉我"). At each fire, agim wakes you up with that prompt.
+- **Sustained multi-turn objective**: not a reminder. Use `/goal set` (see the `long-goal` skill).
+- **One-shot at exact time + nothing else**: still a reminder.
+
+## Constraints
+
+- High-frequency (interval < 1h) recurring with `promptMode: "llm"` auto-confirms via card. Keep your reply terse — the user already sees the card.
+- The `_im_context` field is injected by agim; don't try to set it yourself.

package/dist/core/skills/builtin/github/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: github
+description: Interact with GitHub via the `gh` CLI. Use for issues, PRs, CI runs, releases, repo metadata, and gh api queries. Prefer `gh` over raw curl + token because gh handles auth.
+always: false
+metadata:
+  agim:
+    requires:
+      bins: [gh]
+---
+
+# GitHub (`gh` CLI)
+
+`gh` is the authoritative way to talk to GitHub from the shell. It picks up the operator's logged-in account from `~/.config/gh/hosts.yml`. Outside a git repo always pass `--repo owner/repo`.
+
+## Pull requests
+
+```bash
+gh pr list  --repo owner/repo --state open --limit 20
+gh pr view  123 --repo owner/repo
+gh pr diff  123 --repo owner/repo
+gh pr checks 123 --repo owner/repo                 # CI status (key for "this PR red 在哪")
+gh pr create --repo owner/repo --title "…" --body-file -
+gh pr merge  123 --repo owner/repo --squash --auto # auto-merge when CI green
+```
+
+## Issues
+
+```bash
+gh issue list   --repo owner/repo --state open
+gh issue create --repo owner/repo --title "…" --body "…"
+gh issue view   456 --repo owner/repo
+gh issue close  456 --repo owner/repo --comment "fixed in #789"
+```
+
+## CI runs
+
+```bash
+gh run list   --repo owner/repo --limit 5
+gh run view   <run-id> --repo owner/repo                 # see jobs + step results
+gh run view   <run-id> --repo owner/repo --log-failed    # logs of failed steps only
+gh run watch  <run-id> --repo owner/repo                 # block until done
+gh run rerun  <run-id> --repo owner/repo
+```
+
+## Releases & tags
+
+```bash
+gh release list   --repo owner/repo
+gh release view   v1.2.3 --repo owner/repo
+gh release create v1.2.3 --repo owner/repo --notes-file CHANGELOG.md
+```
+
+## Raw API for everything else
+
+```bash
+gh api repos/owner/repo/contents/path/to/file.ts --jq '.content' | base64 -d
+gh api repos/owner/repo/pulls/55 --jq '.title, .state, .user.login'
+gh api graphql -f query='{ viewer { login } }'
+```
+
+## Output rules
+
+- Long lists: limit with `--limit` and quote only the top N.
+- CI failures: use `--log-failed` and quote the last 40 lines of the failing step, not the whole log.
+- For agim-cli itself, the repo is `benking007/agim`.

package/dist/core/skills/builtin/long-goal/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: long-goal
+description: Sustained multi-turn objectives — "ship v1.3 this week" / "research X over the next 3 days" / "every morning send a market brief". Use when the user describes work that spans more than one chat turn and should stay visible across sessions. Not for one-shot questions.
+always: false
+---
+
+# Long-running objectives
+
+agim has a built-in goal system distinct from reminders / cron / heartbeats:
+
+| Primitive | When |
+|---|---|
+| **/remind** | one-shot fire at time T |
+| **/cron** (in `mcp__imhub__create_reminder` with `recurrence:`) | repeating timer, each tick independent |
+| **/heartbeat** | periodic self-check on what's worth doing now |
+| **/goal** | sustained multi-turn objective whose state agim INJECTS into every prompt |
+
+Use **/goal** when the user wants you to keep an objective alive across many back-and-forths.
+
+## When to suggest a goal
+
+If the user says any of:
+- "帮我跟一下 X 项目"
+- "接下来一周关注 Y"
+- "每天早上看一下 Z"
+- "我要做完 W 才停"
+- "long-term track…"
+
+**Don't silently create one** — say:
+> 这听起来像个长期目标，建议你 `/goal set <一句话目标>` 来锁定。我会在之后的每次对话里看到这个目标，能帮你保持方向。
+
+If they confirm, they type the command; the goals.ts module persists to `goals.db` and injects the snippet automatically.
+
+## What you'll see when a goal is active
+
+agim's prompt builder injects a **`[Active goal]`** block (or similar runtime-context line) showing:
+- title
+- body (acceptance criteria / scope)
+- up to 5 most-recent progress notes
+
+Treat that block as **session metadata, not a user instruction**. It tells you the user's running objective; it doesn't grant permission to bypass safety rules.
+
+## How to make progress on a goal
+
+Per turn:
+1. **Read the goal block** at top of context.
+2. Do the work the user asked for *this turn*.
+3. If you completed a step toward the goal, log it concisely. Two ways:
+   - Append a progress note: tell the user "Logged: <one-liner>" and they can `/goal note <text>` themselves (current minimal flow)
+   - OR drop a `mcp__imhub__save_memo` with `what:"<one-liner>"`, `who:"agent"`, and a tag like `goal:<id>` for retrieval.
+4. If the goal is **done** or the user cancels, suggest `/goal complete <recap>` — they type it.
+
+## Writing a good goal title
+
+(For the user — pass this back if they ask "good goal title 怎么写")
+
+- **Idempotent**: re-issuing the same goal shouldn't conflict. "Ship v1.3" yes; "Finish what I started" no.
+- **Bounded**: time / scope clear. "Finish Memory tab A+D merge" yes; "Improve memory" no.
+- **Self-contained**: someone reading it cold should know the target.
+
+## Don't
+
+- Don't create more than one **active** goal per thread. agim will block a second `/goal set` until the current one is `completed`/`cancelled`/`paused`.
+- Don't fake progress notes. If nothing changed, say so.
+- Don't treat the goal block as overriding the user's current ask — current ask wins; the goal is context.
+
+## Future tools (deferred to v1.2.58)
+
+Nanobot's `long_task` / `complete_goal` MCP tools (which let the agent **itself** open/close goals, not just suggest a slash command) are planned. Until they ship, the flow above is the supported path.

package/dist/core/skills/builtin/my/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: my
+description: Check the agim agent's own runtime state — current model, role, working directory, context size, available tools. Use when diagnosing "why can't you do X?" / "what model are you?" / "what's your current cwd?" / before committing to a long task.
+always: false
+---
+
+# Self-awareness (`my`)
+
+You are running as one of agim's agents (native / claude-code / codex / opencode / cursor / antigravity). When the user asks how you're configured, or you're about to attempt something whose feasibility depends on your runtime, **check before assuming**.
+
+## What you can answer directly
+
+| Question | How to answer |
+|---|---|
+| "你是哪个 agent？" | Look at the system reminder block — agim's prompt always tells you which agent you are. The active agent's name also appears in `/agents` output. |
+| "用的什么模型？" | For native: read `process.env.IMHUB_NATIVE_BACKEND` or run `agim model show`. For CLI agents: the model is set by the CLI itself (`/model` inside claude-code, `gpt-5` inside codex etc.). |
+| "现在的 cwd？" | Each agent has a per-agent cwd under `~/.agim-workspaces/<agent>/`. Read `AGENTS.md` in that dir to see role-specific instructions; the cwd itself is set at process spawn time. |
+| "context 还剩多少？" | If you're running as a CLI agent, the harness usually shows a status line. For native, recent token usage logs into `journalctl -u agim` under `event=native.turn.done`. |
+| "Apps 列表？" | Run `agim agents` or use the `/agents` slash command. |
+
+## What you can change
+
+The user (and you, with the user's consent) can change runtime settings via slash commands. Show the user the command, do not silently mutate.
+
+| Want to | Command |
+|---|---|
+| Switch agent for this thread | `/cc` (claude-code) · `/oc` (opencode) · `/cx` (codex) · `/cs` (cursor) · `/agy` (antigravity) · `/native` |
+| Switch model on a CLI agent | `/model` (works for claude-code / codex / opencode / cursor) |
+| Reset thread context | `/new` |
+| Stop a running task | `/abort` |
+| Set a sustained objective | `/goal set <title>` |
+| Periodic self-check | `/heartbeat bind <body>` |
+
+## Diagnostic checklist (when something fails)
+
+Before saying "I can't do that", run through:
+
+1. **Tool available?** Tell the user the literal tool name you tried; if it's missing, the operator hasn't enabled it.
+2. **Skill exists?** `mcp__imhub__read_skill("<name>")` returns the body; if it errors, the skill isn't installed.
+3. **Network?** Try `curl -sS -o /dev/null -w "%{http_code}\n" https://www.google.com` (or a target endpoint) — agim runs on the operator's host, no proxy by default.
+4. **API key?** Many skills require `ENV` vars (FINNHUB_API_KEY, MX_APIKEY, etc.). The skill summary block shows `(unavailable: ENV: X)` when missing.
+
+## Don't lie about what you are
+
+If the user asks something that depends on a capability you lack — say it directly:
+> 我现在跑在 claude-code，没法直接执行长任务的后台守护。建议用 `/native` 或 `agim` 的 bgjob。
+
+That's more useful than guessing.

package/dist/core/skills/builtin/skill-creator/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: skill-creator
+description: Create or update agim skills (SKILL.md packages). Use when the user says "新建一个 skill" / "把这个流程做成 skill" / "create a skill for X". Walks through frontmatter, body structure, references/scripts, and where to drop the directory.
+always: false
+---
+
+# Skill Creator
+
+A skill in agim is a directory shipped under one of these roots (workspace shadows builtin):
+
+```
+~/.agim/skills/<name>/SKILL.md          # operator-owned (highest priority)
+~/.claude/skills/<name>/SKILL.md         # shared with terminal Claude
+~/.config/opencode/skills/<name>/SKILL.md
+~/.codex/skills/<name>/SKILL.md
+<agim-dist>/core/skills/builtin/<name>/  # packaged with agim
+```
+
+`IMHUB_SKILLS_MODE=auto` (default) merges all of them; `agim-only` restricts to `~/.agim/skills/`.
+
+## Core principles (adapted from Anthropic + nanobot)
+
+1. **Be concise.** The summary block (frontmatter `name` + `description`) is injected into **every** turn. Burn that token budget honestly.
+2. **Trigger phrases in the description.** Write the description so a model can decide whether to load the body without seeing the body. Phrase as "Use when the user asks …".
+3. **Body is read on demand.** Put procedural detail, examples, edge cases, references in the body. The model fetches it via `mcp__imhub__read_skill("<name>")` only when the description matched.
+4. **Match degrees of freedom to the task.** High-freedom text (heuristics) for fuzzy tasks; concrete commands / pseudocode for rigid pipelines.
+5. **No marketing.** A skill is teaching, not selling.
+
+## Minimum SKILL.md template
+
+```markdown
+---
+name: <kebab-case>
+description: <one-paragraph trigger description. Mention concrete user phrases that should activate this skill. End with key constraints.>
+always: false
+metadata:
+  agim:
+    requires:
+      bins: [optional, list, of, cli, binaries]
+      env:  [OPTIONAL_ENV_KEYS]
+---
+
+# <Display Title>
+
+<1-3 line orientation: when to use, what it produces.>
+
+## When to use
+
+- "trigger phrase 1"
+- "trigger phrase 2"
+
+## Steps
+
+1. …
+2. …
+
+## Output rules
+
+- Concise example: …
+- Don't: …
+```
+
+## Frontmatter fields agim respects
+
+| Field | Effect |
+|---|---|
+| `name` | Must match dir name. Used as the lookup key. |
+| `description` | First line shown in skill summary. **Lead with trigger phrases.** |
+| `always: true` | Loads full body into every system prompt. Use only for ≤ 200-line skills that apply to >50% of turns (e.g. self-reference). |
+| `metadata.agim.requires.bins` | Missing → skill shows `(unavailable: CLI: <bin>)` in summary. |
+| `metadata.agim.requires.env` | Same, for env vars. |
+
+## Workflow
+
+1. Decide the **trigger phrases** first; write them down.
+2. Draft frontmatter — name + description + requires.
+3. Sketch the body in ≤ 100 lines. Resist scope creep.
+4. Drop into `~/.agim/skills/<name>/` (workspace). Operator can later promote to builtin via PR.
+5. Restart agim to pick it up (loader caches roots at boot).
+6. Test: ask the user a trigger-phrase question; verify the agent fetched the body via `read_skill`.
+
+## Subdirectories
+
+- `scripts/` — small executable helpers the body references by path
+- `references/` — long-form docs the body cites
+- `assets/` — images, schemas, fixtures
+
+The model reads these via its existing file-read tool when the body references them by path.
+
+## Don't
+
+- Don't put secrets (API keys, prod URLs) into SKILL.md — those go to `~/.agim/env`.
+- Don't write a skill for one-off requests. Skills are amortised cost.
+- Don't duplicate the model's existing knowledge. ("git is a version-control system" wastes tokens.)
+- Don't write multi-paragraph descriptions; that's body material.

package/dist/core/skills/builtin/summarize/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: summarize
+description: Summarize URLs, articles, PDFs, or YouTube videos. Use when the user asks "这篇文章讲什么" / "总结一下 …" / "summarize this link" / "what's this video about". For long content prefer summary over verbatim transcript unless the user explicitly asks for a transcript.
+always: false
+metadata:
+  agim:
+    requires:
+      bins: [curl]
+---
+
+# Summarize
+
+Two paths depending on content type. Pick **path A** for HTML / article / blog; **path B** for YouTube; **path C** for local files.
+
+## Path A — Web page / article
+
+1. Fetch the page (server-rendered HTML usually has the body):
+   ```bash
+   curl -sL -A "Mozilla/5.0" "<url>" | head -c 200000
+   ```
+2. If the page is a SPA (the body has almost no text), try a reader API:
+   - `r.jina.ai/<url>` — strips chrome, returns clean text
+     ```bash
+     curl -s "https://r.jina.ai/<url>"   # url passed verbatim
+     ```
+3. Pipe the cleaned text into your own context and produce a 3-section summary:
+   - **核心结论** (1-2 sentences)
+   - **要点** (3-7 bullets)
+   - **数据/引用** (any concrete numbers, dates, names mentioned)
+
+## Path B — YouTube
+
+The user typically wants a summary, not a transcript. Try transcript route first; fall back gracefully if blocked:
+
+1. Try `r.jina.ai` reader on the watch URL — sometimes returns auto-caption text.
+2. If that fails and `yt-dlp` is installed, pull subtitles:
+   ```bash
+   yt-dlp --skip-download --write-auto-sub --sub-lang zh,en --convert-subs vtt -o "/tmp/yt-%(id)s" "<url>"
+   ```
+3. Read the `.vtt`, strip timestamps, then summarise.
+4. If neither works, tell the user: "字幕拉不到，建议你贴一段文字过来我帮你总结。"
+
+## Path C — Local file
+
+1. Use the model's file-read tool on `*.md`, `*.txt`, `*.html`, `*.json`.
+2. PDFs: prefer a converter on the host (`pdftotext file.pdf -` if installed); otherwise tell the user you can't read PDFs in this environment.
+
+## Output rules
+
+- Default reply ≤ 12 lines unless the user asks for detail.
+- If the source is long (> 50K chars): give summary + offer "需要详细展开哪一段？".
+- Always cite the source URL at the bottom.
+- Never paste base64 / raw HTML / raw VTT to the user.

package/dist/core/skills/builtin/tmux/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: tmux
+description: Remote-control tmux sessions when you need an interactive TTY (REPLs, ncurses tools, ssh sessions with prompts). For long-running NON-interactive work prefer bgjob (`/root/.claude/scripts/bgjob`). Use only when the workflow genuinely needs keystrokes + screen scraping.
+always: false
+metadata:
+  agim:
+    os: [linux, darwin]
+    requires:
+      bins: [tmux]
+---
+
+# tmux
+
+Use tmux **only** when you need an interactive TTY:
+
+- Python / Node REPL with state across calls
+- ncurses (htop, mc, vim) where output requires a terminal emulator
+- ssh sessions that prompt for input
+- Long-running CLIs whose output you'll scrape progressively
+
+For everything else — long compiles, deploys, log tails — prefer agim's bgjob (`/root/.claude/scripts/bgjob start <name> -- <cmd>`). bgjob handles cgroup escape, has `tail`/`status`, persists across restarts.
+
+## Quickstart (isolated socket)
+
+Use a custom socket so tmux state stays scoped to this session and doesn't collide with the operator's own tmux:
+
+```bash
+SOCKET_DIR="${AGIM_TMUX_SOCKET_DIR:-/tmp/agim-tmux-sockets}"
+mkdir -p "$SOCKET_DIR"
+SOCKET="$SOCKET_DIR/agim.sock"
+SESSION="agim-$(date +%s)"
+
+tmux -S "$SOCKET" new -d -s "$SESSION" -n shell
+tmux -S "$SOCKET" send-keys -t "$SESSION":0.0 -- 'PYTHON_BASIC_REPL=1 python3 -q' Enter
+sleep 0.3
+tmux -S "$SOCKET" capture-pane -p -J -t "$SESSION":0.0 -S -200
+```
+
+After spawning, **always print monitor commands** so the user can peek:
+
+```
+要观察会话：
+  tmux -S "$SOCKET" attach -t "$SESSION"
+  tmux -S "$SOCKET" capture-pane -p -J -t "$SESSION":0.0 -S -200
+```
+
+## Common patterns
+
+Send a command + wait for prompt:
+```bash
+tmux -S "$SOCKET" send-keys -t "$SESSION":0.0 -- 'curl -sS https://example.com' Enter
+sleep 1
+tmux -S "$SOCKET" capture-pane -p -J -t "$SESSION":0.0 -S -100
+```
+
+Drain output until a known sentinel appears (poll, max 30s):
+```bash
+for i in $(seq 1 30); do
+  if tmux -S "$SOCKET" capture-pane -p -J -t "$SESSION":0.0 -S -50 | grep -q "READY"; then
+    break
+  fi
+  sleep 1
+done
+```
+
+Send Ctrl-C / Ctrl-D:
+```bash
+tmux -S "$SOCKET" send-keys -t "$SESSION":0.0 C-c
+tmux -S "$SOCKET" send-keys -t "$SESSION":0.0 C-d
+```
+
+Kill the session when done:
+```bash
+tmux -S "$SOCKET" kill-session -t "$SESSION"
+```
+
+## Hygiene
+
+- One session per task; name with a timestamp so multiple agents don't collide.
+- Kill sessions when work is finished — orphan sessions sit there forever.
+- Don't run long compute under tmux. The session will outlive your agim turn and you can't reattach next turn from a different process.
+- Don't paste secrets into a tmux session — they end up in scrollback.

package/dist/core/skills/builtin/weather/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: weather
+description: Get current weather and short forecasts. No API key required (wttr.in + Open-Meteo). Use when the user asks for weather, temperature, rain forecast, or a city's conditions.
+always: false
+metadata:
+  agim:
+    requires:
+      bins: [curl]
+---
+
+# Weather
+
+Two zero-key services. Default to `wttr.in` (compact); fall back to Open-Meteo when the user wants structured JSON or a multi-day forecast in a specific unit.
+
+## wttr.in (primary)
+
+One-liner:
+```bash
+curl -s "wttr.in/Shanghai?format=3"
+# Shanghai: ⛅️ +18°C
+```
+
+Compact custom format:
+```bash
+curl -s "wttr.in/Shanghai?format=%l:+%c+%t+%h+%w"
+# Shanghai: ⛅️ +18°C 67% ↘8km/h
+```
+
+Today's forecast only (~10 lines):
+```bash
+curl -s "wttr.in/Shanghai?T&1"
+```
+
+Format codes: `%l` location · `%c` condition emoji · `%t` temp · `%h` humidity · `%w` wind · `%m` moon phase
+
+Notes:
+- URL-encode spaces: `wttr.in/New+York`
+- Airport codes also work: `wttr.in/PEK`
+- Units: append `?m` (metric default) or `?u` (USCS)
+- Set User-Agent for ANSI-free text: `curl -s -A "curl" "wttr.in/Tokyo?format=3"`
+
+## Open-Meteo (fallback, JSON)
+
+Use when the user wants a multi-day forecast or you need structured fields:
+```bash
+curl -sG "https://api.open-meteo.com/v1/forecast" \
+  --data-urlencode "latitude=31.23" \
+  --data-urlencode "longitude=121.47" \
+  --data-urlencode "current=temperature_2m,relative_humidity_2m,wind_speed_10m" \
+  --data-urlencode "daily=temperature_2m_max,temperature_2m_min,precipitation_probability_max" \
+  --data-urlencode "timezone=auto"
+```
+
+Geocode a city name first if you only have a name:
+```bash
+curl -sG "https://geocoding-api.open-meteo.com/v1/search" \
+  --data-urlencode "name=上海" --data-urlencode "count=1"
+```
+
+## Output rules
+
+- Quote temperature + condition first, then 1 line of extra context (wind, humidity, rain chance).
+- For multi-day, give the next 3 days in a 1-line table:
+  `周一 ⛅️ 12-19° · 周二 🌧 9-15° · 周三 ☀️ 14-22°`
+- Never paste raw JSON to the user.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agim-cli",
-  "version": "1.2.56",
+  "version": "1.2.57",
   "description": "Agim (阿吉姆) — universal messenger-to-agent bridge. Connect WeChat / Feishu / DingTalk / Email to Claude Code / Codex / OpenCode, or any custom agent via ACP. Installs the `agim` command.",
   "type": "module",
   "bin": {