@qvac/skills 0.0.0 → 0.1.0

package/skills/music-generation/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: music-generation
+description: Create original music from an idea, mood, scene, or lyrics. Make complete tracks, with instrumentals, vocals and variations in any music style.
+tools: [generate_music]
+platform: [darwin, linux, win32]
+---
+
+# Music generation
+
+Call `generate_music` when the user asks for a song, track, beat, melody,
+jingle, background music, or any generated audio. The result is saved as a chat
+attachment and played to the user automatically — never describe waveforms,
+paste data, or apologize about being text-only; just confirm what you generated.
+Match your description to the tool result's `instrumental` flag: never tell the
+user a track has vocals when it came back instrumental.
+
+```json
+{
+  "prompt": "lo-fi hip hop, mellow piano, soft drums, warm bass",
+  "title": "midnight study session"
+}
+```
+
+## Instrumental or sung
+
+Vocals come from the `lyrics` argument. It is the only switch that makes the
+model sing: a voice cue in the `prompt` (e.g. "male vocals") only sets the voice
+timbre, and with no `lyrics` the track is always instrumental, whatever the
+prompt says.
+
+- **Instrumental, background music, or a beat with no singing**: omit `lyrics`
+  entirely. That produces an instrumental (the model's default).
+- **A song with singing, vocals, or words**: you must pass `lyrics`, structured
+  with `[verse]` / `[chorus]` tags. Name who sings with a tag in the `prompt`
+  (`male vocal`, `female vocal`, or for a duet `male and female duet, harmonized
+  vocals`) to set the voice, and set `vocalLanguage` when the user names a
+  language.
+- **The user wants singing but gave no words**: write short `[verse]` /
+  `[chorus]` lyrics yourself from their topic and pass them as `lyrics`. Never
+  leave `lyrics` empty for a sung request, or the track comes out instrumental.
+
+Set `duration` when the user asks for a specific length ("30 seconds", "a
+two-minute track"); otherwise leave it unset and let the model choose.
+
+## Parameters
+
+- `prompt` (required) - describe the genre, instruments, mood, and vocal
+  arrangement in plain language. It is the caption ACE-Step reads for the sound
+  and the voice timbre, so name who sings here; the singing itself still needs
+  `lyrics` (see "Instrumental or sung").
+- `title` — a short, descriptive song title (2 to 5 words) used to name the
+  saved audio file. Set it whenever you generate a track so the download has a
+  human-readable name; keep it plain and omit any file extension. Without it the
+  file falls back to a slug of the `prompt`.
+- `lyrics` - the sung words, and the switch that turns vocals on. Omit for an
+  instrumental (the default). Structure them with `[verse]` / `[chorus]` tags. A
+  voice cue in the `prompt` alone does not sing; vocals need `lyrics` here.
+- `vocalLanguage` — the language the vocals are sung in, as a short code
+  (`en`, `es`, `de`, `it`, …). Set it when the user names a language; it only
+  applies with lyrics and defaults to English.
+- `duration` — approximate length in seconds. Leave unset to let the model
+  choose; set it only when the user asks for a specific length. The model rounds
+  to its own frame grid, so the clip may be slightly shorter or longer.
+- `seed` — set only when the user wants a reproducible or slightly varied retry
+  of a previous result; `-1` or omitted is random.
+- `bpm` — tempo in beats per minute; set it when the user names a tempo.
+- `keyscale` — musical key and scale (e.g. `C minor`, `A major`), when named.
+- `timesignature` — meter (e.g. `4/4`, `3/4`), when the user names one.
+
+## Notes
+
+- Generation takes a while; the result arrives as an attachment in this turn.
+- One generation at a time — if the tool reports it is busy, wait and retry
+  instead of stacking calls.
+- The first use downloads several gigabytes of model weights; that happens once,
+  before the first track is produced.

package/skills/notion/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: notion
+description: Notion pages, databases, and blocks — search, read, create, update, and comment via the official Notion MCP server.
+tools: [mcp_call, notion_create_page, notion_insert_content]
+platform: [darwin, linux, win32, ios, android]
+credentials: [notion_mcp_access_token]
+allow_list: [https://mcp.notion.com/mcp]
+mcp_reads:
+  [
+    notion-search,
+    notion-fetch,
+    notion-get-comments,
+    notion-get-teams,
+    notion-get-users,
+    notion-get-async-task,
+    notion-query-data-sources
+  ]
+---
+
+# Notion
+
+Two typed tools cover the most common writes and are called directly, like `skill`: `notion_create_page` creates a page and `notion_insert_content` adds text to one. Everything else is one `mcp_call` against `https://mcp.notion.com/mcp` with the **tool name as `method`** and its **args as `params`** — the JSON-RPC envelope, session handshake, and bearer token are handled for you. Do **not** build a `{name, arguments}` envelope, pass a `sessionId`, or call `initialize`/`notifications/initialized`/`tools/list`.
+
+```json
+{
+  "url": "https://mcp.notion.com/mcp",
+  "method": "notion-search",
+  "params": { "query": "Q4 roadmap", "page_size": 5 }
+}
+```
+
+Rules that hold for every call:
+
+- `params` is a JSON object, never a string.
+- Page, database, and view ids come from a URL the user gave or from a previous result — never invented.
+- A page title is always a plain string: `"properties": { "title": "The title" }` when creating several pages or renaming one.
+- Deleting or archiving a page is not possible through this connection — say so instead of improvising (details in `references/pages.md`).
+- A `401` status means Notion isn't connected — tell the user to connect "Notion" from the skill's setup; do not drive OAuth yourself. An "object not found" / no-access error means the connection can't see that object — tell the user to share the page or database with the Notion connection.
+
+## Finding pages
+
+There is no "list all" — `notion-search` is the entry point and `query` is required (min length 1). For a broad overview pass a keyword from the request, and always bound results with a small `page_size`. Each result carries `title`, `url`, and `id`. Results are ranked by semantic similarity, not by title — when one result's title matches the requested name (case-insensitive), take that one even if it isn't first. When the user named a specific page and no title matches, list the candidates as `[title](url)` and ask instead of guessing. Search once per request; do not re-run it with variations.
+
+`notion-search` knows nothing about the connected identity — for "who am I" / "which workspace" call `notion-fetch` with `id: "self"` (see `references/pages.md`).
+
+## Load the Recipe File First
+
+This file carries no other calls. The tool tables and working calls live in four reference files — load the one for the job with the `skill` tool BEFORE calling a Notion tool, then copy its call and change only the values. Each load is a real `skill` tool call — printing the call as JSON or text in your reply loads nothing.
+
+- **Pages** — read or summarize a page, "who am I / which workspace", create a page, add / change / replace text, rename or set a property, delete / archive (and why it cannot), move, duplicate: call the `skill` tool with `name: "notion"` and `file: "references/pages.md"`.
+- **Databases, data sources and views** — create a database, add a row, read a database's schema, query or filter rows, create or change a view: call the `skill` tool with `name: "notion"` and `file: "references/databases.md"`.
+- **Comments** (also people and teamspaces) — read or add a comment, list workspace members, look up a user, list teamspaces: call the `skill` tool with `name: "notion"` and `file: "references/comments.md"`.
+- **Async tasks** — a result carried a `task_id`, or the user asks whether a duplicate / large write finished: call the `skill` tool with `name: "notion"` and `file: "references/tasks.md"`.
+
+Never write a call from memory. Each tool's arguments have one exact shape (`command` + its single companion field, `data.mode` + its fields) and the server rejects anything else; loading the file is one cheap read-only call. After the file is loaded, your next output is the tool call — no further loads.
+
+## Output
+
+- Show page titles and IDs together. When a result carries a `url`, render the title as a Markdown link — `[title](url)` — never bare or in backticks, or it won't be clickable.
+- For query results, lead with counts/rollups if present, then rows — don't dump the raw structured response. Surface user-visible property names, not IDs.
+- If a query tool responds with an upgrade prompt, tell the user their plan doesn't support it (single-source needs Business+Notion AI, multi-source needs Enterprise+Notion AI) — don't retry.

package/skills/notion/operations.json

@@ -0,0 +1,53 @@
+{
+  "operations": [
+    {
+      "tool": "notion_create_page",
+      "description": "Create one Notion page with a title and optional Markdown body, under a parent page or database. One user request means one call; never recreate a page to make sure it landed.",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "title": { "type": "string", "description": "Exact title from the user" },
+          "content": {
+            "type": "string",
+            "description": "Page body in Notion-flavored Markdown; do not repeat the title"
+          },
+          "parentPageId": { "type": "string", "description": "Parent page id or URL" },
+          "parentDatabaseId": {
+            "type": "string",
+            "description": "Parent database id or URL, for a database row"
+          }
+        },
+        "required": ["title"]
+      },
+      "request": {
+        "transport": "mcp",
+        "method": "notion-create-pages",
+        "url": "https://mcp.notion.com/mcp",
+        "builder": "notion-create-page"
+      }
+    },
+    {
+      "tool": "notion_insert_content",
+      "description": "Add Markdown text to an existing Notion page, at the end by default or at the start. For changing text that is already there use notion-update-page with update_content via mcp_call.",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "pageId": { "type": "string", "description": "Page id or URL" },
+          "content": { "type": "string", "description": "Markdown to add" },
+          "position": {
+            "type": "string",
+            "enum": ["start", "end"],
+            "description": "Defaults to end"
+          }
+        },
+        "required": ["pageId", "content"]
+      },
+      "request": {
+        "transport": "mcp",
+        "method": "notion-update-page",
+        "url": "https://mcp.notion.com/mcp",
+        "builder": "notion-insert-content"
+      }
+    }
+  ]
+}

package/skills/notion/references/comments.md

@@ -0,0 +1,65 @@
+# Notion Comments, People and Teamspaces
+
+Every call is one `mcp_call` with `url: "https://mcp.notion.com/mcp"`, the tool name as `method`, and its args as `params` (a JSON object, never a string). Call these tools directly — no `tools/list`.
+
+| tool                    | required args                 | use for                                     |
+| ----------------------- | ----------------------------- | ------------------------------------------- |
+| `notion-get-comments`   | `page_id`                     | read a page's comments and discussions      |
+| `notion-create-comment` | `page_id`, `rich_text`        | comment on a page                           |
+| `notion-get-users`      | — (optional `id` or `"self"`) | list workspace members, or look up one user |
+| `notion-get-teams`      | —                             | list teamspaces                             |
+
+## Reading comments
+
+```json
+{
+  "url": "https://mcp.notion.com/mcp",
+  "method": "notion-get-comments",
+  "params": { "page_id": "<page id or URL>" }
+}
+```
+
+The result includes block-level and resolved threads. Report each comment with its author and text; a read-only question ends after the read.
+
+## Adding a comment
+
+The comment text goes in `rich_text` as one text object:
+
+```json
+{
+  "url": "https://mcp.notion.com/mcp",
+  "method": "notion-create-comment",
+  "params": {
+    "page_id": "<page id or URL>",
+    "rich_text": [{ "text": { "content": "The comment" } }]
+  }
+}
+```
+
+One user request → one comment. After the result, say the comment was added and link the page.
+
+## People
+
+`notion-get-users` with `params: {}` lists workspace members and guests (id, name, email, type). Pass `"id": "self"` for the connected user, or a user id to look one up:
+
+```json
+{ "url": "https://mcp.notion.com/mcp", "method": "notion-get-users", "params": {} }
+```
+
+For "who am I / which workspace" prefer `notion-fetch` with `"id": "self"` (see `references/pages.md`) — it also names the workspace.
+
+## Teamspaces
+
+```json
+{ "url": "https://mcp.notion.com/mcp", "method": "notion-get-teams", "params": {} }
+```
+
+Lists the teamspaces and whether the connected user is a member of each.
+
+## Output
+
+Show people by name (and email when present), pages as `[title](url)` links. Never invent a user id — take it from `notion-get-users`.
+
+## Now act
+
+Your next output is the tool call (or, after the result, the reply) — no further skill loads.

package/skills/notion/references/databases.md

@@ -0,0 +1,68 @@
+# Notion Databases, Data Sources and Views
+
+A database holds one or more **data sources** (the typed schema behind it) and **views** over them. Every call is one `mcp_call` with `url: "https://mcp.notion.com/mcp"`, the tool name as `method`, and its args as `params` (a JSON object, never a string). Call these tools directly — no `tools/list`.
+
+| tool                        | required args                            | use for                                                                  |
+| --------------------------- | ---------------------------------------- | ------------------------------------------------------------------------ |
+| `notion-fetch`              | `id` (database / data-source / view URL) | read the schema, the `collection://` data-source URLs, and the view URLs |
+| `notion-query-data-sources` | `data` (`mode` + its fields)             | run a database view, or query rows by SQL                                |
+| `notion_create_page`        | `title`, `parentDatabaseId`              | add one row to a database (typed tool — no `params`)                     |
+| `notion-create-database`    | properties for the new database          | create a database + its initial data source + view                       |
+| `notion-update-data-source` | `data_source_id` + fields                | rename a data source or edit its properties                              |
+| `notion-create-view`        | `data_source_id`, `name`, `type`         | add a table / board / list / calendar / timeline / gallery view          |
+| `notion-update-view`        | `view_id` + fields                       | edit a view's name, filters, sorts, or display                           |
+
+## Reading a database
+
+Fetch the database first: the result carries the schema, each data source's `collection://<id>` URL (used as the SQL table name), and each view's URL (the one carrying `?v=<view-id>`).
+
+```json
+{
+  "url": "https://mcp.notion.com/mcp",
+  "method": "notion-fetch",
+  "params": { "id": "<database id or URL>" }
+}
+```
+
+## Querying rows
+
+`notion-query-data-sources` nests every argument under `data`, and the two modes take different fields — send the wrong one and the server rejects the call:
+
+| `mode`          | carries                      | for                                         |
+| --------------- | ---------------------------- | ------------------------------------------- |
+| `view`          | `view_url`                   | run a database view's own filters and sorts |
+| `sql` (default) | `data_source_urls` + `query` | filter, group or aggregate rows yourself    |
+
+View mode works on every plan, so start there:
+
+```json
+{
+  "url": "https://mcp.notion.com/mcp",
+  "method": "notion-query-data-sources",
+  "params": { "data": { "mode": "view", "view_url": "<database url including ?v=>" } }
+}
+```
+
+SQL mode is plan-gated: `data_source_urls` lists the `collection://` URLs and `query` is SQLite using them as table names. If the response is an upgrade prompt, tell the user their plan doesn't support it (single-source needs Business+Notion AI, multi-source needs Enterprise+Notion AI) — don't retry.
+
+## Adding a row
+
+A row is a page whose parent is the database. Use `notion_create_page` with `parentDatabaseId`; the `title` fills the title property and `content` becomes the row's page body:
+
+```json
+{ "title": "Row title", "content": "Optional body", "parentDatabaseId": "<database id or URL>" }
+```
+
+Set other properties afterwards with `notion-update-page` → `update_properties` (see `references/pages.md`).
+
+## Creating and changing structure
+
+`notion-create-database` creates the database with its first data source and view; `notion-update-data-source` renames a data source or changes its properties; `notion-create-view` / `notion-update-view` manage views. Take the `data_source_id` and `view_id` from a `notion-fetch` of the database — never guess them. If the server rejects the call, quote its message and ask the user how to proceed instead of retrying with invented fields.
+
+## Output
+
+Lead with counts and rollups when present, then rows; surface user-visible property names, not IDs. Show the database as a `[title](url)` link.
+
+## Now act
+
+Your next output is the tool call (or, after the result, the reply) — no further skill loads.

package/skills/notion/references/pages.md

@@ -0,0 +1,119 @@
+# Notion Pages
+
+Create with `notion_create_page`, add text with `notion_insert_content`; every other call is one `mcp_call` with `url: "https://mcp.notion.com/mcp"`, the tool name as `method`, and its args as `params` (a JSON object, never a string). Call these tools directly — no `tools/list`.
+
+| tool                    | required args                                   | use for                                                                         |
+| ----------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------- |
+| `notion-fetch`          | `id` (page URL or ID, or `"self"`)              | read a page's properties + content, or the connection identity                  |
+| `notion_create_page`    | `title`; optional `content`, `parentPageId`     | create one page (typed tool — no `params`)                                      |
+| `notion-create-pages`   | `pages`                                         | create several pages in one request; `allow_async: true` for very large content |
+| `notion_insert_content` | `pageId`, `content`; optional `position`        | add text to a page (typed tool — no `params`)                                   |
+| `notion-update-page`    | `page_id`, `command`, + its one companion field | change text, rename, set a property, icon, cover                                |
+| `notion-move-pages`     | `page_or_database_ids`, `new_parent`            | reparent pages or databases                                                     |
+| `notion-duplicate-page` | `page_id`                                       | duplicate a page — always async, poll the returned task (`references/tasks.md`) |
+
+Comments are not a page command: to read or add a comment, load `references/comments.md` and use `notion-create-comment` / `notion-get-comments`.
+
+## Reading a page
+
+`notion-fetch` returns the page's properties and its content as Markdown. Always name the page you read (title + link) when reporting its content. A read-only question ends after the read — never follow it with a write.
+
+```json
+{
+  "url": "https://mcp.notion.com/mcp",
+  "method": "notion-fetch",
+  "params": { "id": "<page id or URL>" }
+}
+```
+
+For "who am I" / "which workspace", the same call with `"id": "self"` is the fixed one-call answer — never loop on search for it.
+
+## Creating a page
+
+One user request → one create. `notion_create_page` is a tool of its own, listed beside `mcp_call` — call it directly with these arguments (it is not a `method` for `mcp_call`, and it takes no `url` or `params`):
+
+```json
+{ "title": "Exact title from the user", "content": "The page body" }
+```
+
+`title` is the exact title from the user; `content` is optional Markdown (do not repeat the title in the body). For a private standalone page send only those two fields — no parent field at all. Add `"parentPageId": "<page id or URL>"` only when the user named a parent page, or `"parentDatabaseId"` for a database row.
+
+Use `notion-create-pages` through `mcp_call` only when one request asks for several pages. Each entry uses `properties.title` — a plain string — plus optional `content`; leave `parent` out for standalone pages and add `"parent": { "page_id": "<id>" }` beside `pages` only when the user named one:
+
+```json
+{
+  "url": "https://mcp.notion.com/mcp",
+  "method": "notion-create-pages",
+  "params": {
+    "pages": [
+      { "properties": { "title": "First title" }, "content": "First body" },
+      { "properties": { "title": "Second title" }, "content": "Second body" }
+    ]
+  }
+}
+```
+
+One user request → one `notion-create-pages` write unless they asked for several pages in that request. Never recreate a page to "make sure", to fill an empty wrap-up, or because a previous call timed out. After a confirmed create, show the title as a Markdown link from the result `url` and keep the result `id` for follow-up edits. To verify, `notion-search` / `notion-fetch` — do not write again. If create times out or returns an uncertain result: search for the **exact title**, then fetch any title match. Only create again if no exact-title page exists.
+
+## Adding text
+
+`notion_insert_content` is also a tool of its own — call it directly. It appends by default; `"position": "start"` prepends. It sends `"command": "insert_content"` to `notion-update-page` for you, so never call that command through `mcp_call`.
+
+```json
+{ "pageId": "<page id or URL>", "content": "The line to add" }
+```
+
+## Changing a page
+
+`notion-update-page` always takes `page_id` and `command`. Each command carries **its own one extra field** — send a different one and the server rejects the call, so pick the row before writing:
+
+| `command`             | carries               | for                                  |
+| --------------------- | --------------------- | ------------------------------------ |
+| `update_content`      | `content_updates`     | change part of the body              |
+| `replace_content`     | `new_str`             | overwrite the whole body             |
+| `update_properties`   | `properties`          | title, status, any database property |
+| `apply_template`      | `template_id`         | apply a database template            |
+| `update_verification` | `verification_status` | mark a page verified                 |
+
+Rename = `update_properties` with the new title as a plain string:
+
+```json
+{
+  "url": "https://mcp.notion.com/mcp",
+  "method": "notion-update-page",
+  "params": {
+    "page_id": "<page id or URL>",
+    "command": "update_properties",
+    "properties": { "title": "New title" }
+  }
+}
+```
+
+Reserve `update_content` for changing text that is already there: its `content_updates` is an array of `{ "old_str", "new_str" }` pairs, `old_str` must match the page exactly, so `notion-fetch` first. `update_content` has no top-level `new_str`. `new_str` is a Markdown string, never an array. Icon and cover can be set alongside any command.
+
+## Archiving (deleting) a page
+
+This connection cannot move a page to Trash: `notion-update-page` rejects `in_trash`, and there is no delete tool. When the user asks to delete, remove or archive a page, make no tool call — reply that the page has to be deleted in Notion itself (open the page, `•••` menu, **Move to Trash**) and link it. Never empty the page, overwrite its body, rename it or move it as a substitute for deleting it.
+
+## Moving and duplicating
+
+```json
+{
+  "url": "https://mcp.notion.com/mcp",
+  "method": "notion-move-pages",
+  "params": {
+    "page_or_database_ids": ["<page id>"],
+    "new_parent": { "page_id": "<new parent id>" }
+  }
+}
+```
+
+`new_parent` is `{ "page_id": … }`, `{ "database_id": … }`, or `{ "data_source_id": … }`. `notion-duplicate-page` takes `page_id` and returns a `task_id`, not the copy — load `references/tasks.md` to poll it before telling the user it is done.
+
+## Output
+
+After a write, show the page as a `[title](url)` link and say what changed. After a read, report the content under the page's title and link.
+
+## Now act
+
+Your next output is the tool call (or, after the result, the reply) — no further skill loads.

package/skills/notion/references/tasks.md

@@ -0,0 +1,28 @@
+# Notion Async Tasks
+
+Some writes do not finish inside the call. The response then carries a `task_id`, not the final result — poll it, and don't tell the user it's done until the status is `succeeded`. Every call is one `mcp_call` with `url: "https://mcp.notion.com/mcp"`, the tool name as `method`, and its args as `params` (a JSON object, never a string).
+
+| tool                    | required args | use for                         |
+| ----------------------- | ------------- | ------------------------------- |
+| `notion-get-async-task` | `task_id`     | poll an async operation's state |
+
+Which calls go async:
+
+- `notion-duplicate-page` — always.
+- `notion-create-pages` and `notion-update-page` — when sent with `"allow_async": true` (use it only for very large content).
+
+## Polling
+
+```json
+{
+  "url": "https://mcp.notion.com/mcp",
+  "method": "notion-get-async-task",
+  "params": { "task_id": "<task_id from the prior response>" }
+}
+```
+
+Status is `queued`, `running`, `retrying`, `succeeded`, or `failed`. Respect the suggested backoff in the response before polling again; poll at most a few times, then tell the user it is still running and how to check later. On `succeeded`, report the result it carries (for a duplicate, the new page's title as a `[title](url)` link). On `failed`, quote the error and stop — do not retry the original write.
+
+## Now act
+
+Your next output is the tool call (or, after the result, the reply) — no further skill loads.

package/skills/obsidian/SKILL.md

@@ -0,0 +1,122 @@
+---
+name: obsidian
+description: Manage local Obsidian vault notes through the registered Obsidian CLI. Search, read, create, append, rename, move, inspect backlinks, list tasks, and work with daily notes.
+tools: [exec(obsidian)]
+platform: [darwin, linux, win32]
+metadata:
+  {
+    "openclaw":
+      {
+        "requires":
+          {
+            "bins": ["obsidian"],
+            "binMinVersions": { "obsidian": { "min": "1.12.7", "command": "obsidian version" } }
+          },
+        "setup":
+          {
+            "summary": "Obsidian works through the official Obsidian CLI connected to the running desktop app. You can instead select a vault folder for direct Markdown file access; app-only actions need the CLI. Workbench opens Obsidian on demand when using the CLI.",
+            "routes":
+              [
+                {
+                  "kind": "instructions",
+                  "label": "Register the Obsidian CLI",
+                  "description": "Requires Obsidian 1.12.7 or newer with the command line interface registered. Keep the app installed; Workbench opens it on demand.",
+                  "helpUrl": "https://help.obsidian.md/cli",
+                  "steps":
+                    [
+                      "Open the Obsidian desktop app and update it to 1.12.7 or newer.",
+                      "Go to Settings → General → Advanced and enable Command line interface.",
+                      "Click Register CLI to add it to your PATH.",
+                      "Reopen this Skills page."
+                    ]
+                },
+                {
+                  "kind": "picker",
+                  "label": "Select vault folder",
+                  "provider": "obsidian",
+                  "description": "Choose a folder that contains a .obsidian config directory. Switches to vault file mode (no running app required).",
+                  "credentialKey": "obsidian_vault_path"
+                }
+              ]
+          }
+      }
+  }
+---
+
+# Obsidian
+
+Work with a local Obsidian vault through the `obsidian` CLI. The CLI is a local
+controller for the running Obsidian desktop app and can search, read, create,
+append, rename, move, open, and manage notes inside known vaults.
+
+## Load the Recipe File First
+
+This file carries no commands. The working commands live in two reference files
+— load the one for the job with the `skill` tool BEFORE calling `exec`, then
+copy its command and change only the arguments:
+
+Each load is a real `skill` tool call — printing the call as JSON or text in
+your reply loads nothing.
+
+- **Finding and reading notes** — "what are my notes", "list notes in X",
+  "find / search notes about X", "read / open / summarize note X", "what's in
+  my daily note", "list my tags", backlinks, tasks: call the `skill` tool with
+  `name: "obsidian"` and `file: "references/read.md"`.
+- **Changing notes** — "create a note", "add to note X", "prepend", "add to
+  my daily note", rename, move, delete: call the `skill` tool with
+  `name: "obsidian"` and `file: "references/write.md"`.
+
+Most requests are ONE command. Run that single command, then answer from its
+output. Do NOT run `obsidian vault info` first unless the vault is ambiguous.
+
+## Always Use the obsidian CLI — Never Shell Out
+
+The vault is managed by Obsidian. ALWAYS read, list, search, and edit notes with
+`obsidian` commands via the `exec` tool. NEVER use `cat`, `ls`, `find`, `grep`,
+`head`, `tail`, `echo`, output redirection, or filesystem paths under the vault
+directory — those bypass Obsidian and are wrong even when they appear to work.
+If an `obsidian` command fails, correct its arguments and retry the `obsidian`
+command; do not switch to shell or file tools. Use `exec` only, one `obsidian`
+command per call. Do not chain with `&&`, `;`, or pipes.
+
+## When to Use
+
+- The user asks to search, read, summarize, create, append, rename, move, or
+  delete notes in Obsidian.
+- The user asks about daily notes, tags, backlinks, aliases, properties, tasks,
+  templates, bookmarks, or vault structure.
+- The user refers to "my vault", "my notes", "daily note", "Obsidian",
+  wikilinks, or Markdown notes managed by Obsidian.
+
+## When NOT to Use
+
+- General filesystem work outside Obsidian.
+- Remote note providers such as Notion, Google Drive, Apple Notes, or cloud
+  storage.
+- Browser automation, OAuth, MCP, web search, or direct filesystem tools.
+- Plugin installation, theme changes, sync changes, command execution by ID, or
+  deletion unless the user explicitly asks for that exact side effect.
+
+## Setup and Availability
+
+- CLI mode: Obsidian 1.12.7+ with Command line interface registered. Workbench
+  launches the app on demand when needed.
+- Vault file mode: Skills page → Obsidian → Select vault folder. Commands run
+  against that folder's Markdown files without the running app.
+- Confirm the active vault with `obsidian vault info=name` ONLY when the request
+  is ambiguous or multiple vaults exist — not before every request. If the
+  request names a specific vault, add `vault="<Vault Name>"`.
+- If no vault is active or the CLI cannot reach Obsidian, ask the user to open
+  Obsidian or select a vault folder. A missing vault path is a runtime setup
+  question, not a reason to use another tool or python.
+
+## Output Policy
+
+- Keep results small: note path, matching line, and the minimal relevant
+  excerpt. Cite note paths and headings when answering from vault content.
+- After a successful command, finish with a concise visible answer.
+- If a command fails because Obsidian is not running, a vault is missing, or a
+  note path is ambiguous, report that clearly and ask for the next specific
+  setup step. Never claim a note changed unless the command succeeded.
+- Do not expose full vault dumps, plugin listings, or large note bodies unless
+  the user explicitly requests them.