@zibby/skills 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zibby
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,228 @@
+# @zibby/skills
+
+Skill definitions for the Zibby test automation framework.
+
+A **skill** is the contract between a workflow node and a tool. It tells the framework what the tool does, how to start it, and what it needs. The framework never hardcodes any skill by name — it reads the skill definition and wires things up generically for both Claude and Cursor agents.
+
+## Quick start
+
+```bash
+npm install @zibby/skills
+```
+
+Import the package to register all built-in skills:
+
+```javascript
+import '@zibby/skills';
+```
+
+## The `skill()` factory
+
+One function to create any skill. Auto-detects the type and auto-registers.
+
+### Function skill
+
+One skill = one tool. Flat, no nesting.
+
+```javascript
+import { skill } from '@zibby/skills';
+
+export const add = skill('add', {
+  description: 'Add two numbers',
+  input: { a: 'number', b: 'number' },
+  handler: async ({ a, b }) => ({ result: a + b })
+});
+```
+
+Use it in a node:
+
+```javascript
+export const mathNode = {
+  name: 'do_math',
+  skills: ['add'],
+  prompt: (state) => `Add ${state.a} and ${state.b}`,
+};
+```
+
+### MCP skill
+
+For wrapping existing MCP server packages:
+
+```javascript
+import { skill } from '@zibby/skills';
+
+export const linear = skill('linear', {
+  envKeys: ['LINEAR_API_KEY'],
+  description: 'Linear issue tracker',
+  resolve() {
+    if (!process.env.LINEAR_API_KEY) return null;
+    return {
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-linear'],
+      env: { LINEAR_API_KEY: process.env.LINEAR_API_KEY },
+    };
+  }
+});
+```
+
+## Built-in skills
+
+| ID | Server | MCP Package |
+|----|--------|-------------|
+| `browser` | `playwright` | `@zibby/mcp-browser` / `@playwright/mcp` |
+| `jira` | `jira` | `@zibby/mcp-jira` |
+| `github` | `github` | `@modelcontextprotocol/server-github` |
+| `slack` | `slack` | `@modelcontextprotocol/server-slack` |
+
+## Function skill API
+
+```javascript
+skill(id, { description, input, handler })
+```
+
+- `id` — Unique skill identifier (used in `skills: ['add']`)
+- `description` — What the tool does (shown to the LLM)
+- `input` — Parameter definitions:
+
+```javascript
+{
+  param: { type: 'string' },             // full form
+  other: 'number',                       // shorthand
+  optional: { type: 'string', required: false },
+}
+```
+
+- `handler` — The function that runs when the tool is called:
+
+```javascript
+handler: async ({ param, other }) => {
+  return { result: 'something' };        // any JSON-serializable value
+}
+```
+
+### Handler rules
+
+- Must be `async` (or return a Promise)
+- Receives one object argument with the input parameters
+- Must return a JSON-serializable value
+- Has full access to imports, closures, and the module scope
+- Runs in a child process (the function bridge)
+
+### More examples
+
+```javascript
+import { skill } from '@zibby/skills';
+
+export const fetchUrl = skill('fetch_url', {
+  description: 'Fetch a URL and return the response body',
+  input: { url: 'string' },
+  handler: async ({ url }) => {
+    const res = await fetch(url);
+    return { status: res.status, body: await res.text() };
+  }
+});
+
+export const healthCheck = skill('health_check', {
+  description: 'Check if the service is running',
+  handler: async () => ({ status: 'ok', timestamp: Date.now() })
+});
+```
+
+## MCP skill API
+
+```javascript
+skill(id, config)
+```
+
+Config object:
+
+| Property | Required | Description |
+|---|---|---|
+| `resolve(options)` | Yes | Returns `{ command, args, env }` or `null` |
+| `serverName` | No | MCP server name (defaults to `id`) |
+| `allowedTools` | No | Tool patterns (defaults to `['mcp__<serverName>__*']`) |
+| `envKeys` | No | Env vars the skill needs |
+| `description` | No | Human-readable description |
+| `tools` | No | Tool schemas for compile-time validation |
+| `cursorKey` | No | Override key in `~/.cursor/mcp.json` |
+| `sessionEnvKey` | No | Env var for session artifact paths (Cursor only) |
+
+### Advanced example: custom binary with fallback
+
+```javascript
+import { skill } from '@zibby/skills';
+import { createRequire } from 'module';
+
+const _require = createRequire(import.meta.url);
+
+export const database = skill('database', {
+  envKeys: ['DATABASE_URL'],
+  description: 'Database query MCP server',
+  resolve({ sessionPath } = {}) {
+    let bin;
+    try { bin = _require.resolve('@myorg/mcp-database/server.js'); }
+    catch { bin = null; }
+
+    if (bin) {
+      return {
+        command: 'node',
+        args: [bin, '--read-only'],
+        env: { DATABASE_URL: process.env.DATABASE_URL },
+      };
+    }
+
+    return {
+      command: 'npx',
+      args: ['-y', '@myorg/mcp-database', '--read-only'],
+      env: { DATABASE_URL: process.env.DATABASE_URL },
+    };
+  }
+});
+```
+
+## How it works under the hood
+
+```
+  Node definition                Skill definition              Agent strategy
+  ─────────────                  ────────────────              ──────────────
+  skills: ['add']        ──►     getSkill('add')        ──►    strategy-specific setup
+                                   │
+                                   ▼
+                                 skill.resolve()
+                                   │
+                                   ▼
+                                 { command, args, env }
+                                   │
+                          ┌────────┴────────┐
+                          ▼                 ▼
+                      Claude SDK         Cursor CLI
+                      ──────────         ──────────
+                      In-memory          Writes to
+                      mcpServers         ~/.cursor/mcp.json
+                      param to           before spawning
+                      query()            `agent` CLI
+```
+
+**Claude**: The SDK receives `mcpServers` as a parameter. It spawns the MCP server as a child process, connects via stdio, routes tool calls through it.
+
+**Cursor**: The framework writes `~/.cursor/mcp.json` to disk before spawning the `agent` CLI. Cursor reads that file and manages MCP servers itself.
+
+The strategies never reference any skill by name. They loop over the skill definitions and call `resolve()` on each.
+
+## API
+
+```javascript
+import {
+  skill,             // Unified factory — auto-detects type, auto-registers
+  registerSkill,     // Register a raw skill definition
+  getSkill,          // Get a skill by ID
+  hasSkill,          // Check if a skill is registered
+  getAllSkills,       // Get all registered skills (Map)
+  listSkillIds,      // Get array of registered skill IDs
+  SKILLS,            // Built-in skill ID constants
+} from '@zibby/skills';
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@zibby/skills",
+  "version": "0.1.0",
+  "description": "Built-in skill definitions for Zibby test automation framework",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./browser": "./src/browser.js",
+    "./jira": "./src/jira.js",
+    "./github": "./src/github.js",
+    "./slack": "./src/slack.js",
+    "./memory": "./src/memory.js",
+    "./function": "./src/function-skill.js"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix ."
+  },
+  "keywords": [
+    "zibby",
+    "skills",
+    "mcp",
+    "automation",
+    "testing"
+  ],
+  "author": "Zibby",
+  "license": "MIT",
+  "homepage": "https://zibby.app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ZibbyHQ/zibby-agent"
+  },
+  "bugs": {
+    "url": "https://github.com/ZibbyHQ/zibby-agent/issues"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "peerDependencies": {
+    "@zibby/core": ">=0.1.0"
+  },
+  "optionalDependencies": {
+    "@zibby/mcp-jira": "*",
+    "@zibby/mcp-browser": "*",
+    "@zibby/mcp-memory": "*"
+  }
+}

package/src/browser.js

@@ -0,0 +1,64 @@
+/**
+ * Browser Skill
+ *
+ * Provides Playwright-based browser automation via MCP.
+ * Resolves to @zibby/mcp-browser (if installed) or @playwright/mcp as fallback.
+ *
+ * Call resolve({ sessionPath, workspace }) to get a ready-to-use MCP server
+ * config with session-specific args (video dir, viewport, etc.).
+ */
+
+import { createRequire } from 'module';
+
+const _require = createRequire(import.meta.url);
+
+function resolveBrowserBin() {
+  if (process.env.MCP_BROWSER_PATH) return process.env.MCP_BROWSER_PATH;
+  try {
+    return _require.resolve('@zibby/mcp-browser/bin/mcp-browser-zibby.js');
+  } catch {
+    return null;
+  }
+}
+
+const VIDEO_RESOLUTION = '1280x720';
+const VIEWPORT_SIZE = '1280x720';
+
+export const browserSkill = {
+  id: 'browser',
+  serverName: 'playwright',
+  cursorKey: 'playwright-official',
+  allowedTools: ['mcp__playwright__*'],
+  sessionEnvKey: 'ZIBBY_SESSION_INFO',
+  description: 'Playwright Browser MCP Server',
+  envKeys: [],
+  tools: [],
+
+  resolve({ sessionPath, workspace } = {}) {
+    const bin = resolveBrowserBin();
+    const outputDir = sessionPath || workspace || 'test-results';
+
+    if (bin) {
+      return {
+        command: 'node',
+        args: [
+          bin,
+          `--save-video=${VIDEO_RESOLUTION}`,
+          `--viewport-size=${VIEWPORT_SIZE}`,
+          `--output-dir=${outputDir}`,
+        ],
+      };
+    }
+
+    return {
+      command: 'npx',
+      args: [
+        '-y',
+        '@playwright/mcp',
+        `--save-video=${VIDEO_RESOLUTION}`,
+        `--viewport-size=${VIEWPORT_SIZE}`,
+        '--output-dir', outputDir,
+      ],
+    };
+  },
+};

package/src/function-skill.js

@@ -0,0 +1,160 @@
+/**
+ * Unified Skill Factory
+ *
+ * Function skill (one skill = one tool, flat):
+ *
+ *   import { skill } from '@zibby/skills';
+ *
+ *   export const add = skill('add', {
+ *     description: 'Add two numbers',
+ *     input: { a: 'number', b: 'number' },
+ *     handler: async ({ a, b }) => ({ result: a + b })
+ *   });
+ *
+ * MCP skill:
+ *
+ *   import { skill } from '@zibby/skills';
+ *
+ *   export const linear = skill('linear', {
+ *     resolve() {
+ *       if (!process.env.LINEAR_API_KEY) return null;
+ *       return { command: 'npx', args: ['-y', '@linear/mcp-server'],
+ *                env: { LINEAR_API_KEY: process.env.LINEAR_API_KEY } };
+ *     }
+ *   });
+ */
+
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { registerHandlers } from '@zibby/core/framework/function-skill-registry.js';
+import { registerSkill } from '@zibby/core/framework/skill-registry.js';
+
+const _require = createRequire(import.meta.url);
+
+function resolveBridgePath() {
+  try {
+    return _require.resolve('@zibby/core/framework/function-bridge.js');
+  } catch {
+    return null;
+  }
+}
+
+const _selfUrl = import.meta.url;
+
+function getCallerFile() {
+  const original = Error.prepareStackTrace;
+  try {
+    Error.prepareStackTrace = (_, stack) => stack;
+    const err = new Error();
+    const stack = err.stack;
+    for (let i = 2; i < stack.length; i++) {
+      const file = stack[i].getFileName();
+      if (file && file !== _selfUrl && !file.startsWith('node:')) {
+        return file.startsWith('file://') ? fileURLToPath(file) : file;
+      }
+    }
+    return null;
+  } finally {
+    Error.prepareStackTrace = original;
+  }
+}
+
+function buildInputSchema(input) {
+  if (!input || typeof input !== 'object') {
+    return { type: 'object', properties: {}, required: [] };
+  }
+  const properties = {};
+  const required = [];
+  for (const [key, def] of Object.entries(input)) {
+    if (typeof def === 'string') {
+      properties[key] = { type: def };
+      required.push(key);
+    } else {
+      const { required: isRequired, ...rest } = def;
+      properties[key] = rest;
+      if (isRequired !== false) required.push(key);
+    }
+  }
+  return { type: 'object', properties, required };
+}
+
+function buildFunctionSkill(id, modulePath, config) {
+  if (typeof config.handler !== 'function') {
+    throw new Error(`Skill "${id}" must have a handler function`);
+  }
+
+  const handlers = { [id]: config.handler };
+  const tools = [{
+    name: id,
+    description: config.description || '',
+    input_schema: buildInputSchema(config.input),
+  }];
+
+  registerHandlers(id, handlers, tools);
+
+  return {
+    id,
+    type: 'function',
+    serverName: id,
+    allowedTools: [`mcp__${id}__*`],
+    description: config.description || `Function skill: ${id}`,
+    envKeys: [],
+    tools,
+    resolve() {
+      const bridge = resolveBridgePath();
+      if (!bridge) return null;
+      return { command: 'node', args: [bridge, modulePath, id] };
+    },
+  };
+}
+
+function buildMcpSkill(id, config) {
+  return {
+    id,
+    type: 'mcp',
+    serverName: config.serverName || id,
+    allowedTools: config.allowedTools || [`mcp__${config.serverName || id}__*`],
+    description: config.description || `MCP skill: ${id}`,
+    envKeys: config.envKeys || [],
+    tools: config.tools || [],
+    resolve: config.resolve,
+    ...(config.cursorKey && { cursorKey: config.cursorKey }),
+    ...(config.sessionEnvKey && { sessionEnvKey: config.sessionEnvKey }),
+  };
+}
+
+/**
+ * Create and register a skill.
+ *
+ * Function skill:  skill(id, { description, input, handler })
+ * MCP skill:       skill(id, { resolve(), serverName?, ... })
+ *
+ * @param {string} id — Unique skill identifier
+ * @param {Object} config — Skill definition
+ * @returns {Object} A registered skill object
+ */
+export function skill(id, config) {
+  let skillObj;
+
+  if ('handler' in config) {
+    if (typeof config.handler !== 'function') {
+      throw new Error(`Skill "${id}" must have a handler function`);
+    }
+    const callerFile = getCallerFile();
+    if (!callerFile) {
+      throw new Error(`Could not resolve caller file for skill "${id}".`);
+    }
+    skillObj = buildFunctionSkill(id, callerFile, config);
+  } else if (typeof config.resolve === 'function') {
+    skillObj = buildMcpSkill(id, config);
+  } else {
+    throw new Error(
+      `Skill "${id}" must have either a handler (function skill) or resolve (MCP skill).`
+    );
+  }
+
+  registerSkill(skillObj);
+  return skillObj;
+}
+
+export const functionSkill = skill;

package/src/github.js

@@ -0,0 +1,54 @@
+/**
+ * GitHub Skill
+ *
+ * Provides GitHub issue and repository management via MCP.
+ * Requires GITHUB_TOKEN environment variable.
+ */
+
+export const githubSkill = {
+  id: 'github',
+  serverName: 'github',
+  allowedTools: ['mcp__github__*'],
+  envKeys: ['GITHUB_TOKEN'],
+  description: 'GitHub MCP Server',
+
+  resolve() {
+    const env = {};
+    for (const key of this.envKeys) {
+      if (process.env[key]) env[key] = process.env[key];
+    }
+    return {
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-github@latest'],
+      env,
+    };
+  },
+
+  tools: [
+    {
+      name: 'github_create_issue',
+      description: 'Create a GitHub issue',
+      input_schema: {
+        type: 'object',
+        properties: {
+          owner: { type: 'string', description: 'Repository owner' },
+          repo: { type: 'string', description: 'Repository name' },
+          title: { type: 'string', description: 'Issue title' },
+          body: { type: 'string', description: 'Issue body (markdown)' }
+        },
+        required: ['owner', 'repo', 'title']
+      }
+    },
+    {
+      name: 'github_search_issues',
+      description: 'Search GitHub issues',
+      input_schema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'GitHub search query' }
+        },
+        required: ['query']
+      }
+    }
+  ]
+};

package/src/index.js

@@ -0,0 +1,35 @@
+/**
+ * @zibby/skills — Built-in skill catalog
+ *
+ * Importing this module registers all built-in skills with the core
+ * skill registry.  Users and community packages can register additional
+ * skills via registerSkill().
+ */
+
+import { registerSkill } from '@zibby/core/framework/skill-registry.js';
+import { browserSkill } from './browser.js';
+import { jiraSkill } from './jira.js';
+import { githubSkill } from './github.js';
+import { slackSkill } from './slack.js';
+import { memorySkill } from './memory.js';
+
+registerSkill(browserSkill);
+registerSkill(jiraSkill);
+registerSkill(githubSkill);
+registerSkill(slackSkill);
+registerSkill(memorySkill);
+
+// Backward-compat alias: MCP_SERVER_REGISTRY used 'slack_notify' as the key
+registerSkill({ ...slackSkill, id: 'slack_notify' });
+
+export const SKILLS = {
+  BROWSER: 'browser',
+  JIRA: 'jira',
+  GITHUB: 'github',
+  SLACK: 'slack',
+  MEMORY: 'memory',
+};
+
+export { browserSkill, jiraSkill, githubSkill, slackSkill, memorySkill };
+export { skill, functionSkill } from './function-skill.js';
+export { registerSkill, getSkill, hasSkill, getAllSkills, listSkillIds } from '@zibby/core/framework/skill-registry.js';

package/src/jira.js

@@ -0,0 +1,110 @@
+/**
+ * Jira Skill
+ *
+ * Provides Jira issue management via MCP.
+ * Requires ATLASSIAN_ACCESS_TOKEN and ATLASSIAN_CLOUD_ID environment variables.
+ *
+ * Call resolve() to get a ready-to-use MCP server config with env vars injected.
+ */
+
+import { createRequire } from 'module';
+
+const _require = createRequire(import.meta.url);
+
+function resolveJiraBin() {
+  if (process.env.MCP_JIRA_PATH) return process.env.MCP_JIRA_PATH;
+  try {
+    return _require.resolve('@zibby/mcp-jira/index.js');
+  } catch {
+    return null;
+  }
+}
+
+export const jiraSkill = {
+  id: 'jira',
+  serverName: 'jira',
+  allowedTools: ['mcp__jira__*'],
+  envKeys: ['ATLASSIAN_ACCESS_TOKEN', 'ATLASSIAN_CLOUD_ID'],
+  description: 'Zibby Jira MCP Server (OAuth Bearer)',
+
+  resolve() {
+    const bin = resolveJiraBin();
+    if (!bin) return null;
+
+    const env = {};
+    for (const key of this.envKeys) {
+      if (process.env[key]) env[key] = process.env[key];
+    }
+    if (process.env.ATLASSIAN_INSTANCE_URL) {
+      env.ATLASSIAN_INSTANCE_URL = process.env.ATLASSIAN_INSTANCE_URL;
+    }
+
+    return {
+      command: 'node',
+      args: [bin],
+      env,
+      description: this.description,
+    };
+  },
+  tools: [
+    {
+      name: 'jira_search',
+      description: 'Search Jira issues using JQL',
+      input_schema: {
+        type: 'object',
+        properties: {
+          jql: { type: 'string', description: 'JQL query string, e.g. "project = PROJ AND status = Open"' },
+          maxResults: { type: 'number', description: 'Max results to return (default 20)' }
+        },
+        required: ['jql']
+      }
+    },
+    {
+      name: 'jira_get_issue',
+      description: 'Get details of a specific Jira issue',
+      input_schema: {
+        type: 'object',
+        properties: {
+          issueKey: { type: 'string', description: 'Issue key, e.g. PROJ-123' }
+        },
+        required: ['issueKey']
+      }
+    },
+    {
+      name: 'jira_add_comment',
+      description: 'Add a comment to a Jira issue',
+      input_schema: {
+        type: 'object',
+        properties: {
+          issueKey: { type: 'string', description: 'Issue key, e.g. PROJ-123' },
+          body: { type: 'string', description: 'Comment text (plain text)' }
+        },
+        required: ['issueKey', 'body']
+      }
+    },
+    {
+      name: 'jira_edit_issue',
+      description: 'Update fields on a Jira issue (summary, story points, labels, priority)',
+      input_schema: {
+        type: 'object',
+        properties: {
+          issueKey: { type: 'string', description: 'Issue key, e.g. PROJ-123' },
+          fields: { type: 'object', description: 'Object of field names to values, e.g. {"summary": "New title", "customfield_10016": 5}', additionalProperties: true }
+        },
+        required: ['issueKey', 'fields']
+      }
+    },
+    {
+      name: 'jira_transition_issue',
+      description: 'Move a Jira issue to a different status',
+      input_schema: {
+        type: 'object',
+        properties: {
+          issueKey: { type: 'string', description: 'Issue key, e.g. PROJ-123' },
+          transitionId: { type: 'string', description: 'Transition ID to perform. Omit to list available transitions.' }
+        },
+        required: ['issueKey']
+      }
+    }
+  ]
+};

package/src/memory.js

@@ -0,0 +1,124 @@
+/**
+ * Memory Skill
+ *
+ * Provides test memory database tools via MCP (Dolt-backed).
+ * The AI agent can query test history, selector stability, page model,
+ * and navigation patterns from previous runs.
+ *
+ * Activated when ZIBBY_MEMORY=1 (set by `zibby run --mem`).
+ * Returns null from resolve() otherwise, so the framework skips it.
+ */
+
+import { createRequire } from 'module';
+import { execFileSync } from 'child_process';
+import { join } from 'path';
+import { existsSync } from 'fs';
+
+const _require = createRequire(import.meta.url);
+
+function resolveMemoryBin() {
+  if (process.env.MCP_MEMORY_PATH) return process.env.MCP_MEMORY_PATH;
+  try {
+    return _require.resolve('@zibby/mcp-memory/index.js');
+  } catch {
+    return null;
+  }
+}
+
+export const memorySkill = {
+  id: 'memory',
+  serverName: 'memory',
+  allowedTools: ['mcp__memory__*'],
+  envKeys: [],
+  description: 'Zibby Memory MCP Server (test history, selectors, page model)',
+
+  resolve() {
+    if (!process.env.ZIBBY_MEMORY) return null;
+
+    const bin = resolveMemoryBin();
+    if (!bin) return null;
+
+    const dbPath = join(process.cwd(), '.zibby', 'memory');
+    if (!existsSync(join(dbPath, '.dolt'))) return null;
+
+    try {
+      const raw = execFileSync('dolt', ['sql', '-q', 'SELECT COUNT(*) AS cnt FROM test_runs', '-r', 'json'], {
+        cwd: dbPath, encoding: 'utf-8', timeout: 5_000,
+      });
+      const rows = JSON.parse(raw.trim()).rows || [];
+      if (!rows[0] || rows[0].cnt === 0) {
+        console.log('[memory] Database empty — memory tools activate after first completed run');
+        return null;
+      }
+    } catch {
+      return null;
+    }
+
+    return {
+      command: 'node',
+      args: [bin, '--db-path', dbPath],
+      description: this.description,
+    };
+  },
+
+  tools: [
+    {
+      name: 'memory_get_test_history',
+      description: 'Query recent test runs with pass/fail results and timing',
+      input_schema: {
+        type: 'object',
+        properties: {
+          specPath: { type: 'string', description: 'Filter by spec path (substring match)' },
+          limit: { type: 'number', description: 'Max results (default 10)' },
+        },
+      },
+    },
+    {
+      name: 'memory_get_selectors',
+      description: 'Query known selectors for a page with stability metrics',
+      input_schema: {
+        type: 'object',
+        properties: {
+          pageUrl: { type: 'string', description: 'Filter by page URL (substring match)' },
+          limit: { type: 'number', description: 'Max results (default 20)' },
+        },
+      },
+    },
+    {
+      name: 'memory_get_page_model',
+      description: 'Query page structure — elements, roles, selectors',
+      input_schema: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'Filter by page URL (substring match)' },
+          limit: { type: 'number', description: 'Max results (default 20)' },
+        },
+      },
+    },
+    {
+      name: 'memory_get_navigation',
+      description: 'Query known page-to-page transitions',
+      input_schema: {
+        type: 'object',
+        properties: {
+          fromUrl: { type: 'string', description: 'Filter by source URL (substring match)' },
+          limit: { type: 'number', description: 'Max results (default 20)' },
+        },
+      },
+    },
+    {
+      name: 'memory_save_insight',
+      description: 'Save a useful observation for future runs (selector tips, timing, workarounds)',
+      input_schema: {
+        type: 'object',
+        properties: {
+          category: { type: 'string', enum: ['selector_tip', 'timing', 'navigation', 'workaround', 'flaky', 'general'], description: 'Type of insight' },
+          content: { type: 'string', description: 'The insight text — be specific and actionable' },
+          specPath: { type: 'string', description: 'Related spec path' },
+          sessionId: { type: 'string', description: 'Current session ID' },
+        },
+        required: ['category', 'content'],
+      },
+    },
+  ],
+};

package/src/slack.js

@@ -0,0 +1,112 @@
+/**
+ * Slack Skill
+ *
+ * Provides Slack messaging and channel management via MCP.
+ * Requires SLACK_BOT_TOKEN and SLACK_TEAM_ID environment variables.
+ */
+
+export const slackSkill = {
+  id: 'slack',
+  serverName: 'slack',
+  allowedTools: ['mcp__slack__*'],
+  envKeys: ['SLACK_BOT_TOKEN', 'SLACK_TEAM_ID'],
+  description: 'Slack MCP Server',
+
+  resolve() {
+    const env = {};
+    for (const key of this.envKeys) {
+      if (process.env[key]) env[key] = process.env[key];
+    }
+    return {
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-slack@latest'],
+      env,
+    };
+  },
+
+  tools: [
+    {
+      name: 'slack_list_channels',
+      description: 'List public channels in the workspace',
+      input_schema: { type: 'object', properties: {}, required: [] }
+    },
+    {
+      name: 'slack_post_message',
+      description: 'Post a message to a Slack channel or DM',
+      input_schema: {
+        type: 'object',
+        properties: {
+          channel: { type: 'string', description: 'Channel ID or name' },
+          text: { type: 'string', description: 'Message text' }
+        },
+        required: ['channel', 'text']
+      }
+    },
+    {
+      name: 'slack_reply_to_thread',
+      description: 'Reply to a specific message thread',
+      input_schema: {
+        type: 'object',
+        properties: {
+          channel: { type: 'string', description: 'Channel ID' },
+          thread_ts: { type: 'string', description: 'Thread timestamp to reply to' },
+          text: { type: 'string', description: 'Reply text' }
+        },
+        required: ['channel', 'thread_ts', 'text']
+      }
+    },
+    {
+      name: 'slack_add_reaction',
+      description: 'Add an emoji reaction to a message',
+      input_schema: {
+        type: 'object',
+        properties: {
+          channel: { type: 'string', description: 'Channel ID' },
+          timestamp: { type: 'string', description: 'Message timestamp' },
+          reaction: { type: 'string', description: 'Emoji name without colons' }
+        },
+        required: ['channel', 'timestamp', 'reaction']
+      }
+    },
+    {
+      name: 'slack_get_channel_history',
+      description: 'Get recent messages from a channel',
+      input_schema: {
+        type: 'object',
+        properties: {
+          channel: { type: 'string', description: 'Channel ID' },
+          limit: { type: 'number', description: 'Number of messages to return' }
+        },
+        required: ['channel']
+      }
+    },
+    {
+      name: 'slack_get_thread_replies',
+      description: 'Get all replies in a message thread',
+      input_schema: {
+        type: 'object',
+        properties: {
+          channel: { type: 'string', description: 'Channel ID' },
+          thread_ts: { type: 'string', description: 'Thread timestamp' }
+        },
+        required: ['channel', 'thread_ts']
+      }
+    },
+    {
+      name: 'slack_get_users',
+      description: 'List workspace users with basic profiles',
+      input_schema: { type: 'object', properties: {}, required: [] }
+    },
+    {
+      name: 'slack_get_user_profile',
+      description: 'Get detailed profile for a specific user',
+      input_schema: {
+        type: 'object',
+        properties: {
+          user_id: { type: 'string', description: 'Slack user ID' }
+        },
+        required: ['user_id']
+      }
+    }
+  ]
+};