### Install GitBook API SDK

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-gitbook/SKILL.md

Installs the official @gitbook/api TypeScript SDK using npm. This is the first step to interacting with the GitBook API programmatically.

```bash
npm install @gitbook/api
```

--------------------------------

### Manual Skill Installation

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/README.md

Provides examples for manually installing a skill by copying or symlinking a skill directory into an agent's designated skills location. This method is an alternative to using CAAMP.

```bash
# Claude Code
cp -r skills/ct-gitbook ~/.claude/skills/ct-gitbook

# Codex
cp -r skills/ct-gitbook .agents/skills/ct-gitbook

# Copilot (VS Code)
cp -r skills/ct-gitbook .github/skills/ct-gitbook
```

--------------------------------

### Installation via CAAMP

Source: https://context7.com/kryptobaseddev/cleo-skills/llms.txt

Instructions for installing skills using the CAAMP tool.

```APIDOC
## Installation via CAAMP

```bash
# Install a specific skill via CAAMP (recommended)
caamp skills install /path/to/cleo-skills/skills/ct-gitbook
```
```

--------------------------------

### CI/CD Integration Patterns

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-gitbook/SKILL.md

Examples of CI/CD workflows for validating documentation structure and triggering synchronization.

```APIDOC
## CI/CD Integration Patterns

### GitHub Actions — Validate Docs Structure

This workflow validates the structure of your documentation by checking links in `SUMMARY.md` before merging a pull request.

```yaml
name: Validate Docs
on:
  pull_request:
    paths:
      - 'docs/**'

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Check SUMMARY.md links
        run: |
          while IFS= read -r link; do
            if [ ! -f "docs/$link" ]; then
              echo "Broken link: $link"
              exit 1
            fi
          done < <(grep -oP '\[.*?\]\(\K[^)]+' docs/SUMMARY.md)
          echo "All links valid"
```

### GitHub Actions — Trigger Sync

This workflow demonstrates a push trigger for syncing to GitBook. Note that GitBook auto-syncs via the GitHub App, so this workflow is primarily for validation.

```yaml
name: Sync to GitBook
on:
  push:
    branches: [main]
    paths:
      - 'docs/**'

jobs:
  sync:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: echo "GitBook auto-syncs via GitHub App — no manual trigger needed"
      # The GitBook GitHub App handles sync automatically.
      # This workflow is for additional validation only.
```

### Pre-commit Hook

This bash script can be used as a pre-commit hook to validate documentation links before committing changes.

```bash
#!/usr/bin/env bash
# .git/hooks/pre-commit — validate docs before commit
if git diff --cached --name-only | grep -q '^docs/'; then
  if [ -f docs/SUMMARY.md ]; then
    grep -oP '\[.*?\]\(\K[^)]+' docs/SUMMARY.md | while read -r link; do
      [ -f "docs/$link" ] || { echo "Broken: $link"; exit 1; }
    done
  fi
fi
```
```

--------------------------------

### Manage GitBook Content with TypeScript SDK

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-gitbook/SKILL.md

Provides examples of managing content within a GitBook space using the TypeScript SDK. Operations include listing page trees, searching content, and importing content from a Git repository. Requires an initialized GitBook client and a space ID.

```typescript
// Get page tree
const content = await client.spaces.listPagesInSpace(spaceId);

// Search
const results = await client.spaces.searchSpaceContent(spaceId, {
  query: 'authentication',
});

// Import from Git
await client.spaces.importContentInSpace(spaceId, {
  source: { type: 'github', url: 'https://github.com/org/repo' },
});
```

--------------------------------

### Install Skill from CLEO SkillsMP

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-skill-lookup/SKILL.md

Illustrates how to install a skill from the SkillsMP marketplace using the CLEO CLI. The `--force` option can be used to overwrite an existing installation.

```bash
cleo skills install ct-code-reviewer --source skillsmp
cleo skills install ct-code-reviewer --source skillsmp --force
```

--------------------------------

### Install Recommended Skill Profile (CLI)

Source: https://context7.com/kryptobaseddev/cleo-skills/llms.txt

Installs the recommended skill profile using the CAAMP CLI. CAAMP handles versioning, validation, and symlink creation automatically.

```bash
caamp skills install-profile recommended
```

--------------------------------

### Install Skill using Skill Installer

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/docs/agent-skills.md

This command installs a skill from a specified folder using the `$skill-installer` command-line tool. It is used to add custom or experimental skills to Codex.

```bash
$skill-installer install the linear skill from the .experimental folder
```

--------------------------------

### Cleo Skills CLI Commands

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/docs/DEVELOPER-GUIDE.md

Commands for interacting with Cleo Skills, including listing profiles, protocols, and installing skills. The install command can take a profile name or a specific skill name, automatically handling dependencies.

```bash
# List install profiles
ct-skills profiles

# List available protocols
ct-skills protocols

# Install skills (requires CAAMP)
ct-skills install --profile recommended
ct-skills install ct-documentor  # installs + dependencies
```

--------------------------------

### List, Get, and Resolve Profiles

Source: https://context7.com/kryptobaseddev/cleo-skills/llms.txt

Manage installation profiles, which are predefined sets of skills. This includes listing available profiles, retrieving the definition of a specific profile, and resolving a profile to its complete list of skills, including inherited ones and their dependencies.

```APIDOC
## listProfiles, getProfile, and resolveProfile

### Description
Work with install profiles for bundled skill sets. Profiles support inheritance via `extends` and automatically resolve skill dependencies.

### Method
GET (Implicit)

### Endpoint
N/A (Function calls within the library)

### Parameters
#### Query Parameters
- **profileName** (string) - Required (for `getProfile` and `resolveProfile`) - The name of the profile to retrieve or resolve.

### Request Example
```javascript
const { listProfiles, getProfile, resolveProfile } = require('@cleocode/ct-skills');

// List available profiles
const profiles = listProfiles();
console.log(profiles);

// Get profile definition
const recommendedProfile = getProfile('recommended');
console.log(JSON.stringify(recommendedProfile, null, 2));

// Resolve profile to full skill list (follows extends chain + resolves deps)
const fullSkillList = resolveProfile('recommended');
console.log(fullSkillList);
```

### Response
#### Success Response (200)
- **profiles** (Array<string>) - List of available profile names (for `listProfiles`).
- **profileDefinition** (Object) - The definition of the requested profile, including name, description, extends, skills, and includeProtocols (for `getProfile`).
- **resolvedSkills** (Array<string>) - The complete list of skills for the resolved profile (for `resolveProfile`).

#### Response Example
```json
// Example for listProfiles
["core", "full", "minimal", "recommended"]

// Example for getProfile('recommended')
{
  "name": "recommended",
  "description": "Core + RCSD pipeline skills",
  "extends": "core",
  "skills": ["ct-epic-architect", "ct-research-agent", "ct-spec-writer", "ct-validator"],
  "includeProtocols": ["research", "specification", "decomposition", "validation"]
}

// Example for resolveProfile('recommended')
["ct-epic-architect", "ct-research-agent", "ct-spec-writer", "ct-validator", "ct-orchestrator", "ct-task-executor"]
```
```

--------------------------------

### Install Skill via CAAMP

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/README.md

Demonstrates how to install a specific skill from the cleo-skills repository using the CAAMP package manager. CAAMP handles versioning, validation, and symlink creation for the installed skill.

```bash
# Install a specific skill
caamp skills install /path/to/cleo-skills/skills/ct-gitbook

# CAAMP handles versioning, validation, and symlink creation
```

--------------------------------

### Migration Guides

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-gitbook/SKILL.md

Guides for migrating documentation from other platforms like MkDocs, Docusaurus, and legacy GitBook versions.

```APIDOC
## Migration Guides

### From MkDocs

1. Copy `docs/` directory contents to your GitBook repo
2. Convert `mkdocs.yml` nav to `SUMMARY.md` format
3. Add `.gitbook.yaml` with `root: ./`
4. Replace `!!! note` admonitions with `{% hint style="info" %}` blocks
5. Connect via Git Sync

### From Docusaurus

1. Copy `docs/` directory to your GitBook repo
2. Convert `sidebars.js` structure to `SUMMARY.md`
3. Strip MDX components — replace with GitBook equivalents
4. Replace `import` statements with standard Markdown
5. Convert frontmatter `sidebar_position` to SUMMARY.md ordering

### From Legacy GitBook (v1/v2)

1. Export content from the legacy instance
2. Structure matches — `SUMMARY.md` format is unchanged
3. Update `.gitbook.yaml` for any root path changes
4. Plugins are not supported — replace with native GitBook features

> Full details: `references/migration.md`
```

--------------------------------

### Configure GitBook Git Sync (.gitbook.yaml)

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-gitbook/SKILL.md

Example configuration file for GitBook's Git Sync feature. It specifies the root directory for content within the repository and defines the structure, including README and SUMMARY files, as well as redirects.

```yaml
root: ./docs/

structure:
  readme: README.md
  summary: SUMMARY.md

redirects:
  old-page: new-page.md
```

--------------------------------

### SKILL.md Frontmatter - Basic Example

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/docs/agentskills-specs.md

Provides a minimal example of the YAML frontmatter required in the SKILL.md file, including 'name' and 'description'.

```yaml
---
name: skill-name
description: A description of what this skill does and when to use it.
---
```

--------------------------------

### Manifest Entry Output Example

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/_shared/manifest-operations.md

Example JSON output returned after successfully adding a manifest entry.

```json
{
  "success": true,
  "entryId": "jwt-auth-2026-02-07",
  "manifestPath": "claudedocs/agent-outputs/MANIFEST.jsonl"
}
```

--------------------------------

### CLEO Orchestrator: Session Commands Quick Reference

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-orchestrator/SKILL.md

A reference guide for essential CLEO orchestrator session management commands. These commands cover listing, resuming, starting, ending sessions, and managing the current task focus.

```bash
| Command | Purpose | When to Use |
|---|---|---|
| `cleo session list` | Show all sessions | Start of conversation |
| `cleo session resume <id>` | Continue existing session | Found active session |
| `cleo session start --scope epic:T1575` | Begin new session | No active session for epic |
| `cleo session end` | Close session | Epic complete or stopping work |
| `cleo focus show` | Current task | Check what's in progress |
| `cleo focus set T1586` | Set active task | Before spawning subagent |
```

--------------------------------

### Examples Pattern for Commit Message Generation

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-skill-creator/references/output-patterns.md

This markdown example demonstrates the 'Examples Pattern' for generating commit messages. It provides specific input/output pairs to illustrate the desired format, including type(scope): brief description and a detailed explanation, helping the skill produce consistent and well-formatted commit messages.

```markdown
## Commit message format

Generate commit messages following these examples:

**Example 1:**
Input: Added user authentication with JWT tokens
Output:
```
feat(auth): implement JWT-based authentication

Add login endpoint and token validation middleware
```

**Example 2:**
Input: Fixed bug where dates displayed incorrectly in reports
Output:
```
fix(reports): correct date formatting in timezone conversion

Use UTC timestamps consistently across report generation
```

Follow this style: type(scope): brief description, then detailed explanation.
```

--------------------------------

### Install @gitbook/api SDK

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-gitbook/references/api-sdk.md

Installs the official GitBook API TypeScript SDK using npm. This is the first step to using the SDK in your Node.js or browser project.

```bash
npm install @gitbook/api
```

--------------------------------

### Mermaid Dependency Graph Example

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/protocols/decomposition.md

An example of a dependency graph generated using Mermaid syntax. This visual representation helps in understanding task relationships and execution order.

```mermaid
graph TD
    T001[Epic] --> T002[Task A]
    T001 --> T005[Task B]
    T002 --> T003[Subtask 1]
    T002 --> T004[Subtask 2]
    T003 --> T004
```

--------------------------------

### CLEO Skill with Dependencies JSON Schema Example

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/docs/DEVELOPER-GUIDE.md

Demonstrates a CLEO skill that has explicit dependencies on other skills. CAAMP automatically installs these listed dependencies alongside the primary skill.

```json
{
  "name": "ct-documentor",
  "description": "Documentation creation, editing, and review with CLEO style guide compliance. Coordinates specialized skills for lookup, writing, and review.",
  "version": "3.0.0",
  "path": "skills/ct-documentor/SKILL.md",
  "references": [],
  "core": false,
  "category": "specialist",
  "tier": 3,
  "protocol": null,
  "dependencies": ["ct-docs-lookup", "ct-docs-write", "ct-docs-review"],
  "sharedResources": ["subagent-protocol-base", "task-system-integration"],
  "compatibility": ["claude-code", "cursor", "windsurf", "gemini-cli"],
  "license": "MIT",
  "metadata": {}
}
```

--------------------------------

### Programmatic Access to CLEO Skills via Node.js API

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/docs/DEVELOPER-GUIDE.md

Shows how to use the `@cleocode/ct-skills` Node.js library to retrieve skill information. Includes examples for getting all skills, a specific skill by name, core skills, and skills filtered by category.

```javascript
const { skills, getSkill, getCoreSkills, getSkillsByCategory } = require('@cleocode/ct-skills');

// Get all skills
console.log(skills.length); // 17

// Find a specific skill
const spec = getSkill('ct-spec-writer');
console.log(spec.version);       // "2.0.0"
console.log(spec.protocol);      // "specification"
console.log(spec.dependencies);  // []

// Get core skills only
const core = getCoreSkills();
console.log(core.map(s => s.name)); // ["ct-orchestrator", "ct-task-executor"]

// Filter by category
const recommended = getSkillsByCategory('recommended');
// ["ct-epic-architect", "ct-research-agent", "ct-spec-writer", "ct-validator"]
```

--------------------------------

### Installation via CAAMP (Bash)

Source: https://context7.com/kryptobaseddev/cleo-skills/llms.txt

Illustrates the recommended method for installing a specific skill using the CAAMP tool. This command points to the local path of the skill's directory within the CLEO skills structure.

```bash
# Install a specific skill via CAAMP (recommended)
caamp skills install /path/to/cleo-skills/skills/ct-gitbook

```

--------------------------------

### Manage GitBook Docs Sites with TypeScript SDK

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-gitbook/SKILL.md

Illustrates how to manage GitBook documentation sites using the TypeScript SDK. This covers creating new sites, listing existing sites within an organization, and updating site customization options like styling and themes. Requires an initialized GitBook client and organization/site IDs.

```typescript
// Create site
const site = await client.orgs.createSite(orgId, { title: 'Docs' });

// List sites
const sites = await client.orgs.listSitesInOrganization(orgId);

// Update customization
await client.sites.updateSiteCustomization(siteId, {
  styling: { primaryColor: '#0066FF' },
  themes: { default: 'light', toggleable: true },
});
```

--------------------------------

### Cleo Skill Entry Schema Example

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/docs/DEVELOPER-GUIDE.md

An example of a fully annotated `manifest.json` entry for a Cleo skill. This JSON structure defines the skill's metadata, capabilities, and constraints.

```json
{
  "name": "ct-spec-generator",
  "version": "1.0.0",
  "description": "Automates generation of technical specifications...",
  "path": "skills/ct-spec-generator",
  "tags": ["specification", "documentation", "automation"],
  "status": "active",
  "tier": 2,
  "token_budget": 8000,
  "references": [
    "skills/ct-spec-generator/SKILL.md",
    "skills/ct-spec-generator/references/spec-templates.md"
  ],
  "capabilities": {
    "inputs": ["TASK_ID", "component_path", "output_format", "DATE", "TOPIC_SLUG"],
    "outputs": ["specification-file", "manifest-entry"],
    "dependencies": [],
    "dispatch_triggers": [
      "generate a spec",
      "create technical specification",
      "document component architecture",
      "write API spec",
      "automated specification"
    ],
    "compatible_subagent_types": ["general-purpose", "Code"],
    "chains_to": ["ct-documentor", "ct-validator"],
    "dispatch_keywords": {
      "primary": ["spec", "specification", "generate", "technical"],
      "secondary": ["api-docs", "architecture", "component", "automated"]
    }
  },
  "constraints": {
    "max_context_tokens": 80000,
    "requires_session": false,
    "requires_epic": false
  }
}
```

--------------------------------

### Expected Build Output

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/docs/DEVELOPER-GUIDE.md

Example output from the build process, indicating successful validation and summary information for a newly added skill.

```text
OK: ct-sprint-planner (v1.0.0 tier:1 core:false cat:specialist proto:decomposition 80 lines, 350 char desc, 1 refs)
```

--------------------------------

### Profile Schema Definition (JSON)

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/docs/DEVELOPER-GUIDE.md

JSON schema defining the structure of a Cleo install profile, including fields for name, description, inheritance, included skills, and protocols.

```json
{
  "name": "recommended",
  "description": "Core + RCSD pipeline skills",
  "extends": "core",
  "skills": ["ct-epic-architect", "ct-research-agent", "ct-spec-writer", "ct-validator"],
  "includeProtocols": ["research", "specification", "decomposition", "consensus", "validation"]
}
```

--------------------------------

### Initialize New Skill using Python Script

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-skill-creator/SKILL.md

This bash command demonstrates how to initialize a new skill using the provided Python script. It requires the skill name and an output directory. The script generates a template skill structure, including SKILL.md, scripts, references, and assets directories.

```bash
scripts/init_skill.py <skill-name> --path <output-directory>
```

--------------------------------

### Manage GitBook Change Requests via API

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-gitbook/SKILL.md

Provides examples for creating and merging change requests using the GitBook API. This enables a branch-and-merge workflow for documentation changes.

```typescript
// Create a change request
const cr = await client.spaces.createChangeRequest(spaceId, {
  subject: 'Update API authentication guide',
});

// Merge when ready
await client.spaces.mergeChangeRequest(spaceId, cr.data.id);
```

--------------------------------

### Example Claude Code MCP Server Configuration (JSON)

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-gitbook/references/llm-ready.md

Provides a specific JSON configuration example for setting up the MCP server connection within Claude Code. This allows Claude Code to directly query project documentation during coding sessions.

```json
{
  "mcpServers": {
    "project-docs": {
      "url": "https://docs.example.com/~gitbook/mcp"
    }
  }
}
```

--------------------------------

### Skill Chaining Configuration Example

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/docs/DEVELOPER-GUIDE.md

Defines which skills can follow a specific skill in a workflow using the `chains_to` field. This JSON snippet shows that `ct-research-agent` can be followed by `ct-spec-writer` or `ct-epic-architect`.

```json
{
  "name": "ct-research-agent",
  "capabilities": {
    "chains_to": ["ct-spec-writer", "ct-epic-architect"]
  }
}
```

--------------------------------

### Sigstore Key-Based Signing Command

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/protocols/provenance.md

Example command for signing an artifact using Sigstore with a specified key reference, outputting the signature.

```bash
cosign sign-blob --key <ref> --output-signature <sig> <artifact>
```

--------------------------------

### CLI Usage: ct-skills (Bash)

Source: https://context7.com/kryptobaseddev/cleo-skills/llms.txt

Demonstrates the command-line interface provided by the ct-skills package for managing skills. Includes commands for installation, listing, getting info, validation, and showing profiles.

```bash
# Install from npm
npm install -g @cleocode/ct-skills

# List all skills
ct-skills list

# Get skill info
ct-skills info ct-research-agent

# Validate all skills
ct-skills validate

# Show available profiles
ct-skills profiles

```

--------------------------------

### Start Session Command

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-epic-architect/references/refactor-epic-example.md

This command initiates a session for a specific scope (epic) with a given name and agent. The `--auto-focus` flag ensures the session is automatically focused.

```bash
{{TASK_SESSION_START_CMD}} \
  --scope epic:{{EPIC_ID}} \
  --name "Auth Modernization - Refactor" \
  --agent ct-epic-architect \
  --auto-focus
```

--------------------------------

### Example Manifest Entry for CLEO Release (Bash)

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/protocols/provenance.md

An example of adding a manifest entry for the CLEO v0.85.0 release, demonstrating specific values for title, file, topics, findings, and task IDs. This command is used to record the provenance details for a specific software release.

```bash
cleo research add \
  --title "Provenance: CLEO v0.85.0" \
  --file "2026-02-09_provenance-v0850.md" \
  --topics "provenance,slsa,v0.85.0,supply-chain" \
  --findings "SLSA L3 achieved,3 artifacts signed,CycloneDX SBOM generated,Chain verified" \
  --status complete \
  --task T3200 \
  --epic T3195 \
  --not-actionable \
  --agent-type provenance
```

--------------------------------

### Get Skill Dependencies and Resolve Dependency Tree

Source: https://context7.com/kryptobaseddev/cleo-skills/llms.txt

Obtain the direct dependencies of a specific skill or resolve the complete transitive dependency graph for a list of skills, essential for installation or execution planning.

```APIDOC
## getSkillDependencies and resolveDependencyTree

### Description
Resolve skill dependencies for installation or spawning. `getSkillDependencies` returns direct dependencies; `resolveDependencyTree` resolves the full transitive dependency graph.

### Method
GET (Implicit)

### Endpoint
N/A (Function calls within the library)

### Parameters
#### Query Parameters
- **skillName** (string) - Required (for `getSkillDependencies`) - The name of the skill to get direct dependencies for.
- **skills** (Array<string>) - Required (for `resolveDependencyTree`) - An array of skill names to resolve the dependency tree for.

### Request Example
```javascript
const { getSkillDependencies, resolveDependencyTree } = require('@cleocode/ct-skills');

// Get direct dependencies
const directDeps = getSkillDependencies('ct-documentor');
console.log(directDeps);

// Resolve full transitive dependency tree
const fullTree = resolveDependencyTree(['ct-documentor']);
console.log(fullTree);

// Resolve multiple skills at once
const multiSkillTree = resolveDependencyTree(['ct-documentor', 'ct-epic-architect']);
console.log(multiSkillTree);
```

### Response
#### Success Response (200)
- **dependencies** (Array<string>) - An array of skill names representing direct or transitive dependencies.

#### Response Example
```json
// Example for directDeps
["ct-docs-lookup", "ct-docs-write", "ct-docs-review"]

// Example for fullTree
["ct-documentor", "ct-docs-lookup", "ct-docs-write", "ct-docs-review"]
```
```

--------------------------------

### Example SUMMARY.md for Multi-Section Docs

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-gitbook/references/git-sync.md

This example demonstrates a complex SUMMARY.md structure with multiple sections, nested pages, and different types of content links, including a CHANGELOG.md. It illustrates how to organize extensive documentation within GitBook using Markdown.

```markdown
# Summary

## Getting Started
* [Introduction](README.md)
* [Installation](getting-started/installation.md)
* [Quick Start](getting-started/quickstart.md)
* [Configuration](getting-started/config.md)

## User Guide
* [Overview](guide/README.md)
* [Basic Usage](guide/basics.md)
* [Advanced Topics](guide/advanced/README.md)
  * [Plugins](guide/advanced/plugins.md)
  * [Theming](guide/advanced/theming.md)
  * [Hooks](guide/advanced/hooks.md)

## API Reference
* [REST API](api/rest.md)
* [TypeScript SDK](api/sdk.md)
* [Webhooks](api/webhooks.md)

## Resources
* [FAQ](resources/faq.md)
* [Troubleshooting](resources/troubleshooting.md)
* [Changelog](CHANGELOG.md)
```

--------------------------------

### Impact Analysis Commands (Bash)

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-epic-architect/references/refactor-epic-example.md

These bash commands are used to perform impact analysis before starting a refactoring epic. They help identify related existing tasks and verify the current project phase.

```bash
# Check for related existing work
{{TASK_FIND_CMD}} "auth" --status pending
{{TASK_LIST_CMD}} --type epic | jq '.tasks[] | select(.title | test("auth"; "i"))'

# Verify current project phase
{{TASK_PHASE_CMD}}
```

--------------------------------

### Skills JSON Entry Schema

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/docs/DEVELOPER-GUIDE.md

This JSON structure represents a skill entry within the `skills.json` file, used by CAAMP for discovery, installation, and validation. It includes metadata such as name, description, version, path, dependencies, and compatibility.

```json
{
  "name": "ct-spec-generator",
  "description": "Automates generation of technical specifications for software components. Use when the user asks to \"generate a spec\", \"create technical specification\", or needs automated specification output.",
  "version": "1.0.0",
  "path": "skills/ct-spec-generator/SKILL.md",
  "references": [
    "skills/ct-spec-generator/references/spec-templates.md"
  ],
  "core": false,
  "category": "specialist",
  "tier": 2,
  "protocol": "specification",
  "dependencies": [],
  "sharedResources": ["subagent-protocol-base", "task-system-integration"],
  "compatibility": ["claude-code", "cursor", "windsurf", "gemini-cli"],
  "license": "MIT",
  "metadata": {}
}
```

--------------------------------

### Markdown Implementation File Output Example

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/protocols/implementation.md

A template for the markdown file output detailing an implementation. It includes sections for summary, changes (files and functions), tests, validation, breaking changes, and follow-up actions.

```markdown
# Implementation: {Feature/Fix Title}

**Task**: T####
**Date**: YYYY-MM-DD
**Status**: complete|partial|blocked
**Agent Type**: implementation

---

## Summary

{2-3 sentence summary of implementation}
## Changes

### Files Modified

| File | Action | Description |
|------|--------|-------------|
| `path/to/file.sh` | Modified | Added validation function |
| `path/to/new.sh` | Created | New utility module |

### Functions Added

| Function | File | Purpose |
|----------|------|---------|
| `validate_input()` | file.sh | Input validation |

### Functions Modified

| Function | File | Change |
|----------|------|--------|
| `process_data()` | file.sh | Added error handling |

## Tests

### New Tests

| Test | File | Coverage |
|------|------|----------|
| `test_validate_input` | tests/unit/file.bats | Input validation |

### Test Results

```
Running tests/unit/file.bats
 ✓ validate_input accepts valid input
 ✓ validate_input rejects empty input
 ✓ validate_input handles special characters

3 tests, 0 failures
```

## Validation

| Check | Status | Notes |
|-------|--------|-------|
| Tests pass | PASS | All 42 tests pass |
| Lint clean | PASS | No shellcheck warnings |
| No regressions | PASS | Existing tests unchanged |

## Breaking Changes

{If any, document migration path}

## Follow-up

- {Suggested improvements}
- {Technical debt items}
```

--------------------------------

### Manage Docs Sites

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-gitbook/references/api-sdk.md

Illustrates how to manage GitBook docs sites using the TypeScript SDK. Examples cover creating a site, listing sites in an organization, retrieving a site by ID, updating site customization (hostname, styling, themes, favicon, logo), and deleting a site.

```typescript
// Create a docs site
const site = await client.orgs.createSite(orgId, {
  title: 'Developer Documentation',
});

// List sites
const sites = await client.orgs.listSitesInOrganization(orgId);

// Get site
const site = await client.sites.getSiteById(siteId);

// Update site customization
await client.sites.updateSiteCustomization(siteId, {
  hostname: 'docs.example.com',
  styling: {
    primaryColor: '#0066FF',
    font: 'Inter',
  },
  themes: {
    default: 'light',
    toggleable: true,
  },
  favicon: 'https://example.com/favicon.ico',
  logo: {
    light: 'https://example.com/logo-light.png',
    dark: 'https://example.com/logo-dark.png',
  },
});

// Delete site
await client.sites.deleteSite(siteId);
```

--------------------------------

### Creating a New Planning Tier Skill (YAML)

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/docs/DEVELOPER-GUIDE.md

Example YAML configuration for a new tier 1 skill, 'ct-sprint-planner'. It defines the skill's name, description, version, tier, category, protocol, dependencies, and compatibility.

```yaml
---
name: ct-sprint-planner
description: >-
  Sprint planning and capacity allocation for mapping decomposed tasks
  to time-boxed iterations. Analyzes task complexity, team capacity, and
  dependencies to produce balanced sprint plans. Use when planning sprints,
  allocating work across iterations, or balancing team workload.
version: 1.0.0
tier: 1                           # ← Planning tier
core: false
category: specialist
protocol: decomposition           # ← Reuses decomposition protocol
dependencies:
  - ct-epic-architect             # ← Needs decomposed task tree as input
sharedResources:
  - subagent-protocol-base
  - task-system-integration
compatibility:
  - claude-code
  - cursor
  - windsurf
  - gemini-cli
license: MIT
---

```

--------------------------------

### CLEO Skills JSON Schema Example

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/docs/DEVELOPER-GUIDE.md

Illustrates a typical JSON object for a core CLEO skill, detailing fields like name, description, version, category, and dependencies. This structure is used by CAAMP for skill management.

```json
{
  "name": "ct-task-executor",
  "description": "General implementation task execution for completing assigned CLEO tasks by following instructions and producing concrete deliverables.",
  "version": "2.0.0",
  "path": "skills/ct-task-executor/SKILL.md",
  "references": [],
  "core": true,
  "category": "core",
  "tier": 2,
  "protocol": "implementation",
  "dependencies": [],
  "sharedResources": ["subagent-protocol-base", "task-system-integration"],
  "compatibility": ["claude-code", "cursor", "windsurf", "gemini-cli"],
  "license": "MIT",
  "metadata": {}
}
```

--------------------------------

### Initialize GitBook API Client (TypeScript)

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-gitbook/SKILL.md

Initializes the GitBookAPI client using a provided authentication token. It then demonstrates verifying authentication by fetching the current user's details.

```typescript
import { GitBookAPI } from '@gitbook/api';

const client = new GitBookAPI({ authToken: process.env.GITBOOK_API_TOKEN });

// Verify authentication
const user = await client.user.getCurrentUser();
console.log(`Authenticated as: ${user.data.displayName}`);
```

--------------------------------

### Token Resolution Example in SKILL.md

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/docs/SKILL-SPECIFICATION.md

This table demonstrates how placeholders (tokens) in SKILL.md files are resolved by the orchestrator into concrete values before being injected into the subagent prompt. Examples include task IDs, dates, and command strings.

```text
In SKILL.md (template) | After resolution (subagent receives) 
------------------------|--------------------------------------
`{{TASK_ID}}` | `T2500` 
`{{DATE}}` | `2026-02-12` 
`{{TOPIC_SLUG}}` | `websocket-auth` 
`{{OUTPUT_DIR}}` | `claudedocs/agent-outputs` 
`{{TASK_FOCUS_CMD}} {{TASK_ID}}` | `cleo focus set T2500` 
`{{TASK_COMPLETE_CMD}} {{TASK_ID}}` | `cleo complete T2500` 

```

--------------------------------

### Bash Dependency Management Example

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-library-implementer-bash/SKILL.md

Shows how to manage dependencies between Bash library files by sourcing other library files at the beginning of a script. This ensures that required functions and constants from other modules are available.

```bash
# At top of file, source dependencies
source "${LIB_DIR:-./lib}/exit-codes.sh"
source "${LIB_DIR:-./lib}/output-format.sh"

```

--------------------------------

### Manage Organizations

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-gitbook/references/api-sdk.md

Provides TypeScript code examples for managing organizations via the GitBook API. This includes listing organizations, getting an organization by ID, managing members (inviting, updating roles, removing), and listing members.

```typescript
// List all organizations for the authenticated user
const orgs = await client.orgs.listOrganizationsForAuthenticatedUser();
for (const org of orgs.data.items) {
  console.log(`${org.title} (${org.id})`);
}

// Get organization by ID
const org = await client.orgs.getOrganizationById(orgId);

// List members
const members = await client.orgs.listMembersInOrganization(orgId);

// Invite members
await client.orgs.inviteMembersToOrganization(orgId, {
  emails: ['user@example.com'],
  role: 'editor', // admin | creator | editor | reviewer | reader
});

// Update member role
await client.orgs.updateMemberInOrganization(orgId, memberId, {
  role: 'admin',
});

// Remove member
await client.orgs.removeMemberFromOrganization(orgId, memberId);
```

--------------------------------

### Start Contribution Tracking

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-contribution/SKILL.md

Initializes contribution tracking for a given epic. It verifies the epic, creates a task, sets up directories, generates an ID, and returns setup instructions. Parameters include the required epic ID and optional label and agent identifiers.

```bash
# 1. Verify epic exists
ct show T2204

# 2. Initialize contribution
/contribution start T2204 --label rcsd-contrib

# 3. Create contribution task (if not auto-created)
ct add "Session B: Architecture Analysis" \
  --parent T2204 \
  --labels consensus-source,research \
  --phase core

# 4. Set focus
ct focus set T2215

# 5. Create contribution directory
mkdir -p .cleo/contributions

```

--------------------------------

### Manual Skill Installation for Agents (Bash)

Source: https://context7.com/kryptobaseddev/cleo-skills/llms.txt

Provides manual installation commands for the 'ct-gitbook' skill for different agents: Claude, Codex, and Copilot (VS Code). This involves copying the skill directory to the appropriate agent-specific location.

```bash
# Claude Code
cp -r skills/ct-gitbook ~/.claude/skills/ct-gitbook

# Codex
cp -r skills/ct-gitbook .agents/skills/ct-gitbook

# Copilot (VS Code)
cp -r skills/ct-gitbook .github/skills/ct-gitbook
```

--------------------------------

### GitBook API Operations for Change Requests (TypeScript)

Source: https://github.com/kryptobaseddev/cleo-skills/blob/main/skills/ct-gitbook/references/change-requests.md

Provides a comprehensive set of TypeScript examples for interacting with GitBook's Change Request API. Includes creating, listing, getting details, diffing, merging, and closing change requests.

```typescript
// Create change request
const cr = await client.spaces.createChangeRequest(spaceId, {
  subject: 'Add new API endpoints documentation',
});

// List change requests for a space
const list = await client.spaces.listChangeRequests(spaceId);
for (const item of list.data.items) {
  console.log(`${item.subject} — ${item.status}`);
}

// Get change request details
const detail = await client.spaces.getChangeRequest(spaceId, crId);

// Get content diff
const diff = await client.spaces.getChangeRequestDiff(spaceId, crId);

// Merge
await client.spaces.mergeChangeRequest(spaceId, crId);

// Close without merging
await client.spaces.closeChangeRequest(spaceId, crId);
```