codymaster 4.6.0 → 5.2.0

package/skills/CLAUDE.md

@@ -91,14 +91,14 @@ See: [references/file.md](references/file.md)
 
 ### Required Fields
 - `name`: Unique identifier (lowercase, hyphens for spaces, max 64 chars)
-- `description`: What the skill does and when to use it (max 1024 chars). Use numbered use cases: `(1) ..., (2) ..., (3) ...`
+- `description`: What the skill does and when to use it (max 1024 chars). Prefer **one or two sentences (~80–120 words / under ~800 chars)** so Google Antigravity, Windsurf, and other hosts do not burn customization token budget on discovery. Put long trigger lists in the markdown body (e.g. a short "Triggers" line under the title), not in YAML. Use numbered use cases when helpful: `(1) ..., (2) ..., (3) ...`
 
 ### Recommended Fields (for marketplace)
 - `license`: License name (we use MIT)
 - `metadata.author`: Author/organization name (we use `wondelai`)
 - `metadata.version`: Semantic version
 
-The YAML frontmatter `description` field is critical for skill discovery - it should include keywords and trigger phrases that help match user requests to the skill. Single quotes in YAML values must be escaped by doubling them (`''`).
+The YAML frontmatter `description` field is critical for skill discovery: include the **minimum** keywords needed to route tasks; avoid duplicating every synonym in YAML. For **low token budget** installs, use `bash install.sh --gemini --profile core` and see `skills/profiles/README.md`. Single quotes in YAML values must be escaped by doubling them (`''`).
 
 ## Adding New Skills
 
@@ -129,11 +129,6 @@ The YAML frontmatter `description` field is critical for skill discovery - it sh
 /plugin install systems-architecture@wondelai-skills # DDIA, System Design, Clean Architecture, Release It!, High Performance Browser Networking
 ```
 
-### Via skills.sh
-```bash
-npx skills add wondelai/skills              # All skills
-npx skills add wondelai/skills/{skill-name} # Individual skill
-```
 
 ## Versioning Policy
 

package/skills/_shared/helpers.md

@@ -35,11 +35,6 @@ Read .cm/skeleton-index.md    (~500 tokens) — modules, entry points, config fi
 Query: cm_query(scope="learnings", query="{current module or error type}", limit=5)
    OR read .cm/memory/learnings.json filtered to scope == "global" | "module:X"
 
-# OpenViking backend (if storage.backend: viking in .cm/config.yaml):
-Query: cm_query(query="{current module or error type}", limit=5)
-→ OpenViking uses VECTOR SEMANTIC SEARCH — no need for exact keyword match.
-   "i18n locale update" will also match "translation missing" and "locale fallback"
-
 Rules:
   NEVER  load status = "invalidated"   (proven wrong)
   CAUTION status = "corrected"         (verify before applying)
@@ -64,9 +59,8 @@ cm continuity budget  (or: loadBudget + checkBudget in code)
 > L0 indexes + context bus + scope filter make this possible.
 > Only escalate to L2 when L0/L1 explicitly flag the need.
 >
-> **Viking bonus:** With OpenViking backend, L0/L1 indexes are auto-generated by the engine —
-> no manual `cm continuity index` needed. Vector search also improves Step 3 recall by ~40%.
-> Switch: set `storage.backend: viking` in `.cm/config.yaml`.
+> **Legacy note:** Some older projects may still keep `storage.backend: viking` in config.
+> CodyMaster now routes that back to SQLite, so do not design workflows around a separate Viking backend.
 
 ---
 

package/skills/cm-ads-tracker/SKILL.md

@@ -1,15 +1,12 @@
 ---
 name: cm-ads-tracker
-description: |
-  Expert CRO conversion tracking strategist. From a single chat message, generates a COMPLETE tracking setup: Facebook/Meta Pixel + CAPI, TikTok Pixel + Events API, Google Ads Enhanced Conversions, GTM container architecture, first-touch/last-touch attribution, and cross-channel deduplication.
-
-  AUTO-DETECTS industry and maps correct standard events per platform specs. Outputs a full implementation document developers can use immediately — GTM tags, triggers, variables, dataLayer schema, UTM conventions, CAPI specs — all with the user's exact tracking IDs.
-
-  ALWAYS trigger for: pixel, tracking code, GTM, tag manager, Facebook pixel, Meta pixel, CAPI, Conversions API, TikTok pixel, Events API, Google Ads conversion, Enhanced Conversions, UTM, attribution, first-touch, last-touch, "setup tracking", "install tracking", "install pixel", "measure conversions", "tracking ads", "measure ROAS", "optimize conversions", conversion event, lead tracking, purchase tracking, ROAS measurement. Use even with partial information.
+description: "End-to-end ad conversion tracking: Meta Pixel+CAPI, TikTok Events API, Google Ads Enhanced Conversions, GTM, attribution. Auto-detects industry, maps standard events, outputs a developer-ready implementation doc. Use for pixels, GTM, CAPI, ROAS, or 'set up tracking' requests."
 ---
 
 # CM Ads Tracker v2
 
+**Triggers (non-exhaustive):** pixel, GTM, Meta/Facebook CAPI, TikTok Events API, Google Ads conversions, UTM, first/last-touch attribution, install tracking, lead/purchase events, ROAS.
+
 You are the world's best conversion tracking architect. Your mission: from **a single chat message**, produce a complete, platform-specific, attribution-aware tracking setup that any developer or marketer can implement immediately.
 
 You know by heart every standard event spec for Meta, TikTok, and Google Ads. You think in dataLayer-first architecture, where GTM is the intelligent orchestration layer between the website and all ad platforms.

package/skills/cm-browse/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: cm-browse
+description: "Use when you need visual QA, screenshots, or post-deploy smoke testing through a real browser with Playwright."
+---
+# cm-browse — local Playwright daemon
+
+> **Full runbook:** [docs/browse-daemon.md](../../docs/browse-daemon.md) (install Chromium, token, troubleshooting).
+
+## When to use
+
+- Visual QA, screenshots, post-deploy smoke through a **real browser** (not only Stitch/Pencil).
+- Before claiming “UI works”, drive `cm browse` + `cm qa-visual`.
+
+## CLI
+
+```bash
+export CM_BROWSE_TOKEN="$(openssl rand -hex 24)"
+cm browse start --port 17395 --token "$CM_BROWSE_TOKEN"
+```
+
+## HTTP API (Bearer token)
+
+- `POST /session/start` body `{ "headless": true }`
+- `POST /navigate` `{ "url": "https://…" }`
+- `POST /refs/refresh` — assigns `data-cm-ref` to interactive nodes; use `@e1` style refs.
+- `POST /click` `{ "ref": "e1" }`
+- `POST /fill` `{ "ref": "e2", "value": "text" }`
+- `GET /screenshot` — PNG
+- `GET /console` / `GET /network` — ring buffers
+
+## Integrations
+
+- `cm qa-visual --url …` calls the daemon locally.
+- Pair with `cm-canary` / `cm-safe-deploy` for ship verification.

package/skills/cm-conductor-worktrees/SKILL.md

@@ -0,0 +1,28 @@
+---
+name: cm-conductor-worktrees
+description: "Use when you need to manage parallel git worktrees for isolated feature development."
+---
+# cm-conductor-worktrees — parallel worktrees
+
+## CLI
+
+```bash
+cm conductor add --at ../my-feature-wt --branch feat/my-feature --base main
+cm conductor list
+```
+
+## Practice
+
+- One **branch + worktree** per parallel agent/session.
+- Reconcile with `git merge` / PR; avoid two agents editing the same files without coordination.
+
+## ELI16 (3+ sessions)
+
+When running **three or more** parallel sessions, re-ground each session with:
+
+- Current branch name + worktree path.
+- Last artifact from `cm sprint status` or `.cm/context-bus.json`.
+
+## Future
+
+Dashboard UI for active sprints is **not** in CLI yet — use `cm dashboard` / Hamster UI where available.

package/skills/cm-content-factory/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: cm-content-factory
-description: "AI Content Factory v2.0 — Self-learning content engine with real-time dashboard, multi-agent support, token management, and Content Mastery framework (StoryBrand, Cialdini, SUCCESs, STEPPS, Hook Model, JTBD, CRO, Grand Slam Offers). Interactive onboarding → auto-research → generate → audit → deploy. Config-driven, niche-agnostic, self-improving."
+description: "Self-learning SEO content pipeline: dashboard, multi-agent queue, token budgets, research → write → audit → publish. StoryBrand/Cialdini/JTBD-style frameworks; config-driven. Use for content factory, batch articles, or scaled publishing."
 ---
 
 # CM Content Factory v2.0 — AI Content Machine Platform

package/skills/cm-content-factory/landing/docs/content/changelog.md

@@ -0,0 +1,36 @@
+# Changelog & What's New in v5
+
+Welcome to the **"Neural Spine"** era! Version 5 is a massive milestone that transitions CodyMaster from a specialized "Content Factory" tool into a full-fledged **Senior AI-Native Engineering Workspace**. 
+
+We achieved this paradigm shift by refining CodyMaster into a local-first Smart Spine architecture paired with **OpenSpace** execution.
+
+---
+
+## 🚀 Key Architectural Shifts
+
+### 1. Replaced "Dumb" RAG with Layered Smart Spine Memory
+**The Problem in v4**: AI agents suffered from "code amnesia." Standard Retrieval-Augmented Generation (RAG) relied on chunking text indiscriminately. Agents hallucinated imports and forgot how system components linked together.
+**The v5 Upgrade**:
+By adopting layered retrieval concepts, CodyMaster v5 introduces a structured memory engine built around indexes, SQLite search, and progressive loading. 
+- It creates a **L0 Skeleton Index** of your entire system's structure instantly.
+- It provides a **L1 Symbol Index** to grasp function signatures perfectly without bogging down the LLM context window with implementation details.
+- Your AI agent now acts like a senior dev who inherently "knows" your monolith's entire structure before typing a single line.
+
+### 2. Upgraded to OpenSpace (The Autonomous Executor)
+**The Problem in v4**: Agents were essentially advanced type-writers. They wrote code, but you had to physically run the terminal commands, test the code, read the errors, and paste the errors back to the AI.
+**The v5 Upgrade**:
+We introduced **OpenSpace**—a secure sandbox and execution container. 
+- Agents can now natively execute Bash commands (`npm test`, `git pull`) within a safe holding environment. 
+- The framework auto-captures standard-error (stderr) logs and creates a self-healing loop. If the AI writes a bug, the test suite catches it, and the AI fixes itself autonomously *before* presenting the final code to you.
+
+---
+
+## 🌟 New Features at a Glance
+
+* **100% Zero-Regression Deployments**: Through TDD-first gates in OpenSpace, no commit is permitted unless tests successfully pass.
+* **Context Bus**: An infrastructure pipeline allowing parallel sub-agents (e.g., a "Backend Database" agent and a "Frontend React" agent) to exchange variables and context natively without losing vital token budgets.
+* **Vision & UI Auto-Healing**: Equipped with frontend Playwright capture mechanisms, agents can take screenshots of their code results, run Vision Models to spot CSS un-alignments, and natively fix visual bugs.
+* **Completely Self-Evolving Skills**: The Skill Chain Engine analyzes repeated commands in your workflow and dynamically builds *new* automation skills specifically tailored to your unique codebase.
+
+> [!TIP]
+> **To Experience It Directly:** Try assigning a task requiring multi-file context tracking, such as *"Migrate our authentication endpoints across the monolith to use the new JWT standard."* and watch Smart Spine pull the precise files needed without bloating the context window.

package/skills/cm-content-factory/landing/docs/content/deployment.md

@@ -0,0 +1,46 @@
+# Deployment Guide
+
+Setting up CodyMaster v5 for your engineering team is straightforward. Follow this guide to initialize the Neural Spine architecture.
+
+## 1. Prerequisites
+
+Ensure your environment meets the following requirements:
+- Node.js v18.0.0 or higher
+- Git
+- SQLite-compatible local environment for CodyMaster's default memory stack
+
+## 2. Installation
+
+Install the framework globally via npm to make the `cm` CLI available anywhere on your machine:
+
+```bash
+npm install -g @codymaster/cli@next
+```
+
+## 3. Initializing a Workspace
+
+Navigate to your existing Next.js, React, or Python repository and initialize the OpenSpace environment:
+
+```bash
+cd my-enterprise-project
+cm init
+```
+
+This will automatically:
+1. Generate the `.agent/` folder structure to house specialized skills.
+2. Prepare CodyMaster's local memory and index surfaces so Smart Spine can retrieve project context efficiently.
+
+## 4. Bootstrapping Agents
+
+You can dispatch your first agent task utilizing the full memory and execution layer:
+
+```bash
+cm do "Refactor the user dashboard to utilize Tailwind CSS dark mode variants, ensuring all current unit tests still pass."
+```
+
+- Watch the terminal to see Smart Spine pull relevant context without filling the token window with unnecessary `.json` configs.
+- Watch OpenSpace dynamically spin up `npm run test` immediately after the code generation completes, self-correcting any errors before offering a Git commit.
+
+## Continuous CI/CD (Founders Edition)
+
+For teams on the Founders Edition, CodyMaster integrates directly into your GitHub Actions or GitLab CI pipelines. The agent intercepts failed PRs, pushes self-healing commits, and verifies visual integrity entirely autonomously. 

package/skills/cm-content-factory/landing/docs/content/execution-flow.md

@@ -0,0 +1,67 @@
+# Architecture & Execution Flow
+
+Understanding how the **Neural Spine** processes a command helps you write better instructions and harness the true autonomous power of CodyMaster v5.
+
+When you dispatch a command to the system, it doesn't just blindly pass your text to an LLM. It routes the instruction through a multi-stage **Agent Lifecyle**.
+
+## The High-Level Flow
+
+Here is a visual breakdown of how Smart Spine memory and OpenSpace handle an incoming task:
+
+```mermaid
+graph TD
+    User([User Prompt: "Refactor Authentication"]) ==> Router
+    
+    subgraph "Phase 1: Knowledge Gathering"
+        Router[Task Router] --> Memory{Smart Spine Memory}
+        Memory --> L0[L0: Skeleton Directory Map]
+        Memory --> L1[L1: Symbol Headers]
+        Memory --> L2[L2: Indexed Project Context]
+        L0 --> Compiler[Context Builder]
+        L1 --> Compiler
+        L2 --> Compiler
+    end
+
+    Compiler ==> SubAgent
+    
+    subgraph "Phase 2: Execution (OpenSpace)"
+        SubAgent[AI Sub-Agent] --> Coding[Writes Code / Logic]
+        Coding --> Sandbox[OpenSpace Container]
+        Sandbox --> Bash[Excecutes Terminal/Tests]
+        Bash -- "Fails ❌" --> Feedback[Stderr Log Reader]
+        Feedback --> SubAgent
+    end
+    
+    Bash -- "Passes ✅" --> Review[Frontend Integrity Gate]
+    Review --> Ship((Complete: Ready to Git Push))
+    
+    style User fill:#3b82f6,stroke:#fff,stroke-width:2px,color:#fff
+    style Ship fill:#10b981,stroke:#fff,stroke-width:2px,color:#fff
+    style Memory fill:#8b5cf6,stroke:#fff,stroke-width:2px,color:#fff
+    style Sandbox fill:#f59e0b,stroke:#fff,stroke-width:2px,color:#111
+```
+
+---
+
+## Step-by-Step Walkthrough
+
+### 1. Task Routing & Context Building
+The moment you hit enter, your command is sent to the **Task Router**. Before connecting to an external AI model (like Claude 3.5 or GPT-4o), the router queries **Smart Spine memory**. 
+- Smart Spine uses project indexes and local memory search to find all functionally related files. 
+- It bundles the `L0` (Project Structure), `L1` (Function Interfaces), and `L2` (Implementation Logic) to create a highly compressed, precisely targeted knowledge package.
+
+### 2. Autonomous Execution
+The heavily enriched context is sent to the **AI Sub-Agent**, which formulates the new code. This code is immediately sent into **OpenSpace**. 
+- OpenSpace spins up an isolated sandbox. 
+- It forces the system to run immediate syntax linters (`eslint`, `mypy`) and your existing Unit Tests (`jest`, `pytest`).
+
+### 3. The Self-Healing Loop
+If the execution environment (OpenSpace) returns an error or a failed test:
+- The exact failure trace (`stderr`) is siphoned off and sent *back* to the Sub-Agent. 
+- The AI autonomously rewrites the logic to resolve the bug, attempting again. **You are never interrupted to solve syntax errors.**
+
+### 4. Integrity and Shipping
+Once unit tests cleanly pass, the final validation stage evaluates Frontend Integrity (e.g. no missing padding, proper CSS compilation). Once confirmed, the result is packaged directly into a pristine, working commit for you to review or deploy.
+
+> [!NOTE]
+> All phases within the Execution Flow are entirely handled by the background Neural Spine mechanisms. You are simply engaging with a "Senior Developer" that solves the problem perfectly.

package/skills/cm-content-factory/landing/docs/content/memory-system.md

@@ -0,0 +1,38 @@
+# Layered Memory System
+
+**CodyMaster's Smart Spine memory** is built to keep context retrieval practical, local-first, and honest about what ships today.
+
+## Why this matters
+
+Standard AI workflows often over-rely on blunt keyword search or huge prompt dumps. That creates three predictable problems:
+- agents miss architectural relationships between files
+- token windows fill with low-signal context
+- teams start depending on extra services before the core workflow is even stable
+
+## The CodyMaster approach
+
+CodyMaster uses a layered memory model that combines:
+
+1. **L0 indexes** for fast structural awareness
+2. **SQLite + FTS5** for durable searchable learnings and decisions
+3. **L1/L2 progressive loading** so agents only load richer context when the task actually needs it
+4. **Context Bus** for passing task outputs between skill steps without re-deriving state from chat
+
+## What you get in practice
+
+- Local-first memory with no extra semantic service required
+- Better context targeting than raw grep-only workflows
+- Lower token usage through progressive loading
+- A supportable default setup that works across real projects today
+
+## Recommended setup
+
+The supported CodyMaster path is:
+
+```bash
+npm install
+npm run build
+npm run test:gate:kit
+```
+
+From there, CodyMaster builds and queries context through the shipped Smart Spine stack without requiring a separate semantic service.

package/skills/cm-content-factory/landing/docs/content/openspace.md

@@ -0,0 +1,27 @@
+# OpenSpace Autonomous Workspace
+
+**OpenSpace** is the execution engine of the Neural Spine architecture. It elevates your AI from being merely a static text-generator to an active, real-time engineering participant.
+
+## The Execution Gap
+
+Most AI setups lack operational agency. Once an LLM outputs code, a human developer has to copy, paste, save, format, compile, and run tests. This process introduces massive friction and manual error into what should be an automated loop.
+
+## Enter OpenSpace
+
+OpenSpace surrounds the agent with a secure execution container (sandbox) tightly coupled with your source control and operational tools. 
+
+### Key Capabilities
+
+- **Command Line Autonomy**: The agent can run raw terminal commands (`npm i`, `pytest`, `cargo run`) to verify that the code it generates compiles and passes logic tests.
+- **Visual Self-Correction**: Using Playwright/Puppeteer bindings, OpenSpace can take screenshots of running frontends, parse the UI using Vision models, and autonomously adjust CSS alignments or missing padding without human intervention.
+- **The Secret Shield**: OpenSpace filters shell execution to prevent agents from inadvertently deleting local databases, exposing secrets (via `.env` blockades), or committing raw tokens to GitHub.
+
+## Anatomy of a Session
+
+When an agent is initialized in OpenSpace, it acts as a headless developer:
+1. It pulls focused context from the **[Layered Memory System](#memory-system)**.
+2. It drafts a solution to isolated branch files.
+3. It spawns an OpenSpace terminal subprocess to run Linters and Unit Tests.
+4. If a test fails, it captures the `stderr` output within OpenSpace and self-heals the code until all checks pass.
+
+This loop ensures that the code pushed to you is robust, tested, and fully autonomous.

package/skills/cm-content-factory/landing/docs/content/use-cases.md

@@ -0,0 +1,26 @@
+# Neural Spine Use Cases
+
+The true power of **CodyMaster v5** is fully realized when integrating semantic memory and autonomous execution together. 
+
+Here are the optimal scenarios where the Founders Edition architecture outperforms standard tools.
+
+## 1. Full-Stack Monolithic Refactoring
+*The Challenge*: Changing an authentication provider or modifying deeply nested CSS logic across a massive 500,000-line React/Node.js monolith usually incites dozens of cascading regressions.
+*The Spine Solution*:
+- **Smart Spine memory** maps where the legacy authentication logic touches every API router through indexes and searchable project memory.
+- **OpenSpace** attempts the refactor in an isolated branch and continuously runs the test suite.
+- The outcome is a tightly controlled refactoring PR that didn't miss a single edge case.
+
+## 2. Zero-Drop Multilingual Deployments
+*The Challenge*: Localizing an application across EN, VI, ZH, and RU requires massive JSON string coordination, structural UI checks (text length variances), and routing configuration.
+*The Spine Solution*:
+- A translation skill is dispatched across multiple parallel agents.
+- Instead of manual checks, OpenSpace spins up a staging server and runs Visual Regression Tests using Vision models to verify that the Russian text doesn't break button layouts.
+- It automatically shifts paddings based on the visual output before committing.
+
+## 3. Immediate Tech-Debt Cleanup
+*The Challenge*: Teams accrue dead code, unused imports, and unoptimized queries over years of product pivots.
+*The Spine Solution*:
+- An agent equipped with the `cm-clean-code` skill natively runs over the codebase at midnight via cron job.
+- OpenSpace runs AST-aware checks against CodyMaster's indexed project context to guarantee no unused code is actually being referenced dynamically.
+- The agent creates a PR each morning with a detailed breakdown of the removed complexity and the token savings achieved.

package/skills/cm-content-factory/landing/docs/content/v5-intro.md

@@ -0,0 +1,28 @@
+# The Neural Spine Architecture
+
+Welcome to **CodyMaster v5**, the first Senior AI-Native Engineering Workspace designed for complete autonomous development.
+
+While standard AI coding assistants excel at generating functions and isolated scripts, they lack the systemic awareness required to build, test, and ship complete applications securely. **CodyMaster v5** introduces the "Neural Spine" architecture to solve this.
+
+## Why a "Spine"?
+
+A spine connects the brain to the nervous system, passing critical signals instantly and maintaining the structure of the body. In CodyMaster v5, the **Neural Spine** represents the underlying infrastructure that connects your AI agents to the real world:
+
+- **Memory (Smart Spine)**: Layered local-first retrieval using SQLite, indexes, and progressive loading.
+- **Execution (OpenSpace)**: A sandboxed, secure environment for agents to run bash commands, databases, and testing suites.
+- **State (Context Bus)**: A fluid mechanism to exchange parameters between specialized subagents without overflowing token limits.
+
+## Core Capabilities
+
+1. **Eliminating Context Drift**: Your agents no longer guess your architecture. They retrieve the exact structural context through Smart Spine indexes and focused memory queries.
+2. **Zero-Regression Shipping**: OpenSpace guarantees that AI-generated code is thoroughly tested (TDD-first) via automated gates before reaching production.
+3. **Multi-Agent Orchestration**: Outsource frontend, backend, and security audits to specialized subagents running in parallel.
+
+## Getting Started
+
+Explore the backbone technologies driving this paradigm shift:
+
+- [Explore Layered Memory](#memory-system)
+- [Understand OpenSpace Containers](#openspace)
+- [Real-world Use Cases](#use-cases)
+- [Deploy the Framework](#deployment)