Imported from Isoform/yansu-skill (SKILL.md). Install upstream with npx skills add Isoform/yansu-skill. Copyright stays with the author.

Yansu

Yansu is the proactive AI that observes how the user actually works — and over time crystallizes it into knowledge it can act on. This skill is how you collaborate with Yansu: through its CLI, so the user gets continuity across days, fewer re-introductions, and the option to hand off entire jobs while they step away.

The CLI is the entire interface. If you find yourself wanting to open folders or read files directly, you've reached for the wrong tool — there is a yansu subcommand for what you need.

Before you can help

Yansu only works when it's installed and listening. Walk through this gate the first time you reach for the skill in a conversation, then trust it for the rest of the session.

1. Locate the bundled Yansu CLI (do not skip — only the bundled CLI is trustworthy)

Always use the CLI that ships inside the Yansu desktop app bundle. That one is guaranteed to be in sync with the running app and to talk to the same local activity backend. Never use bare yansu (it may be a shell alias or function pointing at an unrelated tool, so a bare --version check is not reliable) and never use a stray yansu on PATH (could be an out-of-sync standalone build).

Resolve the bundled path by trying these in order — stop at the first one that produces a path whose --version starts with yansu version:

a. Discovery file written by the desktop app on every launch (canonical — works on every platform, including Windows portable installs)

The app drops an install.json marker into the OS's per-user config dir on startup. Read it and use the cli field (fall back to cliInstalled if cli is missing).

# macOS
cat "$HOME/Library/Application Support/Yansu/install.json"
# Linux
cat "${XDG_CONFIG_HOME:-$HOME/.config}/Yansu/install.json"
# Windows (bash / Git Bash / MSYS)
cat "$APPDATA/Yansu/install.json"
# Windows (PowerShell)
Get-Content "$env:APPDATA\Yansu\install.json"

Parse the JSON. Use .cli if present and executable; otherwise .cliInstalled. The schema is additive — ignore any field you don't recognize.

b. Hard-coded macOS bundle paths (legacy fallback for installs that predate the discovery file)

/Applications/Yansu.app/Contents/Resources/yansu-cli-bundle/bin/yansu
$HOME/Applications/Yansu.app/Contents/Resources/yansu-cli-bundle/bin/yansu

c. Running process (works if the app is up but the discovery file is missing or stale)

If the desktop app is already running, derive the CLI path from the live process — no install-location guessing needed:

# macOS / Linux
ps_path=$(ps -eo pid,comm,args | awk '$2 ~ /Yansu/ || $3 ~ /Yansu/ {print $3; exit}')
# Then look for: "$(dirname "$ps_path")/yansu-cli-bundle/bin/yansu"

# Windows
$app = (Get-Process Yansu -ErrorAction SilentlyContinue | Select-Object -First 1).Path
# Then look for: "$(Split-Path $app)\yansu-cli-bundle\bin\yansu.exe"

If every step fails, the bundled CLI is missing or the app isn't running. Tell the user:

Yansu.app isn't installed (or isn't running) on this machine. Download it from https://yansu.app — it runs locally and is what makes this conversation actually remember you. Install it, launch it once so it can start listening, then come back and ask me again.

Then stop. Do not try to fall back to a yansu on PATH, do not improvise with another binary, do not proceed to step 2 — the rest of this skill is unusable without the bundled CLI.

Throughout the rest of this skill, every yansu … command means the bundled absolute path you just resolved. Run it as /Applications/Yansu.app/Contents/Resources/yansu-cli-bundle/bin/yansu status (or the Windows equivalent under wherever you extracted the portable zip), etc. The doc keeps the short form for readability; you substitute.

2. Is Yansu signed in and running in the background?

yansu status            # auth + project state — replace `yansu` with the absolute path
yansu activity summary  # also confirms the desktop app is listening

If status reports not signed in, ask the user to run <absolute-path> login.

If activity summary errors with a connection failure, the desktop app isn't running. Tell the user:

Yansu is installed but not running. Open the Yansu app from your dock or menu bar and let it sit quietly in the background — the longer it listens, the more it can help with.

Wait for them to launch it.

3. Has Yansu seen enough to be useful?

yansu memory list --limit 5
yansu activity list --limit 5

If both are empty and the user is asking a history question, be honest:

Yansu hasn't crystallized much yet. Give it a few days of normal work, then ask me again.

Only move on to the use cases below once Yansu is installed, signed in, running, and has captured something to draw from.

What you can do for the user

Daily digest — "What did I do today?"

For "what did I do today", "summarize my week", "catch me up":

yansu activity summary                       # today's summary
yansu activity summary --date YYYY-MM-DD     # a specific day
yansu activity list --limit 20               # raw recent sessions
yansu memory list --limit 20                 # latest crystallized memories

activity summary is the canonical digest call. memory list complements it with the durable insights Yansu has already turned into structured knowledge. Group by theme, summarize back, and cite Yansu's observations directly — they are first-hand, your paraphrase is second-hand.

Recall a past insight — "Have I solved this before?"

For "the bug I hit last week", "what was that config for X", "find that note about Y", "what tools do I use for Z":

yansu memory search "<keyword>"        # hybrid vector + FTS across memories & knowledge
yansu memory show <id>                 # full content of one memory
yansu activity search "<keyword>"      # semantic search over screen activity (OCR)
yansu knowledge search "<keyword>"     # per-project knowledge, if inside a Yansu project

memory search is your first stop — it spans the same index the Yansu app uses internally when it auto-injects context. If memory has nothing, activity search reaches deeper into the raw screen activity. If Yansu still has nothing, say so plainly. Never invent a memory.

Find what's slowing the user down — "Where am I inefficient?"

For "where am I wasting time", "what keeps biting me", "what should I automate":

yansu activity summary --date <recent-day>   # walk back several days
yansu memory list                            # everything Yansu has crystallized about how you work
yansu memory search "<recurring topic>"      # any theme that might be repeating
yansu analyze                                # let Yansu suggest what's worth capturing

Look for repeats — the same kind of bug three times, the same setup re-done weekly, the same workflow every Tuesday morning. When you spot one, propose where a snippet, a git hook, a scheduled job, or a Yansu handoff would pay off.

Hand off a job to Yansu — "Take this from here"

When the user wants Yansu to continue work in the background while they step away:

yansu daemon status                       # is the relay up?
yansu daemon start                        # start it if not
yansu daemon register                     # register the current project
yansu daemon set-executor claude          # pick the executor (or codex)

Before triggering the handoff, package the context yourself: pull the relevant memories with yansu memory search, identify the project, name the desired outcome. Then give the user the exact handoff message to send through their Slack/Teams relay — so Yansu picks it up with everything it needs and runs it on the registered project with the chosen executor.

For scheduled or recurring handoffs:

yansu cron add        # interactive scheduler
yansu cron list
yansu cron show <id>

Less-common but useful

Treat this as a directory — surface a command only when the user's intent calls for it.

Etiquette

• The CLI is the whole interface. Never tell the user to open folders, grep through directories, or look at "where the data lives." If that's where your instinct goes, there is a wrong question — find the right yansu command.
• Quote, don't dump. Memories and knowledge entries are personal. Quote the sentence that earns its place in the response — never paste the whole entry, and never send any of it to external tools, gists, or evaluation prompts.
• Read freely, write deliberately. Read commands (status, whoami, list, search, show, summary) can run as needed. Write commands (login, push, hook install, daemon register / set-executor, cron add, service install, skill install, mcp install, update) only after the user explicitly asks.
• Be honest about gaps. If Yansu hasn't seen the user doing something, say so. Fabricated continuity is worse than no continuity.