### Run All Setup Scripts

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/installation.md

Execute the main setup script to automatically detect and install all agents and skills.

```bash
./scripts/setup.sh --all
```

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

### Install OpenCode Agent (Interactive)

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/installation.md

Run the setup script to interactively install the OpenCode agent, choosing between single or multi-model configurations.

```bash
./scripts/setup.sh --agent opencode
```

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

### Automated Setup Script for Agent Teams Lite

Source: https://context7.com/gentleman-programming/agent-teams-lite/llms.txt

Use the setup script for automated installation. It detects agents, copies skills, and configures orchestrator prompts. Options include interactive setup, installing for all agents, or for specific agents.

```bash
# Interactive: detects agents, asks which to set up
./scripts/setup.sh

# Auto-detect + install all agents, no prompts
./scripts/setup.sh --all

# Install for a specific agent
./scripts/setup.sh --agent claude-code
./scripts/setup.sh --agent opencode --opencode-mode single
./scripts/setup.sh --agent opencode --opencode-mode multi
./scripts/setup.sh --agent gemini-cli
./scripts/setup.sh --agent codex
./scripts/setup.sh --agent cursor
./scripts/setup.sh --agent vscode

# Non-interactive mode for external installers
./scripts/setup.sh --all --non-interactive

# Windows PowerShell equivalents
.\scripts\setup.ps1 -All
.\scripts\setup.ps1 -Agent claude-code
```

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

### Install OpenCode Agent (Single Model)

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/installation.md

Use the setup script with the `--opencode-mode single` flag for an OpenCode installation ready to use with the default model.

```bash
./scripts/setup.sh --agent opencode --opencode-mode single
```

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

### Automated PowerShell Setup (All Agents)

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/installation.md

Execute the PowerShell setup script with the `-All` flag for an automated installation of all agents.

```powershell
.\scripts\setup.ps1 -All
```

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

### Install OpenCode Agent (Multi Model Template)

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/installation.md

Use the setup script with the `--opencode-mode multi` flag to set up OpenCode as a template for per-agent model customization.

```bash
./scripts/setup.sh --agent opencode --opencode-mode multi
```

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

### Interactive Setup Script

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/installation.md

Run the setup script interactively to detect agents and choose which ones to set up.

```bash
./scripts/setup.sh
```

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

### Example opencode.multi.json Configuration

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/sub-agents.md

Configure specific models for different agents within your project. Omit the 'model' field for single-model setups.

```json
{
  "sdd-explore": {
    "model": "<your-provider/your-model>",
    "mode": "subagent",
    ...
  },
  "sdd-spec": {
    "model": "<your-provider/your-model>",
    "mode": "subagent",
    ...
  }
}
```

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

### Interactive PowerShell Setup

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/installation.md

Run the PowerShell setup script interactively to configure agents.

```powershell
.\scripts\setup.ps1
```

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

### Example Compact Rules for React 19 Skill

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/skill-registry/SKILL.md

This example demonstrates the format and content of compact rules for a specific skill. Focus on actionable rules, key patterns, and critical gotchas, omitting general explanations or installation steps.

```markdown
### react-19
- No useMemo/useCallback — React Compiler handles memoization automatically
- use() hook for promises/context, replaces useEffect for data fetching
- Server Components by default, add 'use client' only for interactivity/hooks
- ref is a regular prop — no forwardRef needed
- Actions: use useActionState for form mutations, useOptimistic for optimistic UI
- Metadata: export metadata object from page/layout, no <Head> component
```

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

### Install Claude Code Agent

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/installation.md

Automatically install the Claude Code agent using the setup script.

```bash
./scripts/setup.sh --agent claude-code
```

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

### OpenSpec Config File Example

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/_shared/openspec-convention.md

Example structure of the `openspec/config.yaml` file, showing schema, context, and rules for various SDD phases.

```yaml
# openspec/config.yaml
schema: spec-driven

context: |
  Tech stack: {detected}
  Architecture: {detected}
  Testing: {detected}
  Style: {detected}

rules:
  proposal:
    - Include rollback plan for risky changes
  specs:
    - Use Given/When/Then for scenarios
    - Use RFC 2119 keywords (MUST, SHALL, SHOULD, MAY)
  design:
    - Include sequence diagrams for complex flows
    - Document architecture decisions with rationale
  tasks:
    - Group by phase, use hierarchical numbering
    - Keep tasks completable in one session
  apply:
    - Follow existing code patterns
    tdd: false           # Set to true to enable RED-GREEN-REFACTOR
    test_command: ""
  verify:
    test_command: ""
    build_command: ""
    coverage_threshold: 0
  archive:
    - Warn before merging destructive deltas
```

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

### Conventional Commit Examples

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/branch-pr/SKILL.md

Examples demonstrating various conventional commit types and scopes. Use these as a guide when crafting your commit messages.

```git
feat(scripts): add Codex support to setup.sh
```

```git
fix(skills): correct topic key format in sdd-apply
```

```git
docs(readme): update multi-model configuration guide
```

```git
refactor(skills): extract shared persistence logic
```

```git
chore(ci): add shellcheck to PR validation workflow
```

```git
perf(scripts): reduce setup.sh execution time
```

```git
style(skills): fix markdown formatting
```

```git
test(scripts): add setup.sh integration tests
```

```git
ci(workflows): add branch name validation
```

```git
revert: undo broken setup change
```

```git
feat!: redesign skill loading system
```

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

### Manual Skill Installation Script

Source: https://context7.com/gentleman-programming/agent-teams-lite/llms.txt

Use the install.sh script for manual skill-only installation without orchestrator prompt configuration. Specify the agent or use 'all-global' for all global agents.

```bash
# Install for a specific agent
./scripts/install.sh --agent claude-code
./scripts/install.sh --agent opencode
./scripts/install.sh --agent gemini-cli
./scripts/install.sh --agent codex
./scripts/install.sh --agent cursor
./scripts/install.sh --agent vscode
./scripts/install.sh --agent antigravity
./scripts/install.sh --agent project-local   # installs to ./skills/
./scripts/install.sh --agent all-global       # all global agents at once

# Custom path
./scripts/install.sh --agent custom --path /my/custom/skills/dir

# Skills are copied to agent-specific directories:
# Claude Code  → ~/.claude/skills/
# OpenCode     → ~/.config/opencode/skills/
# Gemini CLI   → ~/.gemini/skills/
# Codex        → ~/.codex/skills/
# Cursor       → ~/.cursor/skills/
# VS Code      → .vscode/skills/
# Antigravity  → ~/.gemini/antigravity/skills/
```

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

### Install gentle-ai

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/README.md

Use Homebrew to install gentle-ai and then run the install command. This command automatically detects and configures your existing tools, skills, and orchestrators.

```bash
brew install gentleman-programming/tap/gentle-ai
gentle-ai install
```

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

### Go Test Example: Cursor Navigation

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/go-testing/SKILL.md

This example demonstrates testing cursor navigation within a list or menu in a Bubbletea TUI. It uses a table-driven approach to test various navigation scenarios with different key inputs.

```go
func TestCursorNavigation(t *testing.T) {
    tests := []struct {
        name       string
        startPos   int
        key        string
        endPos     int
        numOptions int
    }{
        {"down from 0", 0, "j", 1, 5},
        {"up from 1", 1, "k", 0, 5},
        {"down at bottom", 4, "j", 4, 5}, // stays at bottom
        {"up at top", 0, "k", 0, 5},       // stays at top
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            m := NewModel()
            m.Cursor = tt.startPos
            // Set up options...

            newModel, _ := m.Update(tea.KeyMsg{
                Type:  tea.KeyRunes,
                Runes: []rune(tt.key),
            })
            m = newModel.(Model)

            if m.Cursor != tt.endPos {
                t.Errorf("cursor = %d, want %d", m.Cursor, tt.endPos)
            }
        })
    }
}
```

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

### Registering Skill in AGENTS.md

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/skill-creator/SKILL.md

Example of how to register a newly created skill in the AGENTS.md file, including skill name, description, and a link to its SKILL.md file.

```markdown
| `{skill-name}` | {Description} | [SKILL.md](skills/{skill-name}/SKILL.md) |
```

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

### Bash Command Example

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/skill-creator/SKILL.md

Example of a common bash command that might be included in a skill's Commands section.

```bash
{Common commands}
```

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

### Example Directory Structure for Openspec/Hybrid Mode

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/sdd-spec/SKILL.md

Illustrates the expected directory structure for storing delta specs when using 'openspec' or 'hybrid' artifact store modes.

```bash
openspec/changes/{change-name}/
├── proposal.md              ← (already exists)
└── specs/
    └── {domain}/
        └── spec.md          ← Delta spec

```

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

### Copy OpenCode Skills and Commands

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/installation.md

Manually install OpenCode by copying necessary skills, commands, and agent configuration files to the appropriate directories.

```bash
cp -r skills/_shared skills/sdd-* skills/skill-registry skills/judgment-day skills/go-testing skills/skill-creator skills/branch-pr skills/issue-creation ~/.config/opencode/skills/
cp examples/opencode/commands/sdd-*.md ~/.config/opencode/commands/
cp examples/opencode/AGENTS.md ~/.config/opencode/AGENTS.md
```

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

### Conventional Commit Examples

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/CONTRIBUTING.md

Illustrative examples of commit messages following the conventional commit format.

```text
feat(scripts): add multi-model setup for OpenCode
fix(skills): correct engram topic key format in sdd-apply
docs(readme): update installation instructions
refactor(skills): extract shared persistence logic
chore(ci): add shellcheck to PR validation workflow
perf(scripts): reduce setup.sh execution time
style(skills): fix markdown formatting
test(scripts): add setup.sh integration tests
ci(workflows): add branch name validation
revert: undo broken setup change
feat!: redesign skill loading system
```

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

### Engram Example Proposal Save

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/_shared/engram-convention.md

Concrete example of saving a proposal artifact for a specific change ('add-dark-mode') within a project ('my-app').

```python
mem_save(
  title: "sdd/add-dark-mode/proposal",
  topic_key: "sdd/add-dark-mode/proposal",
  type: "architecture",
  project: "my-app",
  content: "## Proposal\n\nAdd dark mode toggle..."
)
```

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

### Branch Naming Examples

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/CONTRIBUTING.md

Examples of valid branch names adhering to the specified format.

```text
feat/user-login
fix/zsh-glob-error
docs/installation-guide
```

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

### Decision: assets/ vs references/

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/skill-creator/SKILL.md

A guide to help decide whether to use the assets/ directory for code templates and schemas or the references/ directory for linking to local documentation.

```text
Need code templates?        → assets/
Need JSON schemas?          → assets/
Need example configs?       → assets/
Link to existing docs?      → references/
Link to external guides?    → references/ (with local path)

**Key Rule**: `references/` should point to LOCAL files, not web URLs.
```

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

### Start New Change Command

Source: https://context7.com/gentleman-programming/agent-teams-lite/llms.txt

The /sdd-new meta-command initiates a new change by launching explore and proposal sub-agents, returning a structured plan. Provide a descriptive name for the change.

```bash
/sdd-new add-csv-export
```

```bash
/sdd-new user-authentication
```

```bash
/sdd-new refactor-payment-service
```

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

### Sub-Agent Result Contract Example

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/sub-agents.md

This markdown example demonstrates the expected structure of a sub-agent's return contract, including status, summary, artifacts, and next steps.

```markdown
**Status**: success
**Summary**: Proposal created for `{change-name}`. Defined scope, approach, and rollback plan.
**Artifacts**: Engram `sdd/{change-name}/proposal` | `openspec/changes/{change-name}/proposal.md`
**Next**: sdd-spec or sdd-design
**Risks**: None
```

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

### Copy Gemini CLI Skills

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/installation.md

Manually install Gemini CLI by copying the shared and SDD-related skills to the Gemini configuration directory.

```bash
cp -r skills/_shared skills/sdd-* skills/skill-registry skills/judgment-day skills/go-testing skills/skill-creator skills/branch-pr skills/issue-creation ~/.gemini/skills/
```

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

### Task File Format Example

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/sdd-tasks/SKILL.md

Defines the standard markdown format for the generated tasks file, including phases and actionable checklist items.

```markdown
# Tasks: {Change Title}

## Phase 1: {Phase Name} (e.g., Infrastructure / Foundation)

- [ ] 1.1 {Concrete action — what file, what change}
- [ ] 1.2 {Concrete action}
- [ ] 1.3 {Concrete action}

## Phase 2: {Phase Name} (e.g., Core Implementation)

- [ ] 2.1 {Concrete action}
- [ ] 2.2 {Concrete action}
- [ ] 2.3 {Concrete action}
- [ ] 2.4 {Concrete action}

## Phase 3: {Phase Name} (e.g., Testing / Verification)

- [ ] 3.1 {Write tests for ...}
- [ ] 3.2 {Write tests for ...}
- [ ] 3.3 {Verify integration between ...}

## Phase 4: {Phase Name} (e.g., Cleanup / Documentation)

- [ ] 4.1 {Update docs/comments}
- [ ] 4.2 {Remove temporary code}
```

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

### Sub-Agent Result Contract Example

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/architecture.md

This markdown example illustrates the expected structured output from sub-agents, including status, summary, artifacts, and next steps. Ensure all fields are populated correctly for seamless integration.

```markdown
**Status**: success
**Summary**: Proposal created for `{change-name}`. Defined scope, approach, and rollback plan.
**Artifacts**: Engram `sdd/{change-name}/proposal` | `openspec/changes/{change-name}/proposal.md`
**Next**: sdd-spec or sdd-design
**Risks**: None

```

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

### Return Envelope Example

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/_shared/sdd-phase-common.md

Structure the phase output using this envelope format, including status, summary, artifacts, and next steps. The 'Skill Resolution' field indicates how skills were loaded.

```markdown
**Status**: success
**Summary**: Proposal created for `{change-name}`. Defined scope, approach, and rollback plan.
**Artifacts**: Engram `sdd/{change-name}/proposal` | `openspec/changes/{change-name}/proposal.md`
**Next**: sdd-spec or sdd-design
**Risks**: None
**Skill Resolution**: injected — 3 skills (react-19, typescript, tailwind-4)
(other values: `fallback-registry`, `fallback-path`, or `none — no registry found`)
```

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

### Openspec Configuration File

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/sdd-init/SKILL.md

Example configuration file for 'openspec' mode, detailing project context and various rules for proposals, specs, design, tasks, application, verification, and archiving.

```yaml
# openspec/config.yaml
schema: spec-driven

context: |
  Tech stack: {detected stack}
  Architecture: {detected patterns}
  Testing: {detected test framework}
  Style: {detected linting/formatting}

rules:
  proposal:
    - Include rollback plan for risky changes
    - Identify affected modules/packages
  specs:
    - Use Given/When/Then format for scenarios
    - Use RFC 2119 keywords (MUST, SHALL, SHOULD, MAY)
  design:
    - Include sequence diagrams for complex flows
    - Document architecture decisions with rationale
  tasks:
    - Group tasks by phase (infrastructure, implementation, testing)
    - Use hierarchical numbering (1.1, 1.2, etc.)
    - Keep tasks small enough to complete in one session
  apply:
    - Follow existing code patterns and conventions
    - Load relevant coding skills for the project stack
  verify:
    - Run tests if test infrastructure exists
    - Compare implementation against every spec scenario
  archive:
    - Warn before merging destructive deltas (large removals)
```

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

### OpenSpec Archive Structure Example

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/_shared/openspec-convention.md

Illustrates the directory structure for archived changes, emphasizing immutability for audit trail purposes.

```tree
openspec/changes/archive/YYYY-MM-DD-{change-name}/
```

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

### Copy Codex Skills

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/installation.md

Manually install Codex by copying the shared and SDD-related skills to the Codex configuration directory.

```bash
cp -r skills/_shared skills/sdd-* skills/skill-registry skills/judgment-day skills/go-testing skills/skill-creator skills/branch-pr skills/issue-creation ~/.codex/skills/
```

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

### Go Table-Driven Test Example

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/go-testing/SKILL.md

Use this pattern for testing multiple input/output scenarios of a function. It requires defining a slice of structs, each representing a test case with inputs and expected outputs.

```go
func TestSomething(t *testing.T) {
    tests := []struct {
        name     string
        input    string
        expected string
        wantErr  bool
    }{
        {
            name:     "valid input",
            input:    "hello",
            expected: "HELLO",
            wantErr:  false,
        },
        {
            name:     "empty input",
            input:    "",
            expected: "",
            wantErr:  true,
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result, err := ProcessInput(tt.input)

            if (err != nil) != tt.wantErr {
                t.Errorf("error = %v, wantErr %v", err, tt.wantErr)
                return
            }

            if result != tt.expected {
                t.Errorf("got %q, want %q", result, tt.expected)
            }
        })
    }
}
```

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

### Initialize SDD Context Command

Source: https://context7.com/gentleman-programming/agent-teams-lite/llms.txt

The /sdd-init command bootstraps the project by detecting the stack, initializing the persistence backend, and building the skill registry. It's the first command to run in a new project.

```bash
/sdd-init
```

```text
## SDD Initialized
**Project**: my-app
**Stack**: TypeScript, Next.js 14, Prisma
**Persistence**: engram

### Context Saved
Project context persisted to Engram.
- **Engram ID**: #4821
- **Topic key**: sdd-init/my-app

No project files created.

### Next Steps
Ready for /sdd-explore <topic> or /sdd-new <change-name>.
```

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

### Upgrade Agent Teams Lite to gentle-ai

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/README.md

If you have Agent Teams Lite already installed, run the gentle-ai install command. It will detect your current setup and perform an in-place upgrade, migrating your configurations.

```bash
gentle-ai install
```

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

### Mock System Info for Testing in Go

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/go-testing/SKILL.md

Demonstrates mocking system information to create a controlled testing environment. This is useful for testing code that depends on OS-specific details or system configurations.

```go
func TestWithMockedSystem(t *testing.T) {
    m := NewModel()

    // Mock system info for testing
    m.SystemInfo = &system.SystemInfo{
        OS:       system.OSMac,
        IsARM:    true,
        HasBrew:  true,
        HomeDir:  t.TempDir(),
    }

    // Now test with controlled environment
    m.SetupInstallSteps()

    // Verify expected steps
    hasHomebrew := false
    for _, step := range m.Steps {
        if step.ID == "homebrew" {
            hasHomebrew = true
        }
    }

    if hasHomebrew {
        t.Error("should not have homebrew step when HasBrew=true")
    }
}
```

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

### Install unique-names-generator dependency

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/examples/opencode/plugins/BACKGROUND-AGENTS-README.md

Install the `unique-names-generator` npm package in your OpenCode configuration directory. This is a prerequisite for the background agents plugin.

```bash
cd ~/.config/opencode
npm install unique-names-generator
```

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

### Manual OpenCode Configuration Steps

Source: https://context7.com/gentleman-programming/agent-teams-lite/llms.txt

Manual configuration for OpenCode requires copying skills, commands, and agent configuration files to their respective directories. Merge the agent config into opencode.json, choosing between single or multi-model templates.

```bash
# 1. Copy skills and commands
cp -r skills/_shared skills/sdd-* skills/skill-registry skills/judgment-day \
  skills/go-testing skills/skill-creator skills/branch-pr skills/issue-creation \
  ~/.config/opencode/skills/
cp examples/opencode/commands/sdd-*.md ~/.config/opencode/commands/
cp examples/opencode/AGENTS.md ~/.config/opencode/AGENTS.md

# 2. Merge agent config into ~/.config/opencode/opencode.json
# Use either single (default model) or multi (per-agent models) template
```

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

### Verify plugin initialization

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/examples/opencode/plugins/BACKGROUND-AGENTS-README.md

Check the background agents debug log file to confirm that the plugin has initialized successfully. This log file is located within the OpenCode delegations directory.

```bash
cat ~/.local/share/opencode/delegations/*/background-agents-debug.log
# Should show: "BackgroundAgents initialized with delegation system"
```

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

### OpenSpec Initialization Summary

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/sdd-init/SKILL.md

This is the structured summary returned when the mode is 'openspec'. It indicates that project structure has been created and suggests next steps.

```markdown
## SDD Initialized

**Project**: {project name}
**Stack**: {detected stack}
**Persistence**: openspec

### Structure Created
- openspec/config.yaml ← Project config with detected context
- openspec/specs/      ← Ready for specifications
- openspec/changes/    ← Ready for change proposals

### Next Steps
Ready for /sdd-explore <topic> or /sdd-new <change-name>.
```

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

### Delta Specification Example

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/docs/concepts.md

Illustrates how changes to specifications are described as deltas, showing added and modified requirements.

```markdown
## ADDED Requirements

### Requirement: CSV Export
The system SHALL support exporting data to CSV format.

#### Scenario: Export all observations
- GIVEN the user has observations stored
- WHEN the user requests CSV export
- THEN a CSV file is generated with all observations
- AND column headers match the observation fields

## MODIFIED Requirements

### Requirement: Data Export
The system SHALL support multiple export formats.
(Previously: The system SHALL support JSON export.)
```

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

### Contribution Workflow Steps

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/CONTRIBUTING.md

The required sequence of steps for contributing to the project, starting with an issue and ending with a merged PR.

```markdown
Open Issue → Get status:approved → Open PR → Add type:* label → Review & Merge
```

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

### SKILL.md Template

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/skill-creator/SKILL.md

A template for the main skill file (SKILL.md), including frontmatter and sections for usage, patterns, examples, commands, and resources.

```markdown
---
name: {skill-name}
description: >
  {One-line description of what this skill does}.
  Trigger: {When the AI should load this skill}.
license: Apache-2.0
metadata:
  author: gentleman-programming
  version: "1.0"
---

## When to Use

{Bullet points of when to use this skill}

## Critical Patterns

{The most important rules - what AI MUST know}

## Code Examples

{Minimal, focused examples}

## Commands

```bash
{Common commands}
```

## Resources

- **Templates**: See [assets/](assets/) for {description}
- **Documentation**: See [references/](references/) for local docs
```

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

### None (Ephemeral) Initialization Summary

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/sdd-init/SKILL.md

This is the structured summary returned when the mode is 'none'. It highlights that the session is ephemeral and recommends enabling persistence.

```markdown
## SDD Initialized

**Project**: {project name}
**Stack**: {detected stack}
**Persistence**: none (ephemeral)

### Context Detected
{summary of detected stack and conventions}

### Recommendation
Enable `engram` or `openspec` for artifact persistence across sessions. Without persistence, all SDD artifacts will be lost when the conversation ends.

### Next Steps
Ready for /sdd-explore <topic> or /sdd-new <change-name>.
```

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

### PR Test Plan Format

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/branch-pr/SKILL.md

Example checklist for the test plan section of a PR body. Includes script checks and manual testing.

```markdown
- [x] Scripts run without errors: `shellcheck scripts/*.sh`
- [x] Manually tested the affected functionality
- [x] Skills load correctly in target agent
```

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

### Engram Initialization Summary

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/sdd-init/SKILL.md

This is the structured summary returned when the mode is 'engram'. It confirms context persistence to Engram and suggests next steps.

```markdown
## SDD Initialized

**Project**: {project name}
**Stack**: {detected stack}
**Persistence**: engram

### Context Saved
Project context persisted to Engram.
- **Engram ID**: #{observation-id}
- **Topic key**: sdd-init/{project-name}

No project files created.

### Next Steps
Ready for /sdd-explore <topic> or /sdd-new <change-name>.
```

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

### Task Writing Rules Table

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/sdd-tasks/SKILL.md

Illustrates the criteria for writing effective, specific, actionable, and verifiable tasks, contrasting good examples with poor ones.

```markdown
| Criteria | Example ✅ | Anti-example ❌ |
|----------|-----------|----------------|
| **Specific** | "Create `internal/auth/middleware.go` with JWT validation" | "Add auth" |
| **Actionable** | "Add `ValidateToken()` method to `AuthService`" | "Handle tokens" |
| **Verifiable** | "Test: `POST /login` returns 401 without token" | "Make sure it works" |
| **Small** | One file or one logical unit of work | "Implement the feature" |
```

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

### Phase Organization Guidelines

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/sdd-tasks/SKILL.md

Provides a recommended structure for organizing tasks into phases, outlining the typical focus for each phase.

```markdown
Phase 1: Foundation / Infrastructure
  └─ New types, interfaces, database changes, config
  └─ Things other tasks depend on

Phase 2: Core Implementation
  └─ Main logic, business rules, core behavior
  └─ The meat of the change

Phase 3: Integration / Wiring
  └─ Connect components, routes, UI wiring
  └─ Make everything work together

Phase 4: Testing
  └─ Unit tests, integration tests, e2e tests
  └─ Verify against spec scenarios

Phase 5: Cleanup (if needed)
  └─ Documentation, remove dead code, polish
```

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

### Persist Skill Registry to .atl/

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/skill-registry/SKILL.md

Always write the skill registry to the .atl/skill-registry.md file to ensure its availability. Create the .atl/ directory if it does not exist.

```shell
mkdir -p .atl/
cat <<EOF > .atl/skill-registry.md
...
EOF
```

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

### Adversarial Review Orchestrator Pattern

Source: https://context7.com/gentleman-programming/agent-teams-lite/llms.txt

This example demonstrates the orchestrator pattern for dual-blind adversarial review, involving parallel judge agents, synthesis of findings, and delegation of fixes.

```plaintext
# Trigger phrase (any agent):
"judgment day" / "judgment-day" / "review adversarial" / "dual review"

# Orchestrator pattern:
delegate(prompt: judgePrompt, agent: "general")  # Judge A (async)
delegate(prompt: judgePrompt, agent: "general")  # Judge B (async, parallel)
# ... wait for both ...
synthesize findings → confirm/suspect/contradiction table
delegate(prompt: fixPrompt, agent: "general")    # Fix Agent
# ... re-judge ...

# Judge prompt template:
You are an adversarial code reviewer. Your ONLY job is to find problems.

## Target
src/services/export.ts, src/app/api/export/route.ts

## Project Standards (auto-resolved)
### react-19
- Server Components by default, 'use client' only for interactivity

## Review Criteria
- Correctness: Does the code do what it claims?
- Edge cases: What inputs or states aren't handled?
- Error handling: Are errors caught and propagated properly?
- Security: Any injection risks, exposed secrets?

## Return Format
Each finding:
- Severity: CRITICAL | WARNING | SUGGESTION
- File: path/to/file.ext (line N)
- Description: What is wrong and why it matters
- Suggested fix: one-line description

Always include: **Skill Resolution**: {injected|fallback-registry|fallback-path|none}

# Expected output:
## Judgment Day — export feature

### Round 1 — Verdict
| Finding | Judge A | Judge B | Severity | Status |
|---------|---------|---------|----------|--------|
| No auth check in route.ts:12 | ✅ | ✅ | CRITICAL | Confirmed |
| Missing error handling in export.ts:34 | ✅ | ❌ | WARNING | Suspect (A only) |

**Confirmed issues**: 1 CRITICAL

### Round 2 — Re-judgment
- Judge A: PASS ✅
- Judge B: PASS ✅

### JUDGMENT: APPROVED ✅
Both judges pass clean. The target is cleared for merge.
```

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

### Enable plugin tools in agent configuration

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/examples/opencode/plugins/BACKGROUND-AGENTS-README.md

Configure your agent's `tools` in `opencode.json` to include the background agent tools: `delegate`, `delegation_list`, and `delegation_read`. This allows the agent to utilize the plugin's functionality.

```json
{
  "agent": {
    "your-agent": {
      "tools": {
        "delegate": true,
        "delegation_list": true,
        "delegation_read": true,
        "bash": true,
        "edit": true,
        "read": true,
        "write": true
      }
    }
  }
}
```

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

### Engram Project Context Loading

Source: https://github.com/gentleman-programming/agent-teams-lite/blob/main/skills/_shared/engram-convention.md

Loads the full project context by searching for the initialization artifact and then retrieving its content.

```python
mem_search(query: "sdd-init/{project}", project: "{project}") → get ID
mem_get_observation(id) → full project context
```