Process Content into Centauro Context System

Process files, folders, or information and include them in the Centauro Context Engineering system by classifying content and delegating to context-manager agents for proper integration.

Input Types

The user can provide:

1. File path - A specific file to process (e.g., PDF, markdown, code file, documentation)
2. Folder path - A directory to analyze and extract contexts from
3. Content description - Information or decisions to capture as a context
4. Multiple items - Comma-separated or space-separated paths/descriptions

User Input: $ARGUMENTS

Processing Workflow

Step 1: Identify Input Type and Content

Analyze what the user provided:

• If $ARGUMENTS contains a file path → Read and analyze the file
• If $ARGUMENTS contains a folder path → Use Glob to list files, analyze structure
• If $ARGUMENTS is descriptive text → Treat as content to capture directly
• If $ARGUMENTS contains multiple items → Process each sequentially

Use Read/Glob tools to gather content as needed.

Step 2: Content Analysis

For files:

• Read the file content using the Read tool
• Identify the type of information (methodology, knowledge, tool documentation, decision, configuration)
• Extract key sections, concepts, or patterns
• Determine relevance and scope

For folders:

• Use Glob to list files in the folder
• Identify file types and purposes
• Determine if this represents a tool/capability (c₃), knowledge base (c₂), or configuration (c₅)
• Extract representative examples or patterns

For text descriptions:

• Parse the description for context type indicators
• Identify if this is a decision (c₄), methodology (c₁), knowledge (c₂), or state (c₅)
• Structure the information for context creation

Step 3: Component Classification

Classify content into Context Engineering components:

• c₁ (Instructions) - Methodologies, workflows, procedures, how-to guides
• c₂ (Knowledge) - Domain knowledge, frameworks, reference material, terminology
• c₃ (Tools) - Code capabilities, APIs, utilities, available functions
• c₄ (Memory) - Decisions, lessons learned, historical context, rationale
• c₅ (State) - Current configuration, constraints, resources, project status

Classification Decision Tree:

Is it prescriptive (HOW to do something)?
  → c₁ Instructions

Is it descriptive knowledge (WHAT something is)?
  → c₂ Knowledge

Does it document available capabilities (WHAT can be used)?
  → c₃ Tools

Is it a decision or lesson learned (WHY/historical)?
  → c₄ Memory

Is it current project state (WHERE we are now)?
  → c₅ State

Multiple components: Some content may map to multiple components. Create separate contexts for each classification.

Step 4: Delegate to context-manager

Invoke the context-manager agent via Task tool to handle context file creation, metadata, and integration.

Prompt structure for context-manager:

Process the following content and create appropriate context file(s) in the Centauro system:

**Source:** [file path, folder path, or "user-provided description"]

**Content to process:**
[Include extracted or analyzed content]

**Classification guidance:**
- Primary component: [c₁/c₂/c₃/c₄/c₅]
- Secondary components (if applicable): [list]
- Rationale: [why this classification]

**Context requirements:**
- Apply appropriate metadata standards
- Use semantic versioning (start at v0.1.0 for new contexts)
- Validate quality using 4-dimensional framework (target B+ or higher)
- Create file(s) in `.centauro/contexts/[component]/`
- Ensure specificity and actionability
- Include concrete examples where applicable

**Filename suggestion:** [suggest based on content and classification]

Create the context file(s) following Centauro standards.

Agent delegation pattern:

• Use Task tool with appropriate subagent (context-manager or general)
• Provide structured content and clear classification guidance
• Let the agent handle file creation, validation, and integration
• Agent will apply metadata standards, versioning, and quality checks

Step 5: Report Results

Output to user:

✅ **Processing Complete**

**Source:** [original input]

**Contexts created:**
1. `[filename]` - [component] - [brief description]
   - Location: `.centauro/contexts/[component]/[filename]`
   - Quality: [grade from 4-dimensional framework]
   - Version: v0.1.0

**Component classifications:**
- [c₁/c₂/c₃/c₄/c₅]: [rationale]

**Next steps:**
- Review the generated context file(s)
- Consider related contexts that might enhance this information
- Use `/centauro:build` if you need additional contexts for a specific task

Usage Examples

Example 1: Process a Documentation File

/centauro:process docs/api-design-methodology.md

Expected flow:

1. Read docs/api-design-methodology.md
2. Analyze content → Identifies methodology/process
3. Classify as c₁ (Instructions)
4. Invoke context-manager to create .centauro/contexts/c1-instructions/api_design_methodology.md
5. Report: Created c₁ context documenting API design approach

Example 2: Process a Folder of Utilities

/centauro:process src/utils/

Expected flow:

1. Use Glob to list files in src/utils/
2. Analyze → Identifies utility functions and helpers
3. Classify as c₃ (Tools)
4. Invoke context-manager to create .centauro/contexts/c3-tools/project_utilities.md
5. Report: Created c₃ context documenting available utility functions

Example 3: Process a Decision Description

/centauro:process "We decided to use PostgreSQL over MongoDB because we need strong ACID guarantees and complex relational queries. MongoDB's flexibility wasn't worth the tradeoff for our use case."

Expected flow:

1. Parse text → Identifies architectural decision with rationale
2. Classify as c₄ (Memory)
3. Invoke context-manager to create .centauro/contexts/c4-memory/database_selection_decision.md
4. Report: Created c₄ context capturing database technology decision

Example 4: Process Configuration File

/centauro:process config/app-settings.json

Expected flow:

1. Read config/app-settings.json
2. Analyze → Identifies current configuration and constraints
3. Classify as c₅ (State)
4. Invoke context-manager to create .centauro/contexts/c5-state/application_configuration.md
5. Report: Created c₅ context documenting current app configuration

Example 5: Process Multiple Items

/centauro:process docs/methodology.pdf src/api/ config/database.yml

Expected flow:

1. Process each item sequentially
2. docs/methodology.pdf → c₁ or c₂ context
3. src/api/ → c₃ context (API capabilities)
4. config/database.yml → c₅ context (database state)
5. Report: Created 3 contexts across different components

Example 6: Process Research Notes

/centauro:process research/graphql-vs-rest-comparison.md

Expected flow:

1. Read research notes
2. Analyze → Identifies comparative knowledge
3. Classify as c₂ (Knowledge)
4. Invoke context-manager to create .centauro/contexts/c2-knowledge/api_architecture_comparison.md
5. Report: Created c₂ context with API architecture knowledge

When to Use

Use /centauro:process when you have:

• Documentation files to integrate into the context system
• Code folders that represent reusable capabilities
• Decisions or learnings to capture for future reference
• Configuration or state information to document
• Research notes or reference material to preserve
• PDFs, markdown files, or other documents to analyze and contextualize

This command bridges external content with the Centauro system by handling classification, extraction, and proper integration through the context-manager agent.

Integration Notes

This command complements other Centauro commands:

• /centauro:detect - Analyzes tasks to identify needed contexts (planning)
• /centauro:build - Creates contexts from scratch via guided interview (generation)
• /centauro:process - Integrates existing content into the system (integration)
• /centauro:reflect - Extracts learnings from sessions (retrospective)
• /centauro:setup - Initializes the infrastructure (setup)

Use process when you want to bring existing artifacts into Centauro rather than creating new contexts from scratch.