openclaw-plugin

Deploy a static folder to Cloudflare Pages and bind a *.trespies.dev custom domain — including the two gotchas that cost real time: wrangler's OAuth login CANNOT attach custom domains (you need a scoped API token) and attaching a domain does NOT auto-create its DNS record (you must create the proxied CNAME yourself). Use when "deploy to trespies.dev", "ship this to Cloudflare Pages", "bind a custom subdomain", "publish the POC", or as Phase 4 of poc-tool-forge.

Build ONE self-contained, deployable single-page index.html in the TresPies "official-document" house style (the ip-scout aesthetic) — cream paper, serif/mono, seeded determinism, a landing→artifact flow, a load-bearing general-wellness/regulatory guardrail, and real-data baking when a credible source exists. Use when "build a house-style tool", "make a trespies-poc page", "single-page POC to the ip-scout look", or as Phase 2 of poc-tool-forge.

End-to-end pipeline to turn an idea into a live single-page TresPies POC tool — source/pick an idea (Build Forge brief or operator concept), build it to the house design system, browser-verify, deploy to *.trespies.dev, and document. Use when the operator says "build a POC tool", "make something from the brief", "ship a new trespies-poc tool", "spin up a landing demo", "check trespies-poc for ideas", or "/poc-tool-forge". Orchestrates the house-poc-builder, static-tool-verify, and cf-pages-trespies-deploy skills.

Browser-verify a self-contained single-page tool before shipping — start it via .claude/launch.json, exercise the core mechanic, assert zero console errors, screenshot, and catch the content/logic bugs (seasonal incoherence, misleading severity labels, dead interactions) that pass a syntax check but fail a human. Use when "verify the tool", "check the page before deploy", "browser-test this POC", or as Phase 3 of poc-tool-forge. Never trust an agent's self-report of "done".

Builds production-ready remote MCP servers on Cloudflare Workers with typed tools, OAuth authentication, and Wrangler deployment. Use when: "build MCP server on Cloudflare", "remote MCP", "deploy MCP to Workers", "MCP OAuth authentication", "expose tools via MCP".

Scaffolds production-ready MCP servers from OpenAPI specs with schema validation, named tool definitions, and versioning strategy. Use when: "build MCP server from API", "create tool server from OpenAPI", "expose REST API to LLM agent", "scaffold MCP from spec", "convert API contract to tools".

Produces structured research documents or implementation handoffs by searching external sources — library docs, web, APIs — for a given topic. Use when: "research how to use [library]", "find best practices for [topic]", "compare [options]", "look up [API/framework] documentation". NOT for codebase exploration (use project-exploration for that).

Routes user goals to the appropriate specialist agent workflow with resource allocation confirmation. Use when: the user wants to start a task but hasn't specified a workflow, asks "how should I approach this?", or needs orchestration across research → plan → build → fix stages.

Split large tasks into independent parallel tracks to maximize velocity. Use when coordinating multiple parallel development streams or organizing dependent tracks. Trigger phrases: 'split into parallel tracks', 'organize these tracks', 'phased parallelism', 'coordinate parallel development', 'define track dependencies'.

Teach peers by sharing your learning journey and creating shared practice, not instruction. Use when documenting knowledge or helping another agent grow. Trigger phrases: 'teach this the agent-to-agent way', 'share what I learned without sounding expert', 'make this memorable and saveable', 'give permission not just knowledge'.

Distill long conversation histories into potent memory artifacts using semantic compression. Use at end of sessions to preserve wisdom while reducing context load. Trigger phrases: "compress this context", "distill this conversation", "create a memory artifact", "condense this history", "extract key wisdom".

Create actionable plans deeply grounded in uploaded files. Use when creating plans from specs, docs, code, or research. Trigger phrases: 'create a plan from this spec', 'analyze these files', 'plan the refactoring', 'what's next from these docs', 'extract action items'.

Record architectural decisions at source and propagate their effects through all dependent documents. Use when decisions arrive that answer open questions or change scope. Trigger phrases: 'propagate this decision through the system', 'trace where this decision echoes', 'update the status file last', 'this decision changes the scope—where else must it flow'.

Audit project documentation to identify and correct drift, ensuring all documents are accurate and reflect current codebase state. Use when documentation feels stale, after major releases, before onboarding new team members, or to combat documentation drift. Trigger phrases: 'docs seem out of date', 'audit the documentation', 'is the README accurate', 'check for broken links and outdated info', 'review docs for accuracy'.

Architect multi-release eras with shared vocabulary, architectural constraints, and design language for conceptual coherence. Use when planning major product pivots across multiple releases, defining conceptual architecture before decomposing into releases, or transitioning between product eras. Trigger phrases: 'plan this era', 'define the architecture for multiple releases', 'transition to a new era', 'create a multi-release vision', 'establish conceptual coherence across releases'.

Apply flexible principles and patterns for intuitive file organization adapted to project context. Use when starting new projects or refactoring disorganized structures. Trigger phrases: "organize this project structure", "plan a file layout", "design a directory hierarchy", "improve folder organization", "create a project structure".

Write production-ready frontend specifications deeply grounded in existing backend architecture to prevent integration issues. Use when building frontend features on a working backend or redesigning UI for an existing API. Trigger phrases: 'spec the frontend', 'write frontend spec from backend', 'ground the UI in this API', 'integrate this frontend', 'frontend implementation guide'.

Hand off work between agents cleanly, preserving all context and enabling autonomy. Use when one agent completes work and another must begin. Trigger phrases: 'prepare this for handoff', 'hand off to the implementation agent', 'is this handoff package complete', 'ensure nothing is lost in the transition'.

Conduct comprehensive health audits on software repositories, generating actionable engineering tasks and permanent audit trails. Use when you need a repo health check, want to identify technical debt and blockers, are onboarding to a new codebase, or need a baseline assessment before major work. Trigger phrases: 'audit this repo', 'is this codebase healthy', 'what are the health issues', 'run a full health check', 'identify blockers and debt'.

Transform specifications into structured implementation prompts for autonomous execution. Use when preparing to commission agents or converting specs into execution-ready prompts. Trigger phrases: 'write implementation prompt', 'commission this spec', 'convert spec to prompt', 'prepare for implementation', 'create the execution plan'.

Iterate through scouting cycles by gathering feedback, identifying reframes, and re-scouting with new lenses. Use when initial scouting raises deeper questions. Trigger phrases: 'scout this, gather feedback, then re-scout', 'what is the reframe hiding in this feedback', 'iterate the scout', 'two-scout rule'

Write structured memory entries following the 4-Tier Context Iceberg for efficient context management. Use when recording daily learnings, documenting decisions, or extracting seeds. Trigger phrases: "write a memory entry", "record this learning", "save this to memory", "create a context artifact", "document this insight".

Design a coherent multi-surface strategy where desktop, mobile, and web each have unique complementary roles. Use when planning multiple surfaces or adding a new platform. Trigger phrases: 'design the multi-surface strategy', 'map surfaces to contexts not devices', 'what is each surface uniquely good at', 'define the handoffs between surfaces'.

Learn at the pace of understanding rather than expectation, prioritizing depth over speed. Use when learning something new, feeling overwhelmed, trying to catch up, or managing context overload. Trigger phrases: 'I need to learn this slowly', 'I feel overwhelmed by the amount', 'help me learn patiently', 'I need depth not speed', 'I'm trying to catch up'.

Route file-based planning tasks intelligently to specialized modes. Use when creating plans from uploaded specs, docs, code, or research. Trigger phrases: 'create a plan from these files', 'analyze these docs', 'synthesize these papers', 'plan from specs', 'what should I do with these files'.

Verify specifications are ready before commissioning implementation agents. Use as a quality gate before handoff, to catch spec-to-codebase drift, or before parallel track execution. Trigger phrases: 'verify the spec', 'pre-commission check', 'track 0 alignment', 'ready to commission', 'verify spec-to-code'.

Transform valuable workflows into reusable skills through documentation and structured conversion. Use after completing complex multi-step tasks you'll repeat. Trigger phrases: "turn this process into a skill", "standardize this workflow", "make this repeatable", "capture this procedure", "formalize this multi-step task".

Reframe binary product decisions by discovering what a product is uniquely good at. Use when stuck between keep/kill choices. Trigger phrases: 'reframe this binary decision', 'what is this uniquely good at', 'find the complement not the competition', 'is this really a binary choice', 'unlock the positioning opportunity'.

Explore a new project's philosophy and patterns before committing to collaboration. Assess architecture fit, map resonances, and identify entry points. Use when encountering a new codebase, repository, or project. Trigger phrases include 'explore this project', 'assess this codebase', 'should we collaborate on this', 'onboard me to this repo', 'evaluate this project for fit'.

Write production-ready, A+ quality specifications for software releases. Use when planning a release, designing system architecture, or commissioning work to an autonomous agent. Trigger phrases: 'write a release spec', 'spec this feature', 'create a release specification', 'design the architecture', 'ground this in the codebase'.

Efficiently sync and extract context from GitHub repositories for grounding architectural, design, and orchestration work. Use when exploring codebases, starting refactoring or architecture conversations, tracking changes between sessions, or before writing implementation prompts. Trigger phrases: 'sync the repo', 'what changed in the codebase', 'clone this repository', 'extract context from', 'understand the repo structure'.

Generate comprehensive living status documents for software repositories combining filesystem exploration, semantic clustering, file importance ranking, and health assessment. Use when understanding codebases, auditing repos, creating system maps, assessing health, or onboarding to projects. Trigger phrases: 'give me a complete repo overview', 'understand this codebase', 'what does this repo do', 'create a system map', 'audit this repository', 'build a mental model'.

Conduct deep and wide research using structured approaches for investigating topics and synthesizing findings. Use when making informed decisions, exploring problem spaces, evaluating complex systems, or planning features. Trigger phrases: 'research this topic deeply', 'do a wide scan of the landscape', 'explore the competitive space', 'investigate and synthesize', 'understand before deciding'.

Synthesize multiple research files into actionable insights through cross-referencing and pattern identification. Use when you have 3+ sources on a topic, need a literature review, consolidating notes from multiple sources, or understanding topics from multiple angles. Trigger phrases: 'synthesize these research files', 'find patterns across sources', 'consolidate these notes', 'create a literature review', 'understand by synthesizing'.

Conduct structured post-sprint retrospectives for continuous improvement and learning harvest. Use after major releases, significant milestones, or when projects feel stuck. Trigger phrases: 'do a retrospective', 'what did we learn', 'reflect on this release', 'harvest the learnings', 'what went well and what was hard'.

Extract and document reusable patterns from experiences using evidence-based frameworks. Use after projects or when patterns emerge across contexts. Trigger phrases: "extract the learnings", "document this pattern", "turn this into a seed", "what can we learn from this", "capture this insight".

Access and apply the 10 Dojo Seed Patches plus 3 field seeds as reusable thinking modules. Use when architecting systems, optimizing costs, debugging complex issues, or grounding ecosystem-level work. Trigger phrases include "which seed applies here", "suggest a seed pattern", "apply a seed to this", "what pattern should we use", "load the seed library".

Elevate a frequently-used Dojo Seed into a fully-fledged reusable Skill with templates and workflows. Use when a seed has proven value and describes a repeatable process. Trigger phrases: "promote this seed to a skill", "convert this seed into a skill", "make this seed into a skill", "formalize this pattern", "turn this seed active".

Map software system capabilities using action-verb clusters that group components by what they DO rather than where they live. Produces behavioral architecture revealing capabilities, gaps, and architectural confusion. Use when you need to understand what a codebase does, explain a system to others, plan refactors, audit feature coverage, or understand cross-cutting concerns. Trigger phrases: 'what does this app actually do', 'walk me through the features', 'what are the main capabilities', 'map the system architecture', 'understand this codebase'.

Audit all skills in a repository to assess completeness and upgrade incomplete skills to quality standards. Use when you've created many new skills, before a major release, to maintain ecosystem consistency, or to improve skill usability. Trigger phrases: 'audit all the skills', 'upgrade skills to A+ standard', 'check skill quality and completeness', 'are the skills production-ready', 'improve the skills ecosystem'.