red64-cli 0.1.0

package/framework/agents/codex/.codex/commands/red64/spec-requirements.md

@@ -0,0 +1,62 @@
+---
+description: Generate comprehensive requirements for a specification
+allowed-tools: Read, Task
+argument-hint: <feature-name>
+---
+
+# Requirements Generation
+
+## Parse Arguments
+- Feature name: `$1`
+
+## Validate
+Check that spec has been initialized:
+- Verify `.red64/specs/$1/` exists
+- Verify `.red64/specs/$1/spec.json` exists
+
+If validation fails, inform user to run `/red64:spec-init` first.
+
+## Invoke Subagent
+
+Delegate requirements generation to spec-requirements-agent:
+
+Use the Task tool to invoke the Subagent with file path patterns:
+
+```
+Task(
+  subagent_type="spec-requirements-agent",
+  description="Generate EARS requirements",
+  prompt="""
+Feature: $1
+Spec directory: .red64/specs/$1/
+
+File patterns to read:
+- .red64/specs/$1/spec.json
+- .red64/specs/$1/requirements.md
+- .red64/steering/*.md
+- .red64/settings/rules/ears-format.md
+- .red64/settings/templates/specs/requirements.md
+
+Mode: generate
+"""
+)
+```
+
+## Display Result
+
+Show Subagent summary to user, then provide next step guidance:
+
+### Next Phase: Design Generation
+
+**If Requirements Approved**:
+- Review generated requirements at `.red64/specs/$1/requirements.md`
+- **Optional Gap Analysis** (for existing codebases):
+  - Run `/red64:validate-gap $1` to analyze implementation gap with current code
+  - Identifies existing components, integration points, and implementation strategy
+  - Recommended for brownfield projects; skip for greenfield
+- Then `/red64:spec-design $1 [-y]` to proceed to design phase
+
+**If Modifications Needed**:
+- Provide feedback and re-run `/red64:spec-requirements $1`
+
+**Note**: Approval is mandatory before proceeding to design phase.

package/framework/agents/codex/.codex/commands/red64/spec-status.md

@@ -0,0 +1,87 @@
+---
+description: Show specification status and progress
+allowed-tools: Bash, Read, Glob, Write, Edit, MultiEdit, Update
+argument-hint: <feature-name>
+---
+
+# Specification Status
+
+<background_information>
+- **Mission**: Display comprehensive status and progress for a specification
+- **Success Criteria**:
+  - Show current phase and completion status
+  - Identify next actions and blockers
+  - Provide clear visibility into progress
+</background_information>
+
+<instructions>
+## Core Task
+Generate status report for feature **$1** showing progress across all phases.
+
+## Execution Steps
+
+### Step 1: Load Spec Context
+- Read `.red64/specs/$1/spec.json` for metadata and phase status
+- Read existing files: `requirements.md`, `design.md`, `tasks.md` (if they exist)
+- Check `.red64/specs/$1/` directory for available files
+
+### Step 2: Analyze Status
+
+**Parse each phase**:
+- **Requirements**: Count requirements and acceptance criteria
+- **Design**: Check for architecture, components, diagrams
+- **Tasks**: Count completed vs total tasks (parse `- [x]` vs `- [ ]`)
+- **Approvals**: Check approval status in spec.json
+
+### Step 3: Generate Report
+
+Create report in the language specified in spec.json covering:
+1. **Current Phase & Progress**: Where the spec is in the workflow
+2. **Completion Status**: Percentage complete for each phase
+3. **Task Breakdown**: If tasks exist, show completed/remaining counts
+4. **Next Actions**: What needs to be done next
+5. **Blockers**: Any issues preventing progress
+
+## Critical Constraints
+- Use language from spec.json
+- Calculate accurate completion percentages
+- Identify specific next action commands
+</instructions>
+
+## Tool Guidance
+- **Read**: Load spec.json first, then other spec files as needed
+- **Parse carefully**: Extract completion data from tasks.md checkboxes
+- Use **Glob** to check which spec files exist
+
+## Output Description
+
+Provide status report in the language specified in spec.json:
+
+**Report Structure**:
+1. **Feature Overview**: Name, phase, last updated
+2. **Phase Status**: Requirements, Design, Tasks with completion %
+3. **Task Progress**: If tasks exist, show X/Y completed
+4. **Next Action**: Specific command to run next
+5. **Issues**: Any blockers or missing elements
+
+**Format**: Clear, scannable format with emojis (✅/⏳/❌) for status
+
+## Safety & Fallback
+
+### Error Scenarios
+
+**Spec Not Found**:
+- **Message**: "No spec found for `$1`. Check available specs in `.red64/specs/`"
+- **Action**: List available spec directories
+
+**Incomplete Spec**:
+- **Warning**: Identify which files are missing
+- **Suggested Action**: Point to next phase command
+
+### List All Specs
+
+To see all available specs:
+- Run with no argument or use wildcard
+- Shows all specs in `.red64/specs/` with their status
+
+think

package/framework/agents/codex/.codex/commands/red64/spec-tasks.md

@@ -0,0 +1,75 @@
+---
+description: Generate implementation tasks for a specification
+allowed-tools: Read, Task
+argument-hint: <feature-name> [-y] [--sequential]
+---
+
+# Implementation Tasks Generator
+
+## Parse Arguments
+- Feature name: `$1`
+- Auto-approve flag: `$2` (optional, "-y")
+- Sequential mode flag: `$3` (optional, "--sequential")
+
+## Validate
+Check that design has been completed:
+- Verify `.red64/specs/$1/` exists
+- Verify `.red64/specs/$1/design.md` exists
+- Determine `sequential = ($3 == "--sequential")`
+
+If validation fails, inform user to complete design phase first.
+
+## Invoke Subagent
+
+Delegate task generation to spec-tasks-agent:
+
+Use the Task tool to invoke the Subagent with file path patterns:
+
+```
+Task(
+  subagent_type="spec-tasks-agent",
+  description="Generate implementation tasks",
+  prompt="""
+Feature: $1
+Spec directory: .red64/specs/$1/
+Auto-approve: {true if $2 == "-y", else false}
+Sequential mode: {true if sequential else false}
+
+File patterns to read:
+- .red64/specs/$1/*.{json,md}
+- .red64/steering/*.md
+- .red64/settings/rules/tasks-generation.md
+- .red64/settings/rules/tasks-parallel-analysis.md (include only when sequential mode is false)
+- .red64/settings/templates/specs/tasks.md
+
+Mode: {generate or merge based on tasks.md existence}
+Instruction highlights:
+- Map all requirements to tasks and list requirement IDs only (comma-separated) without extra narration
+- Promote single actionable sub-tasks to major tasks and keep container summaries concise
+- Apply `(P)` markers only when parallel criteria met (omit in sequential mode)
+- Mark optional acceptance-criteria-focused test coverage subtasks with `- [ ]*` only when deferrable post-MVP
+"""
+)
+```
+
+## Display Result
+
+Show Subagent summary to user, then provide next step guidance:
+
+### Next Phase: Implementation
+
+**Before Starting Implementation**:
+- **IMPORTANT**: Clear conversation history and free up context before running `/red64:spec-impl`
+- This applies when starting first task OR switching between tasks
+- Fresh context ensures clean state and proper task focus
+
+**If Tasks Approved**:
+- Execute specific task: `/red64:spec-impl $1 1.1` (recommended: clear context between each task)
+- Execute multiple tasks: `/red64:spec-impl $1 1.1,1.2` (use cautiously, clear context between tasks)
+- Without arguments: `/red64:spec-impl $1` (executes all pending tasks - NOT recommended due to context bloat)
+
+**If Modifications Needed**:
+- Provide feedback and re-run `/red64:spec-tasks $1`
+- Existing tasks used as reference (merge mode)
+
+**Note**: The implementation phase will guide you through executing tasks with appropriate context and validation.

package/framework/agents/codex/.codex/commands/red64/steering-custom.md

@@ -0,0 +1,59 @@
+---
+description: Create custom steering documents for specialized project contexts
+allowed-tools: Task
+---
+
+# Red64 Custom Steering Creation
+
+## Interactive Workflow
+
+This command starts an interactive process with the Subagent:
+1. Subagent asks user for domain/topic
+2. Subagent checks for available templates
+3. Subagent analyzes codebase for relevant patterns
+4. Subagent generates custom steering file
+
+## Invoke Subagent
+
+Delegate custom steering creation to steering-custom-agent:
+
+Use the Task tool to invoke the Subagent with file path patterns:
+
+```
+Task(
+  subagent_type="steering-custom-agent",
+  description="Create custom steering",
+  prompt="""
+Interactive Mode: Ask user for domain/topic
+
+File patterns to read:
+- .red64/settings/templates/steering-custom/*.md
+- .red64/settings/rules/steering-principles.md
+
+JIT Strategy: Analyze codebase for relevant patterns as needed
+"""
+)
+```
+
+## Display Result
+
+Show Subagent summary to user:
+- Custom steering file created
+- Template used (if any)
+- Codebase patterns analyzed
+- Content overview
+
+## Available Templates
+
+Available templates in `.red64/settings/templates/steering-custom/`:
+- api-standards.md, testing.md, security.md, database.md
+- error-handling.md, authentication.md, deployment.md
+
+## Notes
+
+- Subagent will interact with user to understand needs
+- Templates are starting points, customized for project
+- All steering files loaded as project memory
+- Avoid documenting agent-specific tooling directories (e.g. `.cursor/`, `.gemini/`, `.claude/`)
+- `.red64/settings/` content should NOT be documented (it's metadata, not project knowledge)
+- Light references to `.red64/specs/` and `.red64/steering/` are acceptable; avoid other `.red64/` directories

package/framework/agents/codex/.codex/commands/red64/steering.md

@@ -0,0 +1,62 @@
+---
+description: Manage .red64/steering/ as persistent project knowledge
+allowed-tools: Read, Task, Glob
+---
+
+# Red64 Steering Management
+
+## Mode Detection
+
+**Perform detection before invoking Subagent**:
+
+Check `.red64/steering/` status:
+- **Bootstrap Mode**: Empty OR missing core files (product.md, tech.md, structure.md)
+- **Sync Mode**: All core files exist
+
+Use Glob to check for existing steering files.
+
+## Invoke Subagent
+
+Delegate steering management to steering-agent:
+
+Use the Task tool to invoke the Subagent with file path patterns:
+
+```
+Task(
+  subagent_type="steering-agent",
+  description="Manage steering files",
+  prompt="""
+Mode: {bootstrap or sync based on detection}
+
+File patterns to read:
+- .red64/steering/*.md (if sync mode)
+- .red64/settings/templates/steering/*.md
+- .red64/settings/rules/steering-principles.md
+
+JIT Strategy: Fetch codebase files when needed, not upfront
+"""
+)
+```
+
+## Display Result
+
+Show Subagent summary to user:
+
+### Bootstrap:
+- Generated steering files: product.md, tech.md, structure.md
+- Review and approve as Source of Truth
+
+### Sync:
+- Updated steering files
+- Code drift warnings
+- Recommendations for custom steering
+
+## Notes
+
+- All `.red64/steering/*.md` loaded as project memory
+- Templates and principles are external for customization
+- Focus on patterns, not catalogs
+- "Golden Rule": New code following patterns shouldn't require steering updates
+- Avoid documenting agent-specific tooling directories (e.g. `.cursor/`, `.gemini/`, `.claude/`)
+- `.red64/settings/` content should NOT be documented in steering files (settings are metadata, not project knowledge)
+- Light references to `.red64/specs/` and `.red64/steering/` are acceptable; avoid other `.red64/` directories

package/framework/agents/codex/.codex/commands/red64/validate-design.md

@@ -0,0 +1,59 @@
+---
+description: Interactive technical design quality review and validation
+allowed-tools: Read, Task
+argument-hint: <feature-name>
+---
+
+# Technical Design Validation
+
+## Parse Arguments
+- Feature name: `$1`
+
+## Validate
+Check that design has been completed:
+- Verify `.red64/specs/$1/` exists
+- Verify `.red64/specs/$1/design.md` exists
+
+If validation fails, inform user to complete design phase first.
+
+## Invoke Subagent
+
+Delegate design validation to validate-design-agent:
+
+Use the Task tool to invoke the Subagent with file path patterns:
+
+```
+Task(
+  subagent_type="validate-design-agent",
+  description="Interactive design review",
+  prompt="""
+Feature: $1
+Spec directory: .red64/specs/$1/
+
+File patterns to read:
+- .red64/specs/$1/spec.json
+- .red64/specs/$1/requirements.md
+- .red64/specs/$1/design.md
+- .red64/steering/*.md
+- .red64/settings/rules/design-review.md
+"""
+)
+```
+
+## Display Result
+
+Show Subagent summary to user, then provide next step guidance:
+
+### Next Phase: Task Generation
+
+**If Design Passes Validation (GO Decision)**:
+- Review feedback and apply changes if needed
+- Run `/red64:spec-tasks $1` to generate implementation tasks
+- Or `/red64:spec-tasks $1 -y` to auto-approve and proceed directly
+
+**If Design Needs Revision (NO-GO Decision)**:
+- Address critical issues identified
+- Re-run `/red64:spec-design $1` with improvements
+- Re-validate with `/red64:validate-design $1`
+
+**Note**: Design validation is recommended but optional. Quality review helps catch issues early.

package/framework/agents/codex/.codex/commands/red64/validate-gap.md

@@ -0,0 +1,53 @@
+---
+description: Analyze implementation gap between requirements and existing codebase
+allowed-tools: Read, Task
+argument-hint: <feature-name>
+---
+
+# Implementation Gap Validation
+
+## Parse Arguments
+- Feature name: `$1`
+
+## Validate
+Check that requirements have been completed:
+- Verify `.red64/specs/$1/` exists
+- Verify `.red64/specs/$1/requirements.md` exists
+
+If validation fails, inform user to complete requirements phase first.
+
+## Invoke Subagent
+
+Delegate gap analysis to validate-gap-agent:
+
+Use the Task tool to invoke the Subagent with file path patterns:
+
+```
+Task(
+  subagent_type="validate-gap-agent",
+  description="Analyze implementation gap",
+  prompt="""
+Feature: $1
+Spec directory: .red64/specs/$1/
+
+File patterns to read:
+- .red64/specs/$1/spec.json
+- .red64/specs/$1/requirements.md
+- .red64/steering/*.md
+- .red64/settings/rules/gap-analysis.md
+"""
+)
+```
+
+## Display Result
+
+Show Subagent summary to user, then provide next step guidance:
+
+### Next Phase: Design Generation
+
+**If Gap Analysis Complete**:
+- Review gap analysis insights
+- Run `/red64:spec-design $1` to create technical design document
+- Or `/red64:spec-design $1 -y` to auto-approve requirements and proceed directly
+
+**Note**: Gap analysis is optional but recommended for brownfield projects to inform design decisions.

package/framework/agents/codex/.codex/commands/red64/validate-impl.md

@@ -0,0 +1,68 @@
+---
+description: Validate implementation against requirements, design, and tasks
+allowed-tools: Read, Task
+argument-hint: [feature-name] [task-numbers]
+---
+
+# Implementation Validation
+
+## Parse Arguments
+- Feature name: `$1` (optional)
+- Task numbers: `$2` (optional)
+
+## Auto-Detection Logic
+
+**Perform detection before invoking Subagent**:
+
+**If no arguments** (`$1` empty):
+- Parse conversation history for `/red64:spec-impl <feature> [tasks]` patterns
+- OR scan `.red64/specs/*/tasks.md` for `[x]` checkboxes
+- Pass detected features and tasks to Subagent
+
+**If feature only** (`$1` present, `$2` empty):
+- Read `.red64/specs/$1/tasks.md` and find all `[x]` checkboxes
+- Pass feature and detected tasks to Subagent
+
+**If both provided** (`$1` and `$2` present):
+- Pass directly to Subagent without detection
+
+## Invoke Subagent
+
+Delegate validation to validate-impl-agent:
+
+Use the Task tool to invoke the Subagent with file path patterns:
+
+```
+Task(
+  subagent_type="validate-impl-agent",
+  description="Validate implementation",
+  prompt="""
+Feature: {$1 or auto-detected}
+Target tasks: {$2 or auto-detected}
+Mode: {auto-detect, feature-all, or explicit}
+
+File patterns to read:
+- .red64/specs/{feature}/*.{json,md}
+- .red64/steering/*.md
+
+Validation scope: {based on detection results}
+"""
+)
+```
+
+## Display Result
+
+Show Subagent summary to user, then provide next step guidance:
+
+### Next Steps Guidance
+
+**If GO Decision**:
+- Implementation validated and ready
+- Proceed to deployment or next feature
+
+**If NO-GO Decision**:
+- Address critical issues listed
+- Re-run `/red64:spec-impl <feature> [tasks]` for fixes
+- Re-validate with `/red64:validate-impl [feature] [tasks]`
+
+**Note**: Validation is recommended after implementation to ensure spec alignment and quality.

package/framework/agents/codex/docs/AGENTS.md

@@ -0,0 +1,68 @@
+# Red64 Spec-Driven Development
+
+This project uses Red64 for AI-assisted spec-driven development with Codex.
+
+## Project Context
+
+### Paths
+- Steering: `.red64/steering/`
+- Specs: `.red64/specs/`
+
+### Steering vs Specification
+
+**Steering** (`.red64/steering/`) - Guide AI with project-wide rules and context
+**Specs** (`.red64/specs/`) - Formalize development process for individual features
+
+### Active Specifications
+- Check `.red64/specs/` for active specifications
+- Use `/red64:spec-status [feature-name]` to check progress
+
+## Development Guidelines
+- Think in English, generate responses in English. All Markdown content written to project files (e.g., requirements.md, design.md, tasks.md, research.md, validation reports) MUST be written in the target language configured for this specification (see spec.json.language).
+
+## Minimal Workflow
+- Phase 0 (optional): `/red64:steering`, `/red64:steering-custom`
+- Phase 1 (Specification):
+  - `/red64:spec-init "description"`
+  - `/red64:spec-requirements {feature}`
+  - `/red64:validate-gap {feature}` (optional: for existing codebase)
+  - `/red64:spec-design {feature} [-y]`
+  - `/red64:validate-design {feature}` (optional: design review)
+  - `/red64:spec-tasks {feature} [-y]`
+- Phase 2 (Implementation): `/red64:spec-impl {feature} [tasks]`
+  - `/red64:validate-impl {feature}` (optional: after implementation)
+- Progress check: `/red64:spec-status {feature}` (use anytime)
+
+## Development Rules
+- 3-phase approval workflow: Requirements → Design → Tasks → Implementation
+- Human review required each phase; use `-y` only for intentional fast-track
+- Keep steering current and verify alignment with `/red64:spec-status`
+- Follow the user's instructions precisely, and within that scope act autonomously
+
+## Steering Configuration
+- Load entire `.red64/steering/` as project memory
+- Default files: `product.md`, `tech.md`, `structure.md`
+- Custom files are supported (managed via `/red64:steering-custom`)
+
+## Agent Capabilities
+
+This project is configured for use with OpenAI Codex. The agent has access to:
+- File system operations (read, write, edit)
+- Code search and navigation
+- Terminal commands (bash)
+- Web search for documentation
+
+## Commands
+
+The following spec-driven development commands are available in `.codex/commands/red64/`:
+- `spec-init` - Initialize a new specification
+- `spec-requirements` - Generate EARS-format requirements
+- `spec-design` - Create technical design
+- `spec-tasks` - Generate implementation tasks
+- `spec-impl` - Execute tasks with TDD
+- `spec-status` - Check specification progress
+- `steering` - Manage project steering
+- `steering-custom` - Create custom steering documents
+- `validate-gap` - Analyze implementation gaps
+- `validate-design` - Review design quality
+- `validate-impl` - Validate implementation