context-manager（上下文管理器）

Context Manager Skill

Purpose: Comprehensive context management operations with clear guidance, lazy loading, and safe operations for discovering, organizing, and maintaining project context.

What I Do

I provide 8 powerful operations for managing context:

1. DISCOVER - Find context files by topic or path
2. FETCH - Get external documentation from libraries
3. HARVEST - Extract context from summary files
4. EXTRACT - Pull specific information from context
5. COMPRESS - Reduce large file sizes
6. ORGANIZE - Restructure context by concern
7. CLEANUP - Remove stale or temporary files
8. PROCESS - Guided workflow for context operations

Quick Start

1. Discover Context

bash .opencode/skills/context-manager/router.sh discover authentication

Finds all context files related to authentication patterns.

2. Fetch External Documentation

bash .opencode/skills/context-manager/router.sh fetch "Drizzle ORM" "modular schemas"

Retrieves live documentation from external libraries.

3. Harvest Context

bash .opencode/skills/context-manager/router.sh harvest ANALYSIS.md

Extracts key concepts from summary files into permanent context.

4. Extract Information

bash .opencode/skills/context-manager/router.sh extract code-quality.md "naming conventions"

Pulls specific information from context files.

5. Compress Files

bash .opencode/skills/context-manager/router.sh compress .opencode/context/ 100KB

Reduces large context files to save space.

6. Organize Context

bash .opencode/skills/context-manager/router.sh organize .opencode/context/

Restructures context by concern for better organization.

7. Cleanup Stale Files

bash .opencode/skills/context-manager/router.sh cleanup .tmp/ 7

Removes temporary or old files (older than 7 days).

8. Guided Workflow

bash .opencode/skills/context-manager/router.sh process "organize authentication context" .opencode/context/

Step-by-step guidance for complex context operations.

Operations Reference

Operation 1: DISCOVER

Purpose: Find context files using intelligent discovery or direct search

When to Use:

• Need to find all context files in repository
• Looking for specific context by topic
• Mapping context structure
• Understanding what context exists

Syntax:

discover [target]

Examples:

# Discover by topic
./router.sh discover "authentication patterns"

# Discover all context
./router.sh discover "all context files"

# Discover in specific directory
./router.sh discover ".opencode/context/core/"

Output:

• List of discovered files with paths and sizes
• File statistics (count, total size, last updated)
• Categorization by type
• Suggestions for next steps

Operation 2: FETCH

Purpose: Fetch external documentation using ExternalScout

When to Use:

• Need live documentation from external libraries
• Setting up new external library integration
• Need version-specific documentation
• Want to cache external docs for team

Syntax:

fetch [libraries] [topics]

Examples:

# Fetch single library
./router.sh fetch "Drizzle ORM" "modular schemas"

# Fetch multiple libraries
./router.sh fetch "Drizzle ORM" "Better Auth" "Next.js" "modular schemas" "integration" "app router"

# Fetch with specific query
./router.sh fetch "Better Auth" "Next.js App Router integration with Drizzle adapter"

Output:

• Fetched files with paths
• File sizes and statistics
• Source URLs
• How to reference in context
• Manifest updates

Operation 3: HARVEST

Purpose: Extract context from summary files and create permanent context

When to Use:

• Have summary documents that should become context
• Need to convert temporary notes to permanent context
• Want to extract key concepts from larger documents
• Need to organize scattered information

Syntax:

harvest [source-file]

Examples:

# Harvest from analysis
./router.sh harvest DEVELOPER_PROFILE_ANALYSIS.md

# Harvest from brainstorm
./router.sh harvest AGENT_NAMING_BRAINSTORM.md

# Harvest from UX analysis
./router.sh harvest UX_ANALYSIS_THREE_MAIN_AGENTS.md

Output:

• Created context file path
• Space saved (original vs. harvested)
• Content structure
• Updated navigation files
• How to use the new context

Operation 4: EXTRACT

Purpose: Extract specific information from context files

When to Use:

• Need specific information from context
• Creating summaries or reports
• Building context bundles for subagents
• Validating context completeness

Syntax:

extract [file] [what-to-extract]

Examples:

# Extract naming conventions
./router.sh extract code-quality.md "naming conventions"

# Extract test patterns
./router.sh extract test-coverage.md "test patterns"

# Extract all standards
./router.sh extract ".opencode/context/core/" "all standards"

Output:

• Extracted information organized by topic
• Source file citations
• Relevance scores
• Usage suggestions
• Next steps

Operation 5: COMPRESS

Purpose: Compress large context files to save space

When to Use:

• Context files are very large (>100 KB)
• Need to reduce disk space usage
• Archiving old context
• Preparing context for distribution

Syntax:

compress [target] [size-threshold]

Examples:

# Compress large files
./router.sh compress ".opencode/context/" "100 KB"

# Compress all context
./router.sh compress ".opencode/context/"

# Compress and archive
./router.sh compress ".opencode/context/development/" "50 KB"

Output:

• Compressed files with paths
• Space savings (before/after)
• Compression ratio
• Decompression instructions
• Manifest updates

Operation 6: ORGANIZE

Purpose: Reorganize context files by concern (what you're doing) rather than function

When to Use:

• Context is scattered across multiple locations
• Need to reorganize by concern/topic
• Creating new context structure
• Consolidating related context

Syntax:

organize [target]

Examples:

# Organize by concern
./router.sh organize ".opencode/context/"

# Organize specific topic
./router.sh organize ".opencode/context/development/"

Output:

• Current structure analysis
• Proposed new structure
• Files moved and reorganized
• Updated references
• Navigation updates
• New structure overview

Operation 7: CLEANUP

Purpose: Clean up stale, temporary, or unused context files

When to Use:

• Removing temporary files (.tmp/)
• Deleting old external context (>7 days)
• Removing duplicate context
• Archiving unused context

Syntax:

cleanup [target] [older-than-days]

Examples:

# Cleanup .tmp directory
./router.sh cleanup ".tmp/"

# Cleanup old external context
./router.sh cleanup ".tmp/external-context/" "7"

# Cleanup stale sessions
./router.sh cleanup ".tmp/sessions/" "3"

Output:

• Files to be deleted
• Space to be freed
• Impact analysis
• Recovery instructions
• Manifest updates

Operation 8: PROCESS

Purpose: Provide guided workflow for processing context

When to Use:

• Need step-by-step guidance on context operations
• Processing multiple context files
• Learning context management workflow
• Automating context processing

Syntax:

process [goal] [scope]

Examples:

# Process authentication context
./router.sh process "organize authentication context" ".opencode/context/development/"

# Process all development context
./router.sh process "organize all development context" ".opencode/context/development/"

# Process external context
./router.sh process "fetch, persist, and reference external context" ".tmp/external-context/"

Output:

• Step-by-step workflow
• Progress indicators
• Discovered context
• Processing plan
• Execution results
• Validation results
• Summary and next steps

Common Workflows

Workflow 1: Discover & Extract

1. discover context for: "authentication"
   → Find all auth-related context

2. extract from: "security-patterns.md" what: "auth patterns"
   → Get specific patterns

3. Show results
   → Ready to use in session

Workflow 2: Fetch & Reference

1. fetch external docs for: "Drizzle ORM"
   → Get live documentation

2. Show file paths
   → .tmp/external-context/drizzle-orm/...

3. Reference in session context
   → Add to "## External Context Fetched"

4. Pass to subagents
   → Include in subtask JSONs

Workflow 3: Harvest & Organize

1. harvest context from: "ANALYSIS.md"
   → Extract key concepts

2. organize context by: "concern"
   → Restructure for clarity

3. Update documentation
   → Show new structure

4. Delete original summary
   → Clean up temporary files

Workflow 4: Cleanup & Maintain

1. cleanup .tmp/ directory
   → Remove temporary files

2. cleanup external context older than: "7 days"
   → Remove stale external docs

3. Show space freed
   → Provide statistics

4. Update manifest
   → Keep tracking accurate

Key Principles

1. Lazy Loading

• Discover files first (glob, grep)
• Load only what's needed (read specific files)
• Process incrementally (don't load entire repo)
• Reference context files, don't duplicate

2. Clear Guidance

• Explain what you're doing at each step
• Show file paths and sizes
• Provide before/after metrics
• Suggest next steps
• Ask for confirmation before destructive operations

3. Context Reference

• When discovering: cite which files found
• When processing: reference standards applied
• When organizing: show which patterns used
• When cleaning: explain what's being removed

4. Safe Operations

• Ask for confirmation before destructive ops
• Create backups when needed
• Verify integrity after operations
• Provide recovery instructions

File Structure

.opencode/skills/context-manager/
├── SKILL.md                          # This file
├── router.sh                         # CLI router (entry point)
├── CONTEXT_SKILL_QUICK_START.md      # Quick start guide
├── context-manager.md                # Detailed operation guide
└── navigation.md                     # Navigation index

Integration Points

With ContextScout

• ContextScout discovers context files
• This skill helps organize what ContextScout finds
• Can harvest context from ContextScout results

With ExternalScout

• ExternalScout fetches external documentation
• This skill persists and organizes fetched docs
• Can reference external context in operations

With TaskManager

• TaskManager references context in task definitions
• This skill ensures context files exist and are valid
• Can catalog which tasks use which context

With Other Subagents

• All subagents depend on context structure
• This skill maintains and validates context
• Can identify context gaps that subagents need

Success Criteria

You succeed when: ✅ Context files are discovered efficiently ✅ External documentation is fetched and persisted ✅ Context is harvested from summaries ✅ Key information is extracted clearly ✅ Large files are compressed safely ✅ Context is organized by concern ✅ Stale files are cleaned up safely ✅ User has clear guidance at each step ✅ All operations are reversible ✅ Documentation is updated

Tips & Best Practices

1. Regular Discovery

Run discover operations regularly to understand your context structure and identify gaps.

2. Organize by Concern

Organize context by what you're doing (authentication, testing, etc.) not by function (standards, guides).

3. Lazy Load External Docs

Fetch external documentation only when needed, not preemptively.

4. Harvest Summaries

Convert temporary analysis documents into permanent context using harvest.

5. Regular Cleanup

Schedule regular cleanup operations to remove stale temporary files.

6. Validate After Changes

Always validate context integrity after making changes.

7. Document Organization

Keep navigation.md files up-to-date as you organize context.

8. Reference Standards

When extracting context, always cite the source files.

Troubleshooting

"Context files not found"

Run discover all context files to see what exists and where.

"External docs failed to fetch"

Check that the library name is correct and ExternalScout is available.

"Harvest created empty file"

The source file may not have enough high-signal content. Review and add manually.

"Organization failed"

Check that all referenced files exist and navigation.md is valid.

"Cleanup removed too much"

Check the backup at .backup/cleanup-{date}.tar.gz for recovery.

Context Manager Skill - Discover, organize, and maintain your project context!