### Install Framework Files

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Copy the framework's core directories to your project repository to begin setup.

```bash
# From the .claude-framework-adoption directory
cp -r .claude your-repo/
cp -r thoughts your-repo/
```

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

### Install Development Skills

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/README.md

Use these commands to quickly set up the new skills-based system. First, add the marketplace plugin, then install the development and team autonomy skills.

```bash
/plugin marketplace add teambrilliant/marketplace
```

```bash
/plugin install dev-skills@teambrilliant
```

```bash
/plugin install tap-skills@teambrilliant
```

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

### Manual Framework Installation

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/CLAUDE.md

Manually copy framework components to a target repository if automated installation is not feasible. This includes core framework files and the playbook.

```bash
# Manual installation (from framework repo)
cp -r .claude /path/to/target/repo/
cp -r thoughts /path/to/target/repo/
cp PLAYBOOK.md /path/to/target/repo/
```

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

### Install Framework in Target Repository

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/CLAUDE.md

Use this command to install the Claude Code framework into a target repository. It automates the setup process for AI-assisted development.

```bash
# Install framework in target repository
./setup.sh /path/to/target/repo
```

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

### Install Claude Research-Plan-Implement Framework

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Use this script to copy framework files into a target repository. It handles new installations and updates, and can optionally append metadata to CLAUDE.md.

```bash
# Install into a new repository
./setup.sh /path/to/my-project

# The script will:
# 1. Create .claude/agents/, .claude/commands/, thoughts/shared/{research,plans,sessions,cloud}/
# 2. Copy all command and agent .md files
# 3. Offer to append framework commands to existing CLAUDE.md
# 4. Create TEMPLATE.md files in research/ and plans/

# Update an existing installation (overwrite commands/agents with latest)
./setup.sh /path/to/my-project
# > Choose option 1: Update framework

# Manual installation without the script
cp -r .claude /path/to/my-project/
cp -r thoughts /path/to/my-project/
cp PLAYBOOK.md /path/to/my-project/
```

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

### Example Test Case Definitions and DSL Functions

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

This section shows example test case definitions in a Given/When/Then format using DSL function names, followed by a categorized list of required DSL functions.

```text
# ## Test Case Definitions

# 1. New Customer Orders Partner Kit — Happy Path
#
# newCustomer
# partnerKitInCart
#
# customerPlacesOrder
#
# expectOrderCreated
# expectPartnerCreatedInExigo
# expectWelcomeEmailSent

# 2. Existing Customer Upgrades to Partner via Kit
#
# existingCustomer
# partnerKitInCart
#
# customerPlacesOrder
#
# expectOrderCreated
# expectCustomerUpgradedToPartnerInExigo
# expectUpgradeEmailSent

# 3. Order Fails When Exigo Service Unavailable
#
# newCustomer
# partnerKitInCart
# exigoServiceIsDown
#
# customerPlacesOrder
#
# expectOrderPending
# expectRetryScheduled
# expectUserNotifiedOfDelay

# ## Required DSL Functions
#
# Setup (Arrange):
# - newCustomer              ← EXISTS in helpers/customer.js
# - existingCustomer         ← EXISTS
# - partnerKitInCart         ← NEEDS CREATION
# - exigoServiceIsDown       ← NEEDS CREATION
#
# Action (Act):
# - customerPlacesOrder      ← EXISTS in helpers/orders.js
#
# Assertion (Assert):
# - expectOrderCreated       ← EXISTS
# - expectPartnerCreatedInExigo     ← NEEDS CREATION
# - expectCustomerUpgradedToPartnerInExigo  ← NEEDS CREATION
# - expectWelcomeEmailSent   ← EXISTS
# - expectRetryScheduled     ← NEEDS CREATION
```

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

### Adapt CLI Project Commands to Generic

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Before adapting commands, ensure you remove framework-specific references. This example shows how to transition from a CLI project-specific command to a generic save path.

```markdown
# Before (cli project specific)
Run `cli thoughts sync`

# After (Generic)
Save to thoughts/shared/research/
```

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

### Standard Service Pattern Example

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Illustrates a typical service pattern with methods for validation, repository saving, and webhook notification. Requires an OrderRepository dependency.

```typescript
class OrderService {
  constructor(private repo: OrderRepository) {}

  async create(data: CreateOrderDto): Promise<Order> {
    const validated = await this.validate(data);
    const order = await this.repo.save(validated);
    await this.notifyWebhooks(order);
    return order;
  }
}
```

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

### Feature Implementation Plan Structure

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Example structure for a feature implementation plan, including phases, required changes, and success criteria.

```markdown
# Feature Implementation Plan

## Phase 1: Database Setup
### Changes Required:
- Add payment tables
- Migration scripts

### Success Criteria:
#### Automated:
- [ ] Migration runs successfully
- [ ] Tests pass

#### Manual:
- [ ] Data integrity verified

## Phase 2: API Integration
[...]
```

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

### Adjust Tool Commands for Project

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Customize tool commands to match your project's specific tooling. This example illustrates common adjustments for tests, linting, and building.

```markdown
# Match your project's tooling
- Tests: `npm test` → `yarn test`
- Lint: `npm run lint` → `make lint`
- Build: `npm run build` → `cargo build`
```

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

### File Discovery Agent Output Example

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

The `codebase-locator` agent provides categorized file listings for a given search term, such as 'Authentication'. It does not read file contents.

```text
# ## File Locations for: Authentication
#
# ### Implementation Files
# - src/auth/auth.service.js        — Core authentication logic
# - src/middleware/auth.js          — Request validation middleware
# - src/models/user.model.ts        — User schema
#
# ### Test Files
# - src/auth/__tests__/auth.service.test.js
# - e2e/auth.spec.js
#
# ### Configuration
# - config/auth.json                — JWT settings
# - .env.example                   — Required env vars
#
# ### Related Directories
# - src/auth/strategies/            — Contains 3 OAuth strategy files
```

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

### Customize Success Criteria

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Add project-specific checks to your success criteria. This example includes security scans, performance benchmarks, and documentation generation.

```markdown
# Add project-specific checks
- [ ] Security scan passes: `npm audit`
- [ ] Performance benchmarks met
- [ ] Documentation generated
```

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

### Implement Test Case from DSL Comments

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Actual test implementation directly mirrors the DSL comments. This example shows the implementation for the 'New Customer Orders Partner Kit' test case.

```javascript
test('1. New Customer Orders Partner Kit', async () => {
  await newCustomer();
  await partnerKitInCart();

  await customerPlacesOrder();

  await expectOrderCreated();
  await expectPartnerCreatedInExigo();
  await expectWelcomeEmailSent();
});
```

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

### Test-Driven Development Workflow Steps

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Implement a Test-Driven Development (TDD) workflow by defining test cases before writing code. This example outlines the steps from defining tests to implementing the feature.

```shell
# Step 1: Define test cases
/8_define_test_cases
> Partner enrollment when customer orders a kit product

# Output includes:
# - Test cases in comment format (happy path, edge cases, errors)
# - List of DSL functions needed (setup/action/assertion)
# - Existing functions that can be reused

# Step 2: Implement missing DSL functions
# (Follow patterns discovered by the agent)

# Step 3: Write tests using the defined test cases
# (Copy comment structure to test files, add function calls)

# Step 4: Create plan for feature implementation
/2_create_plan
> Implement partner enrollment logic to make tests pass

# Step 5: Implement the feature
/4_implement_plan
> thoughts/shared/plans/partner_enrollment.md
```

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

### Project Conventions: Git Workflow

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Outline the project's Git workflow conventions. This example specifies branching strategies, commit squashing, and commit message formatting.

```markdown
## Git Workflow
- Feature branches from develop
- Squash commits on merge
- Conventional commit messages
```

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

### Framework Settings Configuration

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/CLAUDE.md

Example of a local settings file for the Claude framework. This file typically manages permissions for bash commands like 'find' and 'ls', which are essential for codebase exploration.

```json
{
  "settings.local.json": "Permission settings (allows find/ls)"
}
```

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

### Project Conventions: Testing and Code Style

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Define project-specific conventions for testing and code style. This example outlines TDD, coverage requirements, testing frameworks, formatting, linting, and programming paradigms.

```markdown
# Project Conventions

## Testing
- Always write tests first (TDD)
- Minimum 80% coverage required
- Use Jest for unit tests

## Code Style
- Use Prettier formatting
- Follow ESLint rules
- Prefer functional programming
```

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

### Sequential Numbering Enforcement

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Example of how sequential numbering is enforced for files by checking existing files before creating a new one.

```bash
# Sequential numbering (NNN_) is enforced by checking existing files:
# ls thoughts/shared/research/   →  001_auth.md, 002_payments.md
# → next file is 003_*.md
```

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

### Chaining Commands for Complex Features

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Chain commands sequentially to manage complex features. This example demonstrates a workflow involving research, planning, implementation, and validation.

```shell
/1_research_codebase
> Research current auth system

/2_create_plan
> Based on research, plan OAuth integration

/4_implement_plan
> thoughts/shared/plans/oauth_integration.md

/3_validate_plan
> Verify OAuth implementation

# Then manually commit using git
```

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

### Parallel Research Command

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Initiate parallel research on multiple aspects simultaneously. This example shows a command to research authentication, authorization, and user management.

```shell
/1_research_codebase
> How do authentication, authorization, and user management work together?
```

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

### Define Custom Agent Metadata

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Create new agents for specific needs by defining their metadata. This example shows a 'security-analyzer' agent with specified tools.

```yaml
---
name: security-analyzer
description: Analyzes security implications
tools: Read, Grep
---

You are a security specialist...
```

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

### Cloud Infrastructure Analysis Command

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Analyze cloud deployments without making changes using a dedicated research command. This example targets Azure and analyzes resources, security, architecture, and optimization.

```shell
/7_research_cloud
> Azure
> all

# Analyzes:
- Resource inventory and costs
- Security and compliance
- Architecture patterns
- Optimization opportunities
```

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

### Codebase Analyzer Output Example

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

The `codebase-analyzer` agent provides a deep dive into code, including core logic flow, key functions, and error handling patterns, with specific file:line references.

```text
# ## Analysis: Authentication Service
#
# ### Core Logic Flow
# 1. Request enters at src/api/routes.js:45 (POST /auth/login)
# 2. Body validated in src/validators/auth.validator.js:12
# 3. Credentials checked in src/auth/auth.service.js:34
# 4. JWT signed in src/auth/token.service.js:18
# 5. Response returned with { token, refreshToken }
#
# ### Key Functions
# - authenticate() (auth.service.js:34)  — bcrypt compare + token generation
# - validateToken() (middleware/auth.js:8) — JWT verify on every protected route
# - refreshToken() (auth.service.js:67)  — Issues new access token from refresh token
#
# ### Error Handling
# - Invalid credentials → 401 AuthError
# - Expired token → 401 with refresh hint
# - DB errors → 500, logged to Sentry
```

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

### Implement Plan Command

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Execute the implementation phase by providing the path to the generated plan file.

```bash
/4_implement_plan
> thoughts/shared/plans/stripe_integration.md
```

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

### Create Plan Command

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Generate a detailed implementation plan by using the create plan command with a feature description.

```bash
/2_create_plan
> Add Stripe payment integration based on the research
```

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

### Create Implementation Plan Interactively

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Gathers requirements interactively and uses research agents to understand the codebase, then generates a phased implementation plan with success criteria.

```bash
/2_create_plan
> Add Stripe payment integration based on research in thoughts/shared/research/001_payments.md

# Claude reads research, asks clarifying questions, then saves:
# thoughts/shared/plans/001_stripe_integration.md

# Generated plan structure:
# # Stripe Payment Integration Plan
#
# ## Overview
# Integrate Stripe Checkout for one-time and subscription payments.
#
# ## Current State Analysis
# No payment system exists. Order model lacks payment_status field.
#
# ## Desired End State
# Users can complete purchases; webhooks update order status.
#
# ## What We're NOT Doing
# - No PayPal, Apple Pay in this phase
# - No refund UI (manual via Stripe dashboard)
#
# ## Phase 1: Database & Models
# ### Changes Required:
# #### 1. Order Model
# **File**: `src/models/order.model.ts`
# **Changes**: Add payment_status, stripe_payment_intent_id fields
#
# ### Success Criteria:
# #### Automated Verification:
# - [ ] Tests pass: `npm test`
# - [ ] Type checking passes: `npm run typecheck`
# #### Manual Verification:
# - [ ] Migration runs cleanly on staging
#
# ## Phase 2: Stripe Service
# [...]
```

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

### Implement Plan Phase by Phase

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Executes a saved plan, tracks progress in the plan file, and runs verification after each phase. Use this to systematically implement a project plan.

```shell
/4_implement_plan
> thoughts/shared/plans/001_stripe_integration.md

# Claude reads entire plan, creates todo list, implements phase by phase.
# After each phase it runs verification commands and updates plan checkboxes:

# In the plan file, completed items become:
# - [x] Add payment_status to Order model
# - [x] Migration runs cleanly: `npm run migrate`
# - [ ] Implement StripeService.createPaymentIntent()  ← next

# When a mismatch is found, Claude surfaces it explicitly:
# ---
# Issue in Phase 2:
# Expected: StripeService class in src/payments/stripe.service.ts
# Found: File doesn't exist; payments/ directory is missing entirely
# Why this matters: Phase 3 imports from this path
#
# How should I proceed?
# ---

```

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

### Validate Plan Implementation

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Use this command to verify that the code implementation matches the defined plan. It initiates a review of git changes, runs automated checks, and generates a validation report.

```bash
/3_validate_plan
> Validate the Stripe integration implementation
```

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

### Validate Plan Implementation

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Reviews git changes, runs automated checks, and generates a validation report. Use this to verify implementation against the plan's success criteria.

```shell
/3_validate_plan
> Validate the Stripe integration implementation

# Claude inspects git diff, runs test commands, produces report:

# ## Validation Report: Stripe Payment Integration
#
# ### Implementation Status
# ✓ Phase 1: Database & Models - Fully implemented
# ✓ Phase 2: Stripe Service - Fully implemented
# ⚠️ Phase 3: Webhook Handler - Partially implemented (signature validation missing)
#
# ### Automated Verification Results
# ✓ npm test — 142 passed, 0 failed
# ✓ npm run typecheck — No errors
# ✗ npm run lint — 2 warnings in src/payments/webhook.handler.ts
#
# ### Deviations from Plan:
# - Webhook handler placed in src/payments/ instead of src/api/webhooks/ as planned
#
# ### Manual Testing Required:
# 1. [ ] Complete a test purchase end-to-end in Stripe test mode
# 2. [ ] Verify webhook updates order status after payment confirmation
#
# ### Recommendations:
# - Add Stripe signature validation before merging
# - Move webhook handler to planned path or update plan

```

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

### Define Acceptance Test Cases with DSL

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Use this command to define acceptance test cases based on discovered codebase patterns. It outputs test case definitions and a list of required DSL functions.

```bash
/8_define_test_cases
> Partner enrollment workflow when ordering kit products
```

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

### Standard Workflow Commands

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Execute the standard workflow by invoking research, planning, and implementation commands sequentially.

```bash
/1_research_codebase
> How does user authentication work in this codebase?

/2_create_plan
> I need to add two-factor authentication

/4_implement_plan
> thoughts/shared/plans/two_factor_auth.md
```

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

### Resume Work from Session

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Restores a saved session context, including the plan, research documents, and git state. Use this to seamlessly continue work from a previous checkpoint.

```shell
/6_resume_work
> thoughts/shared/sessions/001_oauth_refactor.md

# Claude reads session → plan → research in sequence, then outputs:
# ✅ Context restored successfully!
#
# 📋 Resuming: OAuth Refactor
# 📍 Current Phase: 2 of 4
# 🎯 Next Task: Complete GitHub OAuth strategy
#
# Previous session:
# - Duration: 4h 30m
# - Completed: Phase 1 (DB), Phase 2 Google OAuth
# - Remaining: GitHub OAuth, Refresh token storage, UI provider selection
#
# Restoring stashed work...
# git stash pop stash@{0}  ✓
#
# Continuing with src/auth/strategies/github.strategy.ts...

# Pattern 2: Full context restore with path
/6_resume_work
> What was I working on last week? Find and continue it.
# Claude lists thoughts/shared/sessions/ and offers choices

```

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

### Framework Directory Structure

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Illustrates the standard directory layout for the Claude framework within a project repository.

```tree
your-repo/
├── .claude/                      # AI Assistant Configuration
│   ├── agents/                   # Specialized AI agents
│   │   ├── codebase-locator.md   # Finds relevant files
│   │   ├── codebase-analyzer.md  # Analyzes implementation
│   │   └── codebase-pattern-finder.md # Finds patterns to follow
│   └── commands/                 # Numbered workflow commands
│       ├── 1_research_codebase.md
│       ├── 2_create_plan.md
│       ├── 3_validate_plan.md
│       ├── 4_implement_plan.md
│       ├── 5_save_progress.md   # Save work session
│       ├── 6_resume_work.md     # Resume saved work
│       ├── 7_research_cloud.md  # Cloud infrastructure analysis
│       └── 8_define_test_cases.md # Design acceptance test cases
├── thoughts/                     # Persistent Context Storage
│   └── shared/
│       ├── research/            # Research findings
│       │   └── YYYY-MM-DD_*.md
│       ├── plans/               # Implementation plans
│       │   └── feature_name.md
│       ├── sessions/            # Work session summaries
│       │   └── YYYY-MM-DD_*.md
│       └── cloud/               # Cloud infrastructure analyses
│           └── platform_*.md
└── CLAUDE.md                    # Project-specific instructions
```

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

### Define Test Cases with DSL

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Design acceptance test cases before implementation using a comment-first approach. This command helps define test scenarios and identify required DSL functions.

```bash
/8_define_test_cases
> Partner enrollment workflow when ordering kit products
```

```javascript
// 1. New Customer Orders Partner Kit

// newCustomer
// partnerKitInCart
//
// customerPlacesOrder
//
// expectOrderCreated
// expectPartnerCreatedInExigo
```

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

### Resume Work Session

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Continue a previously saved work session by restoring the full context, including plan progress, research findings, and todo lists. Provide the path to the session summary file.

```bash
/6_resume_work
> thoughts/shared/sessions/2025-01-06_payment_feature.md

# Restores:
- Full context from session
- Plan progress state
- Research findings
- Todo list
```

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

### Resume Work Command

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/thoughts/shared/sessions/EXAMPLE_session.md

This command loads the context for resuming work on the authentication refactor, pointing to the relevant session file.

```bash
/6_resume_work thoughts/shared/sessions/2025-01-01_auth_refactor.md
```

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

### Project File Organization Structure

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Recommended directory structure for features within a project, including service, controller, model, test, and index files.

```plaintext
src/[feature]/
  [feature].service.ts
  [feature].controller.ts
  [feature].model.ts
  [feature].test.ts
  index.ts
```

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

### Navigate to Auth Strategies Directory

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/thoughts/shared/sessions/EXAMPLE_session.md

This bash command changes the current directory to the authentication strategies folder, a common location for strategy implementations.

```bash
cd src/auth/strategies/
```

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

### Framework Structure Overview

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/CLAUDE.md

Illustrates the directory structure of the Claude Code Research-Plan-Implement Framework. Key components include agent definitions, command scripts, and persistent storage for thoughts.

```tree
claude-research-plan-implement/
├── .claude/
│   ├── agents/                   # Specialized AI agent definitions
│   │   ├── codebase-locator.md   # Finds relevant files efficiently
│   │   ├── codebase-analyzer.md  # Analyzes code implementation details
│   │   └── codebase-pattern-finder.md # Identifies patterns to follow
│   ├── commands/                 # Numbered workflow command definitions
│   │   └── [1-6]_*.md           # Each phase of the workflow
│   └── settings.local.json      # Permission settings (allows find/ls)
├── thoughts/                     # Persistent context storage structure
│   └── shared/
│       ├── research/            # Research findings (YYYY-MM-DD_*.md)
│       ├── plans/               # Implementation plans
│       └── sessions/            # Work session summaries
├── PLAYBOOK.md                   # Comprehensive guide
├── README.md                     # Quick start guide
└── setup.sh                      # Automated installation script
```

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

### Test-Driven Workflow Commands

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Utilize the test-driven approach by defining test cases before implementing the feature.

```bash
/8_define_test_cases
> Two-factor authentication for user login

# Design tests, then implement feature
/4_implement_plan
> Implement 2FA to make tests pass
```

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

### Persistent Context Storage Structure

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Demonstrates the directory structure for storing persistent markdown files across Claude sessions, including research, plans, sessions, and cloud configurations.

```plaintext
thoughts/
└── shared/
    ├── research/
    │   ├── TEMPLATE.md               # Starter template
    │   └── 001_auth_system.md        # Generated by /1_research_codebase
    ├── plans/
    │   ├── TEMPLATE.md               # Starter template
    │   └── 001_stripe_integration.md # Generated by /2_create_plan
    ├── sessions/
    │   └── 001_oauth_refactor.md     # Generated by /5_save_progress
    └── cloud/
        └── 001_azure_production.md   # Generated by /7_research_cloud
```

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

### Authentication Testing Commands

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/thoughts/shared/sessions/EXAMPLE_session.md

These bash commands are used to run specific test suites for the authentication module and end-to-end OAuth tests.

```bash
npm run test:auth       # Run auth module tests
npm run test:e2e:oauth  # Run OAuth e2e tests
```

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

### Cross-referencing Between Documents

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Shows how session files link to their corresponding plan and research documents using frontmatter.

```markdown
# Cross-referencing between documents:
# Session file links to its plan and research:
# ---
# plan: thoughts/shared/plans/001_stripe_integration.md
# research: thoughts/shared/research/002_payment_system.md
# ---
```

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

### Save Work Progress and Session

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Saves current work state, including git diffs, plan progress, and resume instructions, to a session file. Use this to checkpoint your work and ensure continuity.

```shell
/5_save_progress
> Need to stop working on the OAuth refactor

# Claude creates: thoughts/shared/sessions/001_oauth_refactor.md
#
# ---
# date: 2025-01-06T14:30:00Z
# feature: OAuth Refactor
# plan: thoughts/shared/plans/001_oauth_refactor.md
# status: in_progress
# last_commit: abc123def456
# ---
#
# ## Accomplishments
# - ✅ Phase 1: DB schema (oauth_providers, user_oauth_connections tables)
# - ✅ Phase 2: Google OAuth strategy implemented
# - ⚠️ GitHub strategy started, not complete (src/auth/strategies/github.strategy.ts:12)
#
# ## Uncommitted Changes
# modified: src/auth/strategies/github.strategy.ts
# stash@{0}: WIP: GitHub OAuth callback handler
#
# ## Ready to Resume
# /6_resume_work thoughts/shared/sessions/001_oauth_refactor.md
# git stash pop stash@{0}

```

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

### Analyze Cloud Infrastructure (Read-Only)

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Executes read-only CLI operations against cloud providers (Azure, AWS, GCP) to generate an infrastructure analysis document. This command never creates, modifies, or deletes resources.

```shell
/7_research_cloud
> Azure
> all

# Claude verifies `az` CLI auth, then runs read-only commands:
# az vm list --output json
# az storage account list
# az network vnet list
# az security assessment list
# az consumption usage list  (cost data)

# Saves: thoughts/shared/cloud/001_azure_production.md
#
# ---
# platform: Azure
# environment: Production
# ---
#
# ## Executive Summary

```

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

### Research Codebase Command

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Initiate the research phase by invoking the codebase research command with a specific question.

```bash
/1_research_codebase
> How does the payment processing system work?
```

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

### Save Work Progress

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/PLAYBOOK.md

Pause and save your current work state, including progress checkpoints and session context. This command creates session summaries and updates the plan's progress.

```bash
/5_save_progress
> Need to stop working on the payment feature

# Creates:
- Session summary in thoughts/shared/sessions/
- Progress checkpoint in the plan
- Work status documentation
```

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

### List Modified and New Files

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/thoughts/shared/sessions/EXAMPLE_session.md

This bash snippet summarizes file changes, indicating which files were modified and which new files were created during the session.

```bash
# Summary of changes
modified: src/auth/oauth.provider.ts (180 lines)
modified: src/auth/strategies/google.strategy.ts (45 lines)
new file: src/auth/strategies/github.strategy.ts (12 lines - incomplete)
modified: database/migrations/024_add_oauth.sql (35 lines)
modified: src/models/user.model.ts (25 lines)
```

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

### GitHub OAuth Environment Variables

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/thoughts/shared/sessions/EXAMPLE_session.md

This snippet lists the necessary environment variables for configuring GitHub OAuth, including client ID, secret, and callback URL.

```env
GITHUB_CLIENT_ID=xxx
GITHUB_CLIENT_SECRET=xxx
GITHUB_CALLBACK_URL=http://localhost:3000/auth/github/callback
```

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

### Research Codebase with Parallel Agents

Source: https://context7.com/teambrilliant/claude-research-plan-implement/llms.txt

Initiates parallel sub-agents to investigate a codebase for a specific research question. Results are synthesized into a structured markdown document.

```bash
/1_research_codebase
> How does user authentication work in this codebase?

# Claude spawns agents in parallel, then generates:
# thoughts/shared/research/001_user_authentication.md
#
# Output document structure:
# ---
# date: 2025-01-06T10:00:00Z
# researcher: Claude
# topic: "How does user authentication work?"
# tags: [research, codebase, authentication]
# status: complete
# ---
#
# ## Research Question
# How does user authentication work in this codebase?
#
# ## Summary
# JWT-based auth implemented in src/auth/. Middleware in src/middleware/auth.js.
#
# ## Detailed Findings
# ### Authentication Service
# - `src/auth/auth.service.js:34` - Core authenticate() method
# - `src/middleware/auth.js:12` - Request validation middleware
#
# ## Code References
# - `src/auth/auth.service.js:34` - authenticates credentials, returns JWT
# - `src/models/user.model.ts:15` - User schema with password hash field
#
# ## Architecture Insights
# - Passwords hashed with bcrypt, tokens signed with HS256
# - Refresh tokens stored in Redis with 7-day TTL
#
# ## Open Questions
# - Is there a plan to migrate to RS256?
```

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

### Research Findings File Naming Convention

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/CLAUDE.md

Demonstrates the naming convention for research findings stored within the framework's persistent context. Files are timestamped for chronological organization.

```text
# Research findings (YYYY-MM-DD_*.md)
```

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

### Uncommitted Changes Summary

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/thoughts/shared/sessions/EXAMPLE_session.md

This bash snippet lists uncommitted changes and stashed work, useful for understanding the current state of the repository.

```bash
# Files with changes
modified: src/auth/strategies/github.strategy.ts
modified: tests/auth/oauth.test.ts

# Stashed for later
git stash@{0}: WIP: GitHub OAuth callback handler
```

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

### Restore Stashed Changes

Source: https://github.com/teambrilliant/claude-research-plan-implement/blob/main/thoughts/shared/sessions/EXAMPLE_session.md

This bash command restores stashed changes, specifically the work related to the GitHub OAuth callback handler.

```bash
git stash pop stash@{0}  # Restore GitHub OAuth work
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.