@memtensor/memos-local-openclaw-plugin 0.3.18 → 0.3.19

package/skill/browserwing-executor/SKILL.md

@@ -0,0 +1,510 @@
+---
+name: browserwing-executor
+description: Control browser automation through HTTP API. Supports page navigation, element interaction (click, type, select), data extraction, accessibility snapshot analysis, screenshot, JavaScript execution, and batch operations.
+---
+
+# BrowserWing Executor API
+
+## Overview
+
+BrowserWing Executor provides comprehensive browser automation capabilities through HTTP APIs. You can control browser navigation, interact with page elements, extract data, and analyze page structure.
+
+**API Base URL:** `http://localhost:8080/api/v1/executor`
+
+**Authentication:** Use `X-BrowserWing-Key: <api-key>` header or `Authorization: Bearer <token>`
+
+## Core Capabilities
+
+- **Page Navigation:** Navigate to URLs, go back/forward, reload
+- **Element Interaction:** Click, type, select, hover on page elements
+- **Data Extraction:** Extract text, attributes, values from elements
+- **Accessibility Analysis:** Get accessibility snapshot to understand page structure
+- **Advanced Operations:** Screenshot, JavaScript execution, keyboard input
+- **Batch Processing:** Execute multiple operations in sequence
+
+## API Endpoints
+
+### 1. Discover Available Commands
+
+**IMPORTANT:** Always call this endpoint first to see all available commands and their parameters.
+
+```bash
+curl -X GET 'http://localhost:8080/api/v1/executor/help'
+```
+
+**Response:** Returns complete list of all commands with parameters, examples, and usage guidelines.
+
+**Query specific command:**
+```bash
+curl -X GET 'http://localhost:8080/api/v1/executor/help?command=extract'
+```
+
+### 2. Get Accessibility Snapshot
+
+**CRITICAL:** Always call this after navigation to understand page structure and get element RefIDs.
+
+```bash
+curl -X GET 'http://localhost:8080/api/v1/executor/snapshot'
+```
+
+**Response Example:**
+```json
+{
+  "success": true,
+  "snapshot_text": "Clickable Elements:\n  @e1 Login (role: button)\n  @e2 Sign Up (role: link)\n\nInput Elements:\n  @e3 Email (role: textbox) [placeholder: your@email.com]\n  @e4 Password (role: textbox)"
+}
+```
+
+**Use Cases:**
+- Understand what interactive elements are on the page
+- Get element RefIDs (@e1, @e2, etc.) for precise identification
+- See element labels, roles, and attributes
+- The accessibility tree is cleaner than raw DOM and better for LLMs
+- RefIDs are stable references that work reliably across page changes
+
+### 3. Common Operations
+
+#### Navigate to URL
+```bash
+curl -X POST 'http://localhost:8080/api/v1/executor/navigate' \
+  -H 'Content-Type: application/json' \
+  -d '{"url": "https://example.com"}'
+```
+
+#### Click Element
+```bash
+curl -X POST 'http://localhost:8080/api/v1/executor/click' \
+  -H 'Content-Type: application/json' \
+  -d '{"identifier": "@e1"}'
+```
+**Identifier formats:**
+- **RefID (Recommended):** `@e1`, `@e2` (from snapshot)
+- **CSS Selector:** `#button-id`, `.class-name`
+- **XPath:** `//button[@type='submit']`
+- **Text:** `Login` (text content)
+
+#### Type Text
+```bash
+curl -X POST 'http://localhost:8080/api/v1/executor/type' \
+  -H 'Content-Type: application/json' \
+  -d '{"identifier": "@e3", "text": "user@example.com"}'
+```
+
+#### Extract Data
+```bash
+curl -X POST 'http://localhost:8080/api/v1/executor/extract' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "selector": ".product-item",
+    "fields": ["text", "href"],
+    "multiple": true
+  }'
+```
+
+#### Wait for Element
+```bash
+curl -X POST 'http://localhost:8080/api/v1/executor/wait' \
+  -H 'Content-Type: application/json' \
+  -d '{"identifier": ".loading", "state": "hidden", "timeout": 10}'
+```
+
+#### Batch Operations
+```bash
+curl -X POST 'http://localhost:8080/api/v1/executor/batch' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "operations": [
+      {"type": "navigate", "params": {"url": "https://example.com"}, "stop_on_error": true},
+      {"type": "click", "params": {"identifier": "@e1"}, "stop_on_error": true},
+      {"type": "type", "params": {"identifier": "@e3", "text": "query"}, "stop_on_error": true}
+    ]
+  }'
+```
+
+## Instructions
+
+**Step-by-step workflow:**
+
+1. **Discover commands:** Call `GET /help` to see all available operations and their parameters (do this first if unsure).
+
+2. **Navigate:** Use `POST /navigate` to open the target webpage.
+
+3. **Analyze page:** Call `GET /snapshot` to understand page structure and get element RefIDs.
+
+4. **Interact:** Use element RefIDs (like `@e1`, `@e2`) or CSS selectors to:
+   - Click elements: `POST /click`
+   - Input text: `POST /type`
+   - Select options: `POST /select`
+   - Wait for elements: `POST /wait`
+
+5. **Extract data:** Use `POST /extract` to get information from the page.
+
+6. **Present results:** Format and show extracted data to the user.
+
+## Complete Example
+
+**User Request:** "Search for 'laptop' on example.com and get the first 5 results"
+
+**Your Actions:**
+
+1. Navigate to search page:
+```bash
+curl -X POST 'http://localhost:8080/api/v1/executor/navigate' \
+  -H 'Content-Type: application/json' \
+  -d '{"url": "https://example.com/search"}'
+```
+
+2. Get page structure to find search input:
+```bash
+curl -X GET 'http://localhost:8080/api/v1/executor/snapshot'
+```
+Response shows: `@e3 Search (role: textbox) [placeholder: Search...]`
+
+3. Type search query:
+```bash
+curl -X POST 'http://localhost:8080/api/v1/executor/type' \
+  -H 'Content-Type: application/json' \
+  -d '{"identifier": "@e3", "text": "laptop"}'
+```
+
+4. Press Enter to submit:
+```bash
+curl -X POST 'http://localhost:8080/api/v1/executor/press-key' \
+  -H 'Content-Type: application/json' \
+  -d '{"key": "Enter"}'
+```
+
+5. Wait for results to load:
+```bash
+curl -X POST 'http://localhost:8080/api/v1/executor/wait' \
+  -H 'Content-Type: application/json' \
+  -d '{"identifier": ".search-results", "state": "visible", "timeout": 10}'
+```
+
+6. Extract search results:
+```bash
+curl -X POST 'http://localhost:8080/api/v1/executor/extract' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "selector": ".result-item",
+    "fields": ["text", "href"],
+    "multiple": true
+  }'
+```
+
+7. Present the extracted data:
+```
+Found 15 results for 'laptop':
+1. Gaming Laptop - $1299 (https://...)
+2. Business Laptop - $899 (https://...)
+...
+```
+
+## Key Commands Reference
+
+### Navigation
+- `POST /navigate` - Navigate to URL
+- `POST /go-back` - Go back in history
+- `POST /go-forward` - Go forward in history
+- `POST /reload` - Reload current page
+
+### Element Interaction
+- `POST /click` - Click element (supports: RefID `@e1`, CSS selector, XPath, text content)
+- `POST /type` - Type text into input (supports: RefID `@e3`, CSS selector, XPath)
+- `POST /select` - Select dropdown option
+- `POST /hover` - Hover over element
+- `POST /wait` - Wait for element state (visible, hidden, enabled)
+- `POST /press-key` - Press keyboard key (Enter, Tab, Ctrl+S, etc.)
+
+### Data Extraction
+- `POST /extract` - Extract data from elements (supports multiple elements, custom fields)
+- `POST /get-text` - Get element text content
+- `POST /get-value` - Get input element value
+- `GET /page-info` - Get page URL and title
+- `GET /page-text` - Get all page text
+- `GET /page-content` - Get full HTML
+
+### Page Analysis
+- `GET /snapshot` - Get accessibility snapshot (⭐ **ALWAYS call after navigation**)
+- `GET /clickable-elements` - Get all clickable elements
+- `GET /input-elements` - Get all input elements
+
+### Advanced
+- `POST /screenshot` - Take page screenshot (base64 encoded)
+- `POST /evaluate` - Execute JavaScript code
+- `POST /batch` - Execute multiple operations in sequence
+- `POST /scroll-to-bottom` - Scroll to page bottom
+- `POST /resize` - Resize browser window
+- `POST /tabs` - Manage browser tabs (list, new, switch, close)
+- `POST /fill-form` - Intelligently fill multiple form fields at once
+
+### Debug & Monitoring
+- `GET /console-messages` - Get browser console messages (logs, warnings, errors)
+- `GET /network-requests` - Get network requests made by the page
+- `POST /handle-dialog` - Configure JavaScript dialog (alert, confirm, prompt) handling
+- `POST /file-upload` - Upload files to input elements
+- `POST /drag` - Drag and drop elements
+- `POST /close-page` - Close the current page/tab
+
+## Element Identification
+
+You can identify elements using:
+
+1. **RefID (Recommended):** `@e1`, `@e2`, `@e3`
+   - Most reliable method - stable across page changes
+   - Get RefIDs from `/snapshot` endpoint
+   - Valid for 5 minutes after snapshot
+   - Example: `"identifier": "@e1"`
+   - Works with multi-strategy fallback for robustness
+
+2. **CSS Selector:** `#id`, `.class`, `button[type="submit"]`
+   - Standard CSS selectors
+   - Example: `"identifier": "#login-button"`
+
+3. **XPath:** `//button[@id='login']`, `//a[contains(text(), 'Submit')]`
+   - XPath expressions for complex queries
+   - Example: `"identifier": "//button[@id='login']"`
+
+4. **Text Content:** `Login`, `Sign Up`, `Submit`
+   - Searches buttons and links with matching text
+   - Example: `"identifier": "Login"`
+
+5. **ARIA Label:** Elements with `aria-label` attribute
+   - Automatically searched
+
+## Guidelines
+
+**Before starting:**
+- Call `GET /help` if you're unsure about available commands or their parameters
+- Ensure browser is started (if not, it will auto-start on first operation)
+
+**During automation:**
+- **Always call `/snapshot` after navigation** to get page structure and RefIDs
+- **Prefer RefIDs** (like `@e1`) over CSS selectors for reliability and stability
+- **Re-snapshot after page changes** to get updated RefIDs
+- **Use `/wait`** for dynamic content that loads asynchronously
+- **Check element states** before interaction (visible, enabled)
+- **Use `/batch`** for multiple sequential operations to improve efficiency
+
+**Error handling:**
+- If operation fails, check element identifier and try different format
+- For timeout errors, increase timeout value
+- If element not found, call `/snapshot` again to refresh page structure
+- Explain errors clearly to user with suggested solutions
+
+**Data extraction:**
+- Use `fields` parameter to specify what to extract: `["text", "href", "src"]`
+- Set `multiple: true` to extract from multiple elements
+- Format extracted data in a readable way for user
+
+## Complete Workflow Example
+
+**Scenario:** User wants to login to a website
+
+```
+User: "Please log in to example.com with username 'john' and password 'secret123'"
+```
+
+**Your Actions:**
+
+**Step 1:** Navigate to login page
+```bash
+POST http://localhost:8080/api/v1/executor/navigate
+{"url": "https://example.com/login"}
+```
+
+**Step 2:** Get page structure
+```bash
+GET http://localhost:8080/api/v1/executor/snapshot
+```
+Response:
+```
+Clickable Elements:
+  @e1 Login (role: button)
+
+Input Elements:
+  @e2 Username (role: textbox)
+  @e3 Password (role: textbox)
+```
+
+**Step 3:** Enter username
+```bash
+POST http://localhost:8080/api/v1/executor/type
+{"identifier": "@e2", "text": "john"}
+```
+
+**Step 4:** Enter password
+```bash
+POST http://localhost:8080/api/v1/executor/type
+{"identifier": "@e3", "text": "secret123"}
+```
+
+**Step 5:** Click login button
+```bash
+POST http://localhost:8080/api/v1/executor/click
+{"identifier": "@e1"}
+```
+
+**Step 6:** Wait for login success (optional)
+```bash
+POST http://localhost:8080/api/v1/executor/wait
+{"identifier": ".welcome-message", "state": "visible", "timeout": 10}
+```
+
+**Step 7:** Inform user
+```
+"Successfully logged in to example.com!"
+```
+
+## Batch Operation Example
+
+**Scenario:** Fill out a form with multiple fields
+
+Instead of making 5 separate API calls, use one batch operation:
+
+```bash
+curl -X POST 'http://localhost:8080/api/v1/executor/batch' \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "operations": [
+      {
+        "type": "navigate",
+        "params": {"url": "https://example.com/form"},
+        "stop_on_error": true
+      },
+      {
+        "type": "type",
+        "params": {"identifier": "#name", "text": "John Doe"},
+        "stop_on_error": true
+      },
+      {
+        "type": "type",
+        "params": {"identifier": "#email", "text": "john@example.com"},
+        "stop_on_error": true
+      },
+      {
+        "type": "select",
+        "params": {"identifier": "#country", "value": "United States"},
+        "stop_on_error": true
+      },
+      {
+        "type": "click",
+        "params": {"identifier": "#submit"},
+        "stop_on_error": true
+      }
+    ]
+  }'
+```
+
+## Best Practices
+
+1. **Discovery first:** If unsure, call `/help` or `/help?command=<name>` to learn about commands
+2. **Structure first:** Always call `/snapshot` after navigation to understand the page
+3. **Use accessibility indices:** They're more reliable than CSS selectors (elements might have dynamic classes)
+4. **Wait for dynamic content:** Use `/wait` before interacting with elements that load asynchronously
+5. **Batch when possible:** Use `/batch` for multiple sequential operations
+6. **Handle errors gracefully:** Provide clear explanations and suggestions when operations fail
+7. **Verify results:** After operations, check if desired outcome was achieved
+
+## Common Scenarios
+
+### Form Filling
+1. Navigate to form page
+2. Get accessibility snapshot to find input elements and their RefIDs
+3. Use `/type` for each field: `@e1`, `@e2`, etc.
+4. Use `/select` for dropdowns
+5. Click submit button using its RefID
+
+### Data Scraping
+1. Navigate to target page
+2. Wait for content to load with `/wait`
+3. Use `/extract` with CSS selector and `multiple: true`
+4. Specify fields to extract: `["text", "href", "src"]`
+
+### Search Operations
+1. Navigate to search page
+2. Get accessibility snapshot to locate search input
+3. Type search query into input
+4. Press Enter or click search button
+5. Wait for results
+6. Extract results data
+
+### Login Automation
+1. Navigate to login page
+2. Get accessibility snapshot to find RefIDs
+3. Type username: `@e2`
+4. Type password: `@e3`
+5. Click login button: `@e1`
+6. Wait for success indicator
+
+## Important Notes
+
+- Browser must be running (it will auto-start on first operation if needed)
+- Operations are executed on the **currently active browser tab**
+- Accessibility snapshot updates after each navigation and click operation
+- All timeouts are in seconds
+- Use `wait_visible: true` (default) for reliable element interaction
+- Replace `localhost:8080` with actual API host address
+- Authentication required: use `X-BrowserWing-Key` header or JWT token
+
+## Troubleshooting
+
+**Element not found:**
+- Call `/snapshot` to see available elements
+- Try different identifier format (accessibility index, CSS selector, text)
+- Check if page has finished loading
+
+**Timeout errors:**
+- Increase timeout value in request
+- Check if element actually appears on page
+- Use `/wait` with appropriate state before interaction
+
+**Extraction returns empty:**
+- Verify CSS selector matches target elements
+- Check if content has loaded (use `/wait` first)
+- Try different extraction fields or type
+
+## Quick Reference
+
+```bash
+# Discover commands
+GET localhost:8080/api/v1/executor/help
+
+# Navigate
+POST localhost:8080/api/v1/executor/navigate {"url": "..."}
+
+# Get page structure
+GET localhost:8080/api/v1/executor/snapshot
+
+# Click element
+POST localhost:8080/api/v1/executor/click {"identifier": "@e1"}
+
+# Type text
+POST localhost:8080/api/v1/executor/type {"identifier": "@e3", "text": "..."}
+
+# Extract data
+POST localhost:8080/api/v1/executor/extract {"selector": "...", "fields": [...], "multiple": true}
+```
+
+## Response Format
+
+All operations return:
+```json
+{
+  "success": true,
+  "message": "Operation description",
+  "timestamp": "2026-01-15T10:30:00Z",
+  "data": {
+    // Operation-specific data
+  }
+}
+```
+
+**Error response:**
+```json
+{
+  "error": "error.operationFailed",
+  "detail": "Detailed error message"
+}
+```
+

package/skill/memos-memory-guide/SKILL.md

@@ -1,86 +1,112 @@
 ---
 name: memos-memory-guide
-description: Use the MemOS Local memory system to search and use the user's past conversations. Use this skill whenever the user refers to past chats, their own preferences or history, or when you need to answer from prior context. When auto-recall returns nothing (long or unclear user query), generate your own short search query and call memory_search. Use task_summary when you need full task context, skill_get for experience guides, and memory_timeline to expand around a memory hit.
+description: Use the MemOS Local memory system to search and use the user's past conversations. Use this skill whenever the user refers to past chats, their own preferences or history, or when you need to answer from prior context. When auto-recall returns nothing (long or unclear user query), generate your own short search query and call memory_search. Use task_summary when you need full task context, skill_get for experience guides, skill_search to discover public skills, memory_write_public for shared knowledge, and memory_timeline to expand around a memory hit.
 ---
 
 # MemOS Local Memory — Agent Guide
 
-This skill describes how to use the MemOS memory tools so you can reliably search and use the user's long-term conversation history.
+This skill describes how to use the MemOS memory tools so you can reliably search and use the user's long-term conversation history, share knowledge across agents, and discover public skills.
 
 ## How memory is provided each turn
 
 - **Automatic recall (hook):** At the start of each turn, the system runs a memory search using the user's current message and injects relevant past memories into your context. You do not need to call any tool for that.
-- **When that is not enough:** If the user's message is very long, vague, or the automatic search returns **no memories**, you should **generate your own short, focused query** and call `memory_search` yourself. For example:
-  - User sent a long paragraph → extract 1–2 key topics or a short question and search with that.
-  - Auto-recall said "no memories" or you see no memory block → call `memory_search` with a query you derive (e.g. the user's name, a topic they often mention, or a rephrased question).
-- **When you need more detail:** Search results only give excerpts and IDs. Use the tools below to fetch full task context, skill content, or surrounding messages.
+- **When that is not enough:** If the user's message is very long, vague, or the automatic search returns **no memories**, you should **generate your own short, focused query** and call `memory_search` yourself.
+- **Memory isolation:** Each agent can only see its own memories and memories marked as `public`. Other agents' private memories are invisible to you.
 
 ## Tools — what they do and when to call
 
 ### memory_search
 
-- **What it does:** Searches the user's stored conversation memory by a natural-language query. Returns a list of relevant excerpts with `chunkId` and optionally `task_id`.
+- **What it does:** Searches the user's stored conversation memory by a natural-language query. Returns a list of relevant excerpts with `chunkId` and optionally `task_id`. Only returns memories belonging to the current agent or marked as public.
 - **When to call:**
-  - The automatic recall did not run or returned nothing (e.g. no `<memory_context>` block, or a note that no memories were found).
-  - The user's query is long or unclear — **generate a short query yourself** (keywords, rephrased question, or a clear sub-question) and call `memory_search(query="...")`.
-  - You need to search with a different angle (e.g. filter by `role='user'` to find what the user said, or use a more specific query).
-- **Parameters:** `query` (required), optional `minScore`, `role` (e.g. `"user"`).
-- **Output:** List of items with role, excerpt, `chunkId`, and sometimes `task_id`. Use those IDs with the tools below when you need more context.
+  - The automatic recall did not run or returned nothing.
+  - The user's query is long or unclear — **generate a short query yourself** and call `memory_search(query="...")`.
+  - You need to search with a different angle (e.g. filter by `role='user'`).
+- **Parameters:** `query` (required), optional `minScore`, `role`.
+
+### memory_write_public
+
+- **What it does:** Writes a piece of information to **public memory**. Public memory is visible to all agents — any agent doing `memory_search` can find it.
+- **When to call:** In multi-agent or collaborative scenarios, when you have **persistent information useful to everyone** (e.g. shared decisions, conventions, configurations, workflows). Do not write session-only or purely private content.
+- **Parameters:** `content` (required), `summary` (optional).
 
 ### task_summary
 
-- **What it does:** Returns the full task summary for a given `task_id`: title, status, and the complete narrative summary of that conversation task (steps, decisions, URLs, commands, etc.).
-- **When to call:** A `memory_search` hit included a `task_id` and you need the full story of that task (e.g. what was done, what the user decided, what failed or succeeded).
+- **What it does:** Returns the full task summary for a given `task_id`: title, status, and the complete narrative summary.
+- **When to call:** A `memory_search` hit included a `task_id` and you need the full story of that task.
 - **Parameters:** `taskId` (from a search hit).
-- **Effect:** You get one coherent summary of the whole task instead of isolated excerpts.
 
 ### skill_get
 
-- **What it does:** Returns the content of a learned skill (experience guide) by `skillId` or by `taskId`. If you pass `taskId`, the system finds the skill linked to that task.
-- **When to call:** A search hit has a `task_id` and the task is the kind that has a “how to do this again” guide (e.g. a workflow the user has run before). Use this to follow the same approach or reuse steps.
+- **What it does:** Returns the content of a learned skill (experience guide) by `skillId` or by `taskId`.
+- **When to call:** A search hit has a `task_id` and the task has a "how to do this again" guide. Use this to follow the same approach or reuse steps.
 - **Parameters:** `skillId` (direct) or `taskId` (lookup).
-- **Effect:** You receive the full SKILL.md-style guide. You can then call `skill_install(skillId)` if the user or you want that skill loaded for future turns.
+
+### skill_search
+
+- **What it does:** Searches available **skills** (capabilities/guides) by natural language. Can search your own skills, other agents' public skills, or both — controlled by the `scope` parameter.
+- **When to call:** The current task requires a capability or guide you don't have. Use `skill_search` to find one first; after finding it, use `skill_get` to read it, then `skill_install` to load it for future turns. Set `scope` to `public` to only see others' public skills, `self` for only your own, or leave as default `mix` for both.
+- **Parameters:** `query` (required, natural language description of the need), `scope` (optional, default `mix`: self + public; `self`: own only; `public`: public only).
 
 ### skill_install
 
-- **What it does:** Installs a skill (by `skillId`) into the workspace so it is loaded in future sessions.
-- **When to call:** After `skill_get` when the skill is useful for ongoing use (e.g. the user’s recurring workflow). Optional; only when you want the skill to be permanently available.
+- **What it does:** Installs a skill (by `skillId`) into the workspace for future sessions.
+- **When to call:** After `skill_get` when the skill is useful for ongoing use.
+- **Parameters:** `skillId`.
+
+### skill_publish
+
+- **What it does:** Makes a skill **public** so other agents can discover and install it via `skill_search`.
+- **When to call:** You have a useful skill that other agents could benefit from, and you want to share it.
+- **Parameters:** `skillId`.
+
+### skill_unpublish
+
+- **What it does:** Makes a skill **private** again. Other agents will no longer discover it.
+- **When to call:** You want to stop sharing a previously published skill.
 - **Parameters:** `skillId`.
 
 ### memory_timeline
 
-- **What it does:** Expands context around a single memory chunk: returns the surrounding conversation messages (±N turns) so you see what was said before and after that excerpt.
-- **When to call:** A `memory_search` hit is relevant but you need the surrounding dialogue (e.g. who said what next, or the exact follow-up question).
+- **What it does:** Expands context around a single memory chunk: returns the surrounding conversation messages.
+- **When to call:** A `memory_search` hit is relevant but you need the surrounding dialogue.
 - **Parameters:** `chunkId` (from a search hit), optional `window` (default 2).
-- **Effect:** You get a short, linear slice of the conversation around that chunk.
 
 ### memory_viewer
 
-- **What it does:** Returns the URL of the MemOS Memory Viewer (web UI) where the user can browse, search, and manage their memories.
-- **When to call:** The user asks how to view their memories, open the memory dashboard, or manage stored data.
+- **What it does:** Returns the URL of the MemOS Memory Viewer web dashboard.
+- **When to call:** The user asks how to view their memories or open the memory dashboard.
 - **Parameters:** None.
-- **Effect:** You can tell the user to open that URL in a browser.
 
 ## Quick decision flow
 
-1. **No memories in context or auto-recall reported nothing**  
-   → Call `memory_search` with a **self-generated short query** (e.g. key topic or rephrased question).
+1. **No memories in context or auto-recall reported nothing**
+   → Call `memory_search` with a **self-generated short query**.
 
-2. **Search returned hits with `task_id` and you need full context**  
+2. **Search returned hits with `task_id` and you need full context**
    → Call `task_summary(taskId)`.
 
-3. **Task has an experience guide you want to follow**  
-   → Call `skill_get(taskId=...)` (or `skill_get(skillId=...)` if you have the id). Optionally `skill_install(skillId)` for future use.
+3. **Task has an experience guide you want to follow**
+   → Call `skill_get(taskId=...)` or `skill_get(skillId=...)`. Optionally `skill_install(skillId)` for future use.
 
-4. **You need the exact surrounding conversation of a hit**  
+4. **You need the exact surrounding conversation of a hit**
    → Call `memory_timeline(chunkId=...)`.
 
-5. **User asks where to see or manage their memories**  
+5. **You need a capability/guide that you don't have**
+   → Call `skill_search(query="...", scope="mix")` to discover available skills.
+
+6. **You have shared knowledge useful to all agents**
+   → Call `memory_write_public(content="...")` to persist it in public memory.
+
+7. **You want to share a useful skill with other agents**
+   → Call `skill_publish(skillId=...)`.
+
+8. **User asks where to see or manage their memories**
    → Call `memory_viewer()` and share the URL.
 
 ## Writing good search queries
 
 - Prefer **short, focused** queries (a few words or one clear question).
-- Use **concrete terms**: names, topics, tools, or decisions (e.g. “preferred editor”, “deploy script”, “API key setup”).
-- If the user’s message is long, **derive one or two sub-queries** rather than pasting the whole message.
-- Use `role='user'` when you specifically want to find what the user said (e.g. preferences, past questions).
+- Use **concrete terms**: names, topics, tools, or decisions.
+- If the user's message is long, **derive one or two sub-queries** rather than pasting the whole message.
+- Use `role='user'` when you specifically want to find what the user said.