pack-engineering

Clawdi Knowledge Work Plugins

Modular knowledge-work plugins for OpenClaw with dynamic service discovery.

The system consists of a router plugin that discovers available services in your environment, and pack plugins that provide role-specific skills (sales, recruiting, marketing, etc.).

Quick Start

1. Clone and install:

git clone <repo-url>
cd clawdi-plugins
pnpm install

2. Deploy to your OpenClaw extensions directory:

./scripts/deploy.sh /data/openclaw/extensions

This builds all packages, copies them with correct plugin ID directory names, and installs runtime dependencies.

3. Enable in your openclaw.json:

{
  "plugins": {
    "knowledge-work-router": { "enabled": true },
    "pack-sales": { "enabled": true },
    "pack-productivity": { "enabled": true }
  }
}

4. Restart the agent and run /connect_apps to discover and connect services.

Available Packs

| Pack | Skills | What It Does | |------|--------|-------------| | sales | 8 | Meeting prep, CRM updates, follow-ups, research | | productivity | 4 | Calendar management, task tracking, email triage | | recruiting | 4 | Pipeline management, interview prep, offers | | marketing | 8 | Campaign planning, SEO, content, analytics | | operations | 9 | Process management, reporting, documentation | | customer-support | 5 | Ticket triage, knowledge base, escalation | | engineering | 6 | Sprint planning, code review prep, incident response | | enterprise-search | 4 | Cross-system search, knowledge retrieval | | human-resources | 7 | Reviews, comp analysis, onboarding, policy | | product-management | 8 | Roadmap, specs, user research, metrics |

Total: 63 skills across 10 packs

Connecting Services

Run /connect_apps to see what services are available in your environment:

/connect_apps

The router dynamically discovers services from:

Composio — SaaS integrations (Google Workspace, HubSpot, Slack, etc.)
Built-in OpenClaw tools — Native tools (web_search, read_file, etc.)
Lobster workflows — Multi-step orchestrated flows
CLI tools — Local binaries (pandoc, jq, etc.)
MCP servers — Any configured MCP server tools

No hardcoded service list — the router adapts to whatever you have connected.

Configuration

Plugin Enable/Disable

In openclaw.json (plugin IDs are unscoped — no @clawdi-ai/ prefix):

{
  "plugins": {
    "knowledge-work-router": { "enabled": true },
    "pack-sales": { "enabled": true },
    "pack-recruiting": { "enabled": false }
  }
}

Router Config

{
  "plugins": {
    "knowledge-work-router": {
      "enabled": true,
      "config": {
        "adapterOrder": ["composio", "openclaw_tool", "lobster", "cli", "mcporter"],
        "disabledAdapters": [],
        "sideEffectPolicy": "confirm_destructive",
        "cacheTtl": 600000,
        "capabilityPins": {
          "seo.*": "mcporter"
        },
        "cliMappings": {
          "docs.convert_*": "pandoc",
          "data.query_*": "jq"
        }
      }
    }
  }
}

| Field | Description | Default | |-------|-------------|---------| | adapterOrder | Fallback order for adapter probing | All 5 in order | | disabledAdapters | Adapters to skip entirely | [] | | sideEffectPolicy | always_confirm, confirm_destructive, never_confirm | confirm_destructive | | cacheTtl | Discovery cache TTL in ms | 600000 (10 min) | | capabilityPins | Pin capabilities to specific adapters | {} | | cliMappings | Map capability patterns to CLI binaries | {} |

Checking Status

/check_setup

Shows the status of all capabilities across all installed packs, which adapter resolves each one, and which adapters are enabled.

---

Architecture

Pack Skill → capability_execute tool
                    ↓
               Router.resolve()
                    ↓
          DiscoveryEngine.resolve()
                    ↓
      Probe adapters in fallback order:
        Composio → OpenClaw Tool → Lobster → CLI → MCPorter
                    ↓
           Cache result, execute via adapter

The DiscoveryEngine probes each adapter asking "can you handle this capability?" Adapters search their runtime (Composio's search API, MCP server tool lists, built-in tool names, Lobster workflow registry, PATH binaries) and return a probe result or null.

The router also supports filesystem-based pack discovery — if the plugin API registry is unavailable, it scans /data/openclaw/extensions/pack-* for pack directories.

Creating a Pack

1. Create directory: packages/pack-yourpack/ 2. Add pack-manifest.yaml:

packId: yourpack
displayName: "Your Pack"
capabilities:
  required:
    - calendar.read_events
  optional:
    - docs.create_brief
preferredApps:
  calendar.*:
    - google_workspace
onboarding:
  welcomeMessage: "Your pack is ready."
  suggestedFirstTask: "Try: 'do something cool'"

3. Add skills in skills/your-skill/SKILL.md 4. Add openclaw.plugin.json (use unscoped ID):

{
  "id": "pack-yourpack",
  "name": "Your Pack",
  "description": "Description of your pack",
  "version": "0.1.0",
  "skills": ["./skills"]
}

5. Add src/index.ts to register slash commands. Command handlers return { text: "..." }:

export function register(api: any) {
  api.registerCommand({
    name: "your_command",
    description: "Does something useful",
    handler: async () => {
      return { text: "Command output here" };
    },
  });
}

6. Add tsconfig.json:

{
  "extends": "../../tsconfig.base.json",
  "compilerOptions": { "outDir": "dist", "rootDir": "src" },
  "include": ["src"],
  "exclude": ["src/__tests__"]
}

7. Run ./scripts/deploy.sh to deploy all plugins, or manually copy the built pack to /data/openclaw/extensions/pack-yourpack and run npm install --omit=dev --ignore-scripts --legacy-peer-deps if it has runtime dependencies. Enable in openclaw.json.

Pack Manifest Reference

All fields for pack-manifest.yaml:

| Field | Type | Required | Description | |-------|------|----------|-------------| | packId | string | yes | Unique pack identifier | | displayName | string | yes | Human-readable name | | capabilities.required | string[] | yes | Capabilities the pack needs to function (keep minimal — only free/universally available) | | capabilities.optional | string[] | yes | Capabilities that enhance the pack (paid integrations go here) | | preferredApps | Record\<pattern, string[]\> | no | Preferred app/toolkit per capability pattern | | fallbackOverrides | Record\<pattern, {adapters}\> | no | Override adapter order for specific capabilities | | preferences | Record\<string, PackPreference\> | no | User-configurable preferences captured at first use or onboarding | | sideEffects | string[] | no | Capabilities that should always be treated as side-effects | | onboarding.welcomeMessage | string | yes | Shown when pack is first activated | | onboarding.suggestedFirstTask | string | yes | Suggested prompt to try |

How Discovery Works

Each adapter implements probe() and execute():

Composio: Calls COMPOSIO_SEARCH_TOOLS with the capability's intent string. Returns the best matching toolkit and action.
OpenClaw Tool: Matches the capability's verb_noun against built-in tool names. Exact match only.
Lobster: Matches capabilities with _workflow suffix against registered Lobster workflows.
CLI: Checks cliMappings config for pattern match, then verifies binary exists via which.
MCPorter: Scans all configured MCP server tool lists for keyword matches.

Results are cached for 10 minutes (configurable). Cache is invalidated on execution failure.

Adding an Adapter

To add a new adapter:

1. Create src/adapters/your-adapter.ts implementing CapabilityAdapter:

probe(capabilityId, intent, hints?) — return a ProbeResult if you can handle this capability, or null
execute(capabilityId, providerDetails, args, packId) — run the capability using the details from your probe result

2. Register it in src/index.ts — add to the adapters array 3. Add its ID to the adapterOrder enum in openclaw.plugin.json 4. Write tests in src/__tests__/your-adapter.test.ts

The probe() method should be fast (no side-effects, <5s). Return connectionReady: false with a setupHint if the service needs configuration.

Deployment

Deploy Script

The scripts/deploy.sh script automates deployment following OpenClaw conventions:

# On the remote machine
git clone <repo-url> /root/.openclaw/clawdi-plugins
cd /root/.openclaw/clawdi-plugins
pnpm install
./scripts/deploy.sh /data/openclaw/extensions

The script:

Builds all packages
Reads each plugin's id from openclaw.plugin.json
Copies only deployment files (dist/, package.json, openclaw.plugin.json, skills/, pack-manifest.yaml)
Installs runtime dependencies per-plugin (npm install --omit=dev --ignore-scripts --legacy-peer-deps)
Safe to re-run — replaces each plugin directory on every run

To deploy a subset of packs, copy only the desired pack directories manually after building, or modify plugins.allow in openclaw.json to control which plugins load.

Plugin ID Convention

OpenClaw uses unscoped plugin IDs. The directory name under /data/openclaw/extensions/ should match the id field in openclaw.plugin.json:

/data/openclaw/extensions/
  knowledge-work-router/    → id: "knowledge-work-router"
  pack-sales/               → id: "pack-sales"
  pack-marketing/           → id: "pack-marketing"

Development

pnpm install          # Install dependencies
pnpm build            # Build all packages
pnpm test             # Run all tests

Monorepo layout:

packages/ router/ # Knowledge work router plugin (id: knowledge-work-router) pack-sales/ # Sales pack (id: pack-sales) pack-productivity/ # Productivity pack (id: pack-productivity) ... # 8 more packs docs/ superpowers/ # Specs and plans

Summary

Install to Claude Code