myaiforone 1.0.0

package/registry/skills/platform/opProjectCreate.md

@@ -0,0 +1,239 @@
+---
+name: opProjectCreate
+description: >-
+  Create and execute a cross-agent project from a high-level description. Dialogues to refine scope, breaks down into tasks, creates the project entity with linked agents/artifacts, and optionally kicks off autonomous background execution. Use when a user says "build me a project for X" or "I want to start a new initiative".
+allowed-tools: Read Write Edit Glob Grep Bash
+---
+
+# Project Create & Execute
+
+Take a high-level objective from the user, plan it, create the project, and optionally execute it autonomously.
+
+**Arguments:** User message describes what they want to achieve. Extract the objective, scope, and any specific requirements.
+
+If no description provided, ask: "What do you want this project to achieve?"
+
+---
+
+## Phase 1: Understand & Plan
+
+### Step 1: Extract the Objective
+
+From the user's description, identify:
+- **Project name** — short, descriptive
+- **Description** — 1-2 sentence summary of what this project achieves
+- **Deliverables** — what artifacts, agents, apps, content, or infrastructure will be created
+- **Owner agent** — who owns this project (default: the agent running this skill)
+- **Team members** — other agents that will participate
+
+### Step 2: Break Down into Tasks
+
+Create a task list. Each task should be:
+- **Actionable** — clear what "done" looks like
+- **Ordered** — dependencies respected (can't deploy before building)
+- **Assigned** — which agent will do this task
+- **Sized** — no task should be bigger than a single agent session
+
+Categories to consider for every project:
+- **Build tasks** — create the actual thing (website, app, content, agents)
+- **Platform tasks** — create agents, orgs, register apps
+- **Marketing tasks** — LinkedIn posts, outreach messages, PDFs
+- **Deployment tasks** — Railway, domain setup, DNS
+- **Review task** — final checklist verification (always include this as the last task)
+
+### Step 3: Identify Credentials Needed
+
+Check if the project will need:
+- GitHub token (for repo creation/push)
+- Railway token (for deployment)
+- Namecheap credentials (for domain registration)
+- Resend API key (for email/contact forms)
+- LinkedIn MCP (for posting)
+- Any other API keys or tokens
+
+### Step 4: Present the Plan
+
+Show the user:
+```
+## Project: {name}
+
+**Description:** {description}
+**Owner:** {agent}
+**Team:** {agents}
+
+### Tasks:
+1. {task 1} — {agent} — {priority}
+2. {task 2} — {agent} — {priority}
+...
+N. Project review — verify all deliverables — high
+
+### Credentials Needed:
+- {credential 1}: {what for}
+- {credential 2}: {what for}
+
+### Shall I create this project and start executing?
+```
+
+Wait for user approval before proceeding.
+
+---
+
+## Phase 2: Create the Project
+
+Once approved, execute in this order:
+
+### Step 5: Create the Project Entity
+
+Use the `create_initiative` MCP tool:
+```
+create_initiative(
+  name: "{project name}",
+  description: "{description}",
+  owner: "{owner agent ID}",
+  teamMembers: ["{agent1}", "{agent2}"],
+  plan: "{markdown plan with all tasks as checkboxes}",
+  notes: "{any context, references, or notes from the conversation}"
+)
+```
+
+Save the returned `projectId`.
+
+### Step 6: Create Tasks
+
+For each task, use `create_task`:
+```
+create_task(
+  agentId: "{assigned agent}",
+  title: "{task title}",
+  description: "{detailed description}",
+  priority: "{high|medium|low}",
+  project: "{project-slug}"  // per-agent task board grouping
+)
+```
+
+Save each `taskId`.
+
+### Step 7: Link Tasks to Project
+
+For each task, use `link_to_project`:
+```
+link_to_project(
+  projectId: "{projectId}",
+  type: "task",
+  value: { agentId: "{agent}", taskId: "{taskId}" }
+)
+```
+
+### Step 8: Link Agents to Project
+
+For each team member agent:
+```
+link_to_project(
+  projectId: "{projectId}",
+  type: "agent",
+  value: "{agentId}"
+)
+```
+
+### Step 9: Save Credentials
+
+If credentials were provided, write them to the project's credentials file:
+```
+Path: PersonalAgents/projects/{projectId}/credentials.json
+```
+
+Write only the credentials relevant to this project. Format:
+```json
+{
+  "github_token": "ghp_...",
+  "railway_token": "...",
+  "resend_api_key": "re_..."
+}
+```
+
+### Step 10: Save Context
+
+Write any reference notes, design decisions, or links to:
+```
+Path: PersonalAgents/projects/{projectId}/context.md
+```
+
+Use `update_project` with the `notes` field to update context.
+
+---
+
+## Phase 3: Execute (Optional)
+
+### Step 11: Ask About Execution
+
+Ask the user:
+```
+Project "{name}" is set up with {N} tasks. How would you like to proceed?
+
+1. **Execute now** — I'll work through all tasks in this conversation
+2. **Execute in background** — I'll set up autonomous execution (runs on a schedule, notifies you when done or blocked)
+3. **Manual** — You'll direct me task by task
+```
+
+### If "Execute now" (Option 1):
+Work through tasks sequentially in the conversation. For each task:
+1. Update status to `in_progress` via `update_task`
+2. Execute the task
+3. Update status to `done` via `update_task`
+4. If blocked, update to `blocked` and explain why
+5. Move to the next task
+
+### If "Execute in background" (Option 2):
+Use `execute_project` MCP tool:
+```
+execute_project(
+  projectId: "{projectId}",
+  schedule: "*/15 * * * *",  // or ask user preference
+  reportTo: "slack:{owner's slack channel}"
+)
+```
+
+Report to the user:
+```
+Project is now executing autonomously.
+- Schedule: every 15 minutes
+- Notifications: {channel}
+- To check status: ask me "what's the status of {project name}?"
+- To pause: ask me to pause the project
+```
+
+### If "Manual" (Option 3):
+Report the project is ready and wait for the user to direct.
+
+---
+
+## Phase 4: Review
+
+### Step 12: Final Checklist
+
+When all tasks are done (or user asks for status), run through the review task checklist:
+- Verify each deliverable exists
+- Verify deployments are live
+- Verify agents are created and connected
+- Verify artifacts are linked to the project
+- Report pass/fail for each item
+
+Use `get_project_status` to pull the current rollup.
+
+---
+
+## Quick Reference: MCP Tools Used
+
+| Tool | When |
+|------|------|
+| `create_initiative` | Create the project entity |
+| `create_task` | Create each task |
+| `link_to_project` | Link tasks, agents, orgs, apps, artifacts |
+| `update_task` | Update task status during execution |
+| `update_project` | Update project status, plan, notes |
+| `get_project_status` | Check progress |
+| `execute_project` | Start autonomous background execution |
+| `pause_project` | Pause autonomous execution |
+| `create_agent` | Create agents needed by the project |
+| `add_agent_route` | Connect agents to channels |
+| `create_project` | Create per-agent task board grouping |

package/registry/skills/platform/op_devbrowser.md

@@ -0,0 +1,136 @@
+---
+name: op_devbrowser
+description: Use when controlling a browser programmatically — navigating pages, clicking, filling forms, scraping content, taking screenshots, or automating any web workflow. Trigger when user asks to visit a URL, interact with a site, extract web data, or automate browser tasks.
+allowed-tools: Bash
+---
+
+# op_devbrowser
+
+Control a real Chromium browser from the CLI. Scripts run via `dev-browser` against a persistent background daemon.
+
+## When to Use
+
+- Navigate to a URL and read/interact with its content
+- Scrape headlines, prices, data from any site
+- Fill forms, click buttons, automate web workflows
+- Take screenshots for visual inspection
+- Connect to the user's running Chrome instance
+
+## Quick Start
+
+```bash
+dev-browser <<'EOF'
+const page = await browser.getPage("main");
+await page.goto("https://example.com");
+console.log(await page.title());
+EOF
+```
+
+Named pages (`"main"`, `"login"`, etc.) **persist between runs** — no need to re-navigate.
+
+## Core Browser API
+
+```js
+browser.getPage("name")     // Get or create a named persistent page
+browser.newPage()           // Anonymous page (cleaned up after script)
+browser.listPages()         // All open tabs: [{id, url, title, name}]
+browser.closePage("name")   // Close a named page
+```
+
+## Key Page Methods (Playwright)
+
+```js
+await page.goto("https://...")
+await page.title()
+await page.url()
+await page.click("selector")
+await page.fill("selector", "value")
+await page.press("selector", "Enter")
+await page.waitForSelector(".results")
+await page.waitForURL("**/success")
+await page.textContent("selector")
+await page.evaluate(() => document.body.innerText)  // plain JS only
+```
+
+## AI Snapshot (element discovery)
+
+```js
+const result = await page.snapshotForAI();
+console.log(result.full);
+// Then use page.getByRole("button", { name: "Submit" }).click()
+```
+
+Use `snapshotForAI()` to discover elements on unknown pages. Skip it when you already know selectors.
+
+## Screenshots & File I/O
+
+```js
+// Screenshot
+const buf = await page.screenshot();
+const path = await saveScreenshot(buf, "debug.png");
+console.log(path);  // ~/.dev-browser/tmp/debug.png
+
+// Write / read temp files
+await writeFile("data.json", JSON.stringify(result));
+const raw = await readFile("data.json");
+```
+
+## Sandbox Constraints
+
+Scripts run in QuickJS — NOT Node.js:
+- No `require()` / `import()`
+- No `process`, `fs`, `path`, `fetch`
+- No TypeScript syntax inside `page.evaluate()`
+
+## Connect to Existing Chrome
+
+```bash
+# Auto-discover Chrome with --remote-debugging-port=9222
+dev-browser --connect <<'EOF'
+const tabs = await browser.listPages();
+console.log(JSON.stringify(tabs, null, 2));
+EOF
+
+# Specific endpoint
+dev-browser --connect http://localhost:9222 <<'EOF'
+const page = await browser.getPage("TARGET_ID");
+console.log(await page.title());
+EOF
+```
+
+## CLI Reference
+
+```bash
+dev-browser run script.js          # Run a script file
+dev-browser --headless <<'EOF'     # Headless mode
+dev-browser --timeout 10 <<'EOF'   # Fail fast (default 30s)
+dev-browser status                 # Daemon status
+dev-browser browsers               # List browser instances
+dev-browser stop                   # Stop daemon + all browsers
+dev-browser install                # Install Playwright + Chromium
+dev-browser install-skill          # Install skill into agent dirs
+```
+
+## Common Patterns
+
+**Scrape data:**
+```js
+const page = await browser.getPage("scrape");
+await page.goto("https://news.ycombinator.com");
+const titles = await page.$$eval(".titleline > a", els => els.map(e => e.textContent));
+console.log(JSON.stringify(titles));
+```
+
+**Error recovery:**
+```js
+const page = await browser.getPage("checkout");
+const path = await saveScreenshot(await page.screenshot(), "debug.png");
+console.log(JSON.stringify({ screenshot: path, url: page.url(), title: await page.title() }));
+```
+
+## Tips
+
+- Use short `--timeout 10` so scripts fail fast instead of hanging
+- Keep page names stable (`"login"`, `"results"`) — resume after failures
+- One script = one action. Log state at end for the next decision.
+- `--browser my-project` gives isolated browser state per project

package/registry/skills/platform/sop_brandguidelines.md

@@ -0,0 +1,103 @@
+---
+name: sop_brandguidelines
+description: Apply consistent Anthropic brand identity styling to artifacts including colors, typography, and visual elements. Use when creating branded materials or applying company styling.
+---
+
+# Brand Styling Guide
+
+Apply consistent brand identity guidelines for visual styling of artifacts.
+
+## Brand Elements
+
+### Color Palette
+
+| Name | Hex | Usage |
+|------|-----|-------|
+| Dark | #141413 | Primary text |
+| Light | #faf9f5 | Backgrounds |
+| Orange | #d97757 | Accent |
+| Blue | #6a9bcc | Accent |
+| Green | #788c5d | Accent |
+
+### Typography
+
+**Headings**: Poppins (with Arial fallback)
+- Apply to headings 24pt and larger
+- Clean, modern sans-serif
+
+**Body Text**: Lora (with Georgia fallback)
+- Apply to body copy
+- Elegant serif for readability
+
+### Implementation
+
+The system automatically:
+- Applies Poppins to headings (24pt+)
+- Applies Lora to body text
+- Selects colors based on background context
+- Rotates accent colors for visual variety
+
+### Font Fallbacks
+
+If preferred fonts aren't available:
+- Headings: Arial
+- Body: Georgia
+
+Pre-installation optimizes results, but fallbacks maintain consistency.
+
+## Application Guidelines
+
+### Text Hierarchy
+
+```
+H1: Poppins, 32pt, Dark (#141413)
+H2: Poppins, 24pt, Dark (#141413)
+Body: Lora, 14pt, Dark (#141413)
+```
+
+### Accent Usage
+
+Rotate through accent colors for:
+- Buttons and CTAs
+- Highlights
+- Decorative elements
+- Data visualization
+
+### Background Patterns
+
+- Primary background: Light (#faf9f5)
+- Cards/panels: White (#ffffff) on Light background
+- Dark sections: Dark (#141413) with Light text
+
+### Contrast Requirements
+
+- Ensure sufficient contrast for accessibility
+- Test text on colored backgrounds
+- Use Dark text on Light backgrounds
+- Use Light text on Dark backgrounds
+
+## CSS Variables
+
+```css
+:root {
+  --color-dark: #141413;
+  --color-light: #faf9f5;
+  --color-accent-orange: #d97757;
+  --color-accent-blue: #6a9bcc;
+  --color-accent-green: #788c5d;
+
+  --font-heading: 'Poppins', Arial, sans-serif;
+  --font-body: 'Lora', Georgia, serif;
+}
+```
+
+## Quick Reference
+
+| Element | Font | Size | Color |
+|---------|------|------|-------|
+| H1 | Poppins | 32pt | Dark |
+| H2 | Poppins | 24pt | Dark |
+| H3 | Poppins | 20pt | Dark |
+| Body | Lora | 14pt | Dark |
+| Caption | Lora | 12pt | Dark |
+| Button | Poppins | 14pt | Light on accent |

package/registry/skills/platform/sop_docx.md

@@ -0,0 +1,117 @@
+---
+name: sop_docx
+description: Comprehensive Word document operations - content analysis, document creation, and editing. Use when working with .docx files including reading, creating, or modifying Word documents.
+---
+
+# DOCX Processing Guide
+
+## Core Capabilities
+
+1. **Content Analysis**: Extract text via pandoc or access raw XML for comments, formatting, and metadata
+2. **Document Creation**: Build new .docx files using docx-js library
+3. **Document Editing**: Modify existing files using Python-based Document library for OOXML manipulation
+
+## Reading Documents
+
+### Text Extraction (Simple)
+```bash
+# Convert to markdown - preserves structure and tracked changes
+pandoc document.docx -o document.md
+```
+
+### Raw XML Access
+For comments, formatting, metadata, and complex structures:
+
+```bash
+# Unpack document
+python ooxml/scripts/unpack.py document.docx output_dir/
+```
+
+Key XML files:
+- `word/document.xml` - Main content
+- `word/comments.xml` - Comments
+- `word/styles.xml` - Style definitions
+- `word/settings.xml` - Document settings
+
+## Creating Documents (docx-js)
+
+Read the complete docx-js.md documentation before implementing.
+
+```javascript
+import { Document, Paragraph, TextRun, Packer } from "docx";
+
+const doc = new Document({
+  sections: [{
+    properties: {},
+    children: [
+      new Paragraph({
+        children: [
+          new TextRun("Hello World"),
+          new TextRun({
+            text: "Bold text",
+            bold: true,
+          }),
+        ],
+      }),
+    ],
+  }],
+});
+
+// Save document
+Packer.toBuffer(doc).then((buffer) => {
+  fs.writeFileSync("output.docx", buffer);
+});
+```
+
+## Editing Documents (Python)
+
+### Workflow
+1. Unpack: `python ooxml/scripts/unpack.py document.docx unpacked/`
+2. Edit XML files via Document library API
+3. Repack: `python ooxml/scripts/pack.py unpacked/ edited.docx`
+
+## Tracked Changes (Redlining)
+
+For legal, academic, business, or government documents:
+
+### Principles
+- Make minimal, precise edits
+- Mark only changed text, not entire passages
+- Group changes into batches of 3-10 related modifications
+- Validate after each batch
+
+### XML Structure for Changes
+```xml
+<!-- Insertion -->
+<w:ins w:author="Author" w:date="2024-01-15T10:00:00Z">
+  <w:r><w:t>New text</w:t></w:r>
+</w:ins>
+
+<!-- Deletion -->
+<w:del w:author="Author" w:date="2024-01-15T10:00:00Z">
+  <w:r><w:delText>Removed text</w:delText></w:r>
+</w:del>
+```
+
+## Document Visualization
+
+Convert to images for visual analysis:
+
+```bash
+# DOCX to PDF (LibreOffice)
+soffice --headless --convert-to pdf document.docx
+
+# PDF to JPEG
+pdftoppm -jpeg -r 150 document.pdf page
+```
+
+## Quick Reference
+
+| Task | Tool | Method |
+|------|------|--------|
+| Extract text | pandoc | `pandoc doc.docx -o doc.md` |
+| Read XML | unpack.py | Access raw OOXML |
+| Create new | docx-js | Document + Packer |
+| Edit existing | Python OOXML | Unpack, modify, repack |
+| Track changes | OOXML | `<w:ins>`, `<w:del>` elements |
+| Visualize | LibreOffice + pdftoppm | Convert to images |

package/registry/skills/platform/sop_frontenddesign.md

@@ -0,0 +1,44 @@
+---
+name: frontend-design
+description: Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautifying any web UI). Generates creative, polished code and UI design that avoids generic AI aesthetics.
+---
+
+This skill guides creation of distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices.
+
+The user provides frontend requirements: a component, page, application, or interface to build. They may include context about the purpose, audience, or technical constraints.
+
+## Design Thinking
+
+Before coding, understand the context and commit to a BOLD aesthetic direction:
+
+- **Purpose**: What problem does this interface solve? Who uses it?
+- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
+- **Constraints**: Technical requirements (framework, performance, accessibility).
+- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
+
+**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity.
+
+Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is:
+
+- Production-grade and functional
+- Visually striking and memorable
+- Cohesive with a clear aesthetic point-of-view
+- Meticulously refined in every detail
+
+## Frontend Aesthetics Guidelines
+
+Focus on:
+
+- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font.
+- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes.
+- **Motion**: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise.
+- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
+- **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays.
+
+NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, Arial, system fonts), cliched color schemes (particularly purple gradients on white backgrounds), predictable layouts and component patterns, and cookie-cutter design that lacks context-specific character.
+
+Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices (Space Grotesk, for example) across generations.
+
+**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code with extensive animations and effects. Minimalist or refined designs need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from executing the vision well.
+
+Remember: Claude is capable of extraordinary creative work. Don't hold back, show what can truly be created when thinking outside the box and committing fully to a distinctive vision.