@namch/agent-assistant 1.1.0 → 1.2.0

package/commands/test/team.md

@@ -0,0 +1,303 @@
+---
+description: "🔺 Team Test — Golden Triangle adversarial collaboration for maximum quality testing"
+version: "2.0"
+category: testing
+execution-mode: execute
+---
+
+# /test:team — Golden Triangle Test & Quality Assurance
+
+> **MISSION**: Maximum quality testing through adversarial collaboration.
+> Each phase spawns a **Golden Triangle** of 3 agents: Tech Lead (coordinator),
+> Executor (implementer), Reviewer (devil's advocate). Tests are released ONLY
+> upon consensus after debate.
+
+<scope>$ARGUMENTS</scope>
+
+---
+
+## 🛑 PRE-FLIGHT (DO FIRST — BLOCKS PHASE 1)
+
+**LOAD now** (in order; path `./rules/` or `~/.{TOOL}/skills/agent-assistant/rules/`):
+
+1. CORE.md — Identity, Laws, Routing
+2. PHASES.md — Phase Execution
+3. AGENTS.md — Tiered Execution
+4. **TEAMS.md** — Golden Triangle protocol (MANDATORY)
+
+**⛔ Do not run Phase 1 until all are loaded.** Follow **all** rules in those files; they override any conflicting instructions in this file.
+
+**Skills Resolution**: Load `SKILLS.md` on-demand for fitness calculation and dynamic discovery.
+
+---
+
+## 🔀 TIERED EXECUTION
+
+> Reference: AGENTS.md (Tiered Execution) + TEAMS.md (Golden Triangle Protocol)
+
+| Tier       | When                          | Action                                                                    |
+| ---------- | ----------------------------- | ------------------------------------------------------------------------- |
+| **TIER 1** | runSubagent/Agent Tool EXISTS | Orchestrator spawns Tech Lead → Tech Lead spawns Executor + Reviewer      |
+| **TIER 2** | Tool MISSING or SYSTEM error  | EMBODY Tech Lead → EMBODY Executor → EMBODY Reviewer → EMBODY Tech Lead  |
+
+**❌ Anti-Lazy**: Never use TIER 2 when TIER 1 tool available.
+
+**TIER 2 Golden Triangle Embodiment**: EMBODY Tech Lead (decompose) → EMBODY Executor (implement) → EMBODY Reviewer (review) → IF FAIL loop max 3 → EMBODY Tech Lead (arbitrate + synthesize)
+
+---
+
+## 📬 MAILBOX — Central Communication Hub
+
+**Location**: `./reports/MAILBOX-{date}.md` — All 3 triangle agents READ + APPEND. Never overwrite.
+
+**Message Types**: `TASK_ASSIGNMENT` (Lead→Executor) · `SUBMISSION` (Executor→Reviewer) · `REVIEW` (Reviewer→Executor: PASS/FAIL) · `DEFENSE` / `RESUBMISSION` (Executor→Reviewer) · `APPROVAL` (Reviewer→Lead) · `ESCALATION` (Any→Lead) · `ARBITRATION` / `DECISION` (Lead→All)
+
+**Format**: `[{TIMESTAMP}] {TYPE} | {AGENT} → {TARGET} | Phase: {n} | Task: {id} | Content: ...`
+
+---
+
+## 📁 DELIVERABLE FILES
+
+| Phase / Team     | Output                                          |
+| ---------------- | ----------------------------------------------- |
+| Phase 1          | `./reports/tests/TEST-STRATEGY-{scope}.md`      |
+| Phase 2          | `./reports/tests/TEST-PLAN-{scope}.md`          |
+| Phase 3          | Test files written to codebase                  |
+| Phase 4          | `./reports/tests/TEST-RESULTS-{scope}.md`       |
+| Phase 4          | `./reports/qa/QA-{scope}.md`                    |
+| ALL Phases       | `./reports/MAILBOX-{date}.md`                   |
+
+All files in `./reports/` → English only.
+
+---
+
+## 🔗 PHASE DEPENDENCIES
+
+| Phase                           | Requires                            | Blocking    |
+| ------------------------------- | ----------------------------------- | ----------- |
+| P1: Test Strategy               | User scope + codebase access        | No          |
+| P2: Test Planning               | TEST-STRATEGY from P1               | **YES**     |
+| P3: Test Implementation         | TEST-PLAN from P2                   | **YES**     |
+| P4: Coverage & Verification     | Tests from P3 + code under test     | **YES**     |
+
+**⛔ Blocking**: If input missing → STOP → Create it first → Resume
+
+---
+
+## ⛔ INCREMENTAL EXECUTION (MANDATORY)
+
+One phase at a time. Within each phase, follow the **Golden Triangle Loop**:
+
+```
+1. Tech Lead decomposes → Shared Task List → TASK_ASSIGNMENT to Mailbox
+2. Executor works tasks → SUBMISSION to Mailbox (what, files, approach)
+3. Reviewer critiques → REVIEW to Mailbox (PASS or FAIL + findings)
+4. IF FAIL → debate loop: fix/defend → re-review (max 3 rounds)
+   → After 3 rounds unresolved → ESCALATION to Tech Lead → ARBITRATION
+5. IF PASS → APPROVAL → task ✅
+6. All tasks done → Tech Lead verifies coherence → DECISION + consensus stamp
+```
+
+**Consensus Stamp** (required per phase): `✅ CONSENSUS: {TechLead} ✓ | {Executor} ✓ | {Reviewer} ✓`
+
+Format: rules/PHASES.md § Phase output + rules/TEAMS.md § Golden Triangle Phase Output Format.
+
+---
+
+## 🎭 Phase 1: TEST STRATEGY — 🔺 GOLDEN TRIANGLE
+
+| Role      | Agent                                | Mission                                                    |
+| --------- | ------------------------------------ | ---------------------------------------------------------- |
+| Tech Lead | `tester`                             | Decompose: test strategy, coverage targets, test types needed |
+| Executor  | `scouter`                            | Execute: analyze codebase, identify testable units, map dependencies |
+| Reviewer  | `tech-lead` (Devil's Advocate)       | Challenge: is strategy complete? Missing test categories? Over-testing? |
+
+**Triangle Loop**:
+1. `tester` decomposes into areas: test pyramid, coverage targets, framework selection, test data needs → TASK_ASSIGNMENT to `scouter`
+2. `scouter` analyzes codebase → SUBMISSION per area: testable units inventory, dependency graph, coverage gaps, complex logic paths, external deps requiring mocks
+3. `tech-lead` reviews → REVIEW: pyramid appropriate? Targets realistic? Missing categories (contract, smoke, regression)? Over-testing low-risk areas? Framework fits CI/CD?
+4. Debate loop if FAIL → max 3 rounds → ESCALATION to `tester` if unresolved
+5. `tester` synthesizes approved findings into unified test strategy
+
+**Deliverable**: `./reports/tests/TEST-STRATEGY-{scope}.md`
+**Exit Criteria**: Test pyramid defined, coverage targets set, frameworks chosen, testable units mapped
+**Consensus**: ✅ CONSENSUS: tester ✓ | scouter ✓ | tech-lead ✓
+
+---
+
+## 🎭 Phase 2: TEST PLANNING — 🔺 GOLDEN TRIANGLE
+
+| Role      | Agent                                | Mission                                                    |
+| --------- | ------------------------------------ | ---------------------------------------------------------- |
+| Tech Lead | `tester`                             | Decompose: test plan with specific test cases per component |
+| Executor  | `researcher`                         | Execute: research testing patterns, edge cases, boundary conditions |
+| Reviewer  | `security-engineer` (Devil's Advocate) | Challenge: security test cases missing? Edge cases not covered? Injection tests? |
+
+**Prerequisite**: **READ** `./reports/tests/TEST-STRATEGY-{scope}.md` before starting.
+
+**Triangle Loop**:
+1. `tester` reads strategy → decomposes into: unit test cases, integration scenarios, E2E journeys, security cases, perf benchmarks → TASK_ASSIGNMENT to `researcher`
+2. `researcher` researches patterns → SUBMISSION per area: specific test cases (inputs/outputs/edges), boundary conditions, equivalence partitions, mock strategies, test data approaches
+3. `security-engineer` reviews → REVIEW: injection tests (SQL/XSS/command)? Auth bypass? IDOR/privilege escalation? Input validation (null/overflow/special chars)? Race conditions? Error message leakage?
+4. Debate loop if FAIL → max 3 rounds → ESCALATION to `tester` if unresolved
+5. `tester` synthesizes approved test cases into final test plan
+
+**Deliverable**: `./reports/tests/TEST-PLAN-{scope}.md`
+**Exit Criteria**: Every component has specific test cases, edge cases documented, security scenarios covered
+**Consensus**: ✅ CONSENSUS: tester ✓ | researcher ✓ | security-engineer ✓
+
+---
+
+## 🛡️ VERIFICATION CHECKPOINT
+
+> **⛔ BLOCKING**: `rules/CONTEXT-GATE.md` — HARD MODE. Prevents context rot between planning and implementation.
+> Trigger: After Phase 2 completes. Plan file: `TEST-PLAN-{scope}.md`. Remaining: Phase 3 → 4.
+
+**DO NOT proceed to Phase 3 until user selects option.**
+
+---
+
+## 🎭 Phase 3: TEST IMPLEMENTATION — 🔺 GOLDEN TRIANGLE (CRITICAL)
+
+> **THIS IS THE MOST CRITICAL PHASE.** Every step is detailed. No shortcuts.
+
+### Team Selection
+
+```
+Fullstack → Tech Lead: tester | Executor: backend-engineer then frontend-engineer | Reviewer: reviewer + perf lens
+Backend  → Tech Lead: tester | Executor: backend-engineer | Reviewer: reviewer + perf lens
+Frontend → Tech Lead: tester | Executor: frontend-engineer | Reviewer: reviewer + perf lens
+Self     → Tech Lead: tester | Executor: tester (self) | Reviewer: reviewer + perf lens
+```
+
+| Role      | Agent                                                    | Mission                                                    |
+| --------- | -------------------------------------------------------- | ---------------------------------------------------------- |
+| Tech Lead | `tester`                                                 | Load TEST-PLAN → decompose into test writing tasks → Shared Task List → coordinate all work |
+| Executor  | `tester` (self) OR `backend-engineer`/`frontend-engineer`| Follow plan EXACTLY → write tests per spec → submit via Mailbox |
+| Reviewer  | `reviewer` + `performance-engineer` lens                 | Review EVERY submission → check test quality, assertions, mocks, coverage |
+
+**Prerequisite**: **READ and FOLLOW** `./reports/tests/TEST-PLAN-{scope}.md`
+
+### GOLDEN TRIANGLE IMPLEMENTATION LOOP (CRITICAL — Step by Step)
+
+```
+╔══════════════════════════════════════════════════════════════════════╗
+║  PHASE 3: TEST IMPLEMENTATION LOOP — FOLLOW EXACTLY                 ║
+╠══════════════════════════════════════════════════════════════════════╣
+║                                                                      ║
+║  STEP 1: Tech Lead reads TEST-PLAN-{scope}.md                       ║
+║  - Load full test plan, identify all tasks, determine ordering       ║
+║                                                                      ║
+║  STEP 2: Tech Lead creates Shared Task List                          ║
+║  - Break into atomic tasks: unit→integration→E2E→security→perf      ║
+║  - Format: [ID] [Status] [Description] [Files] [Acceptance]         ║
+║  - Post as TASK_ASSIGNMENT to Mailbox                                ║
+║                                                                      ║
+║  STEP 3: Dispatch — each TASK_ASSIGNMENT includes:                   ║
+║  - Task ID, test files to create, cases from plan, mock reqs,       ║
+║    coverage target                                                   ║
+║                                                                      ║
+║  STEP 4: FOR EACH TASK — Executor writes tests                       ║
+║  a. Read TASK_ASSIGNMENT → write tests EXACTLY as plan specifies     ║
+║  b. Post SUBMISSION: Task | Tests written | Files | Cases covered    ║
+║     | Mocks used | Self-review notes | Plan step reference           ║
+║                                                                      ║
+║  STEP 5: Reviewer reviews each SUBMISSION                            ║
+║  c. Check 5 dimensions:                                              ║
+║     1. ASSERTIONS — meaningful, not trivial?                         ║
+║     2. COVERAGE — edge cases, boundaries, error paths?               ║
+║     3. MOCKS — appropriate? Over-mocking hiding bugs?                ║
+║     4. PLAN COMPLIANCE — matches test plan exactly?                  ║
+║     5. TEST QUALITY — isolated, deterministic, readable?             ║
+║  d. Post REVIEW: PASS/FAIL + findings table (severity + action)      ║
+║                                                                      ║
+║  STEP 6: IF FAIL — Debate Loop (max 3 rounds)                       ║
+║  e. Executor reads findings, for EACH:                               ║
+║     - VALID → fix test + note what was fixed                         ║
+║     - DISPUTED → DEFENSE with evidence/reasoning                     ║
+║  f. Post RESUBMISSION/DEFENSE: Task | Round | Fixes | Defenses      ║
+║  g. Reviewer re-reviews → back to step (c)                          ║
+║  h. After round 3 unresolved → ESCALATION → Tech Lead ARBITRATION   ║
+║                                                                      ║
+║  STEP 7: IF PASS → APPROVAL → task ✅ → next task                   ║
+║                                                                      ║
+║  STEP 8: After ALL tasks complete                                    ║
+║  i. Tech Lead verifies: all ✅ | no conflicts | mock consistency    ║
+║     | test independence (no shared state)                             ║
+║  j. Posts DECISION: Phase 3 COMPLETE | tasks {n}/{n} |               ║
+║     disputes {n} | arbitrations {n}                                  ║
+║     ✅ CONSENSUS: tester ✓ | {executor} ✓ | reviewer ✓              ║
+║  k. Phase output released                                            ║
+╚══════════════════════════════════════════════════════════════════════╝
+```
+
+### STRICT PLAN ADHERENCE (ENFORCED BY REVIEWER)
+
+```
+1. READ TEST PLAN FIRST — every test MUST trace to a plan test case
+2. IF test case seems wrong → STOP → ESCALATION → Tech Lead evaluates
+3. NO unauthorized test additions — Reviewer checks: "Any tests not in plan?"
+4. Unauthorized deviations → automatic FAIL: CRITICAL | "Remove or get plan amended"
+```
+
+**Exit Criteria**: All plan test cases implemented, all reviews passed, no unauthorized deviations, test suite integration verified
+**Consensus**: ✅ CONSENSUS: tester ✓ | {executor} ✓ | reviewer ✓
+
+---
+
+## 🎭 Phase 4: COVERAGE & VERIFICATION — 🔺 GOLDEN TRIANGLE
+
+| Role      | Agent                                | Mission                                                    |
+| --------- | ------------------------------------ | ---------------------------------------------------------- |
+| Tech Lead | `tester`                             | Synthesize: coverage report, gap analysis, quality gate evaluation |
+| Executor  | `tester` (self-executes)             | Execute: run all tests, generate coverage report, collect metrics |
+| Reviewer  | `tech-lead` (Devil's Advocate)       | Challenge: coverage sufficient? Brittle tests? False positives? |
+
+**Triangle Loop**:
+1. `tester` (Tech Lead) decomposes: test execution, coverage analysis, quality gates, gap identification → TASK_ASSIGNMENT to self
+2. `tester` (Executor) runs full suite → SUBMISSION: pass/fail per category, coverage metrics (line/branch/function), quality gate eval, failure analysis (code bugs vs test flaws vs flaky), plan checkpoint verification
+3. `tech-lead` reviews → REVIEW: gaming metrics with trivial tests? Brittle tests? False positives? Flaky tests (shared state)? Missing negative tests? Maintainable long-term?
+4. Debate loop if FAIL → max 3 rounds → `tester` synthesizes final QA report
+
+**PLAN CHECKPOINT VERIFICATION** (if PLAN exists):
+```
+FOR EACH AC in PLAN-{scope}.md → map to test → tech-lead confirms not trivial → "AC-{id} → Test: {name} → {pass/fail}"
+```
+
+**QUALITY GATES** (all must pass for ✅):
+```
+Coverage: unit ≥ strategy target | integration: critical paths exercised | E2E: journeys pass
+Test Health: no flaky | no false positives | assertions meaningful
+Security: injection passed | auth bypass covered | input validation verified
+Performance: no regressions beyond threshold | baselines established
+```
+
+**Deliverable**: `./reports/tests/TEST-RESULTS-{scope}.md` + `./reports/qa/QA-{scope}.md`
+**Exit Criteria**: All tests run, quality gates evaluated, coverage verified, no brittle/flaky tests, report complete
+**Consensus**: ✅ CONSENSUS: tester ✓ | tester(exec) ✓ | tech-lead ✓
+
+---
+
+## ✅ COMPLETION
+
+```markdown
+# 🔺 Golden Triangle Test Report: {scope}
+
+## Phase Results
+| Phase | Triangle | Consensus | Rounds |
+|-------|----------|-----------|--------|
+| P1: Test Strategy | tester / scouter / tech-lead | ✅ | {n} |
+| P2: Test Planning | tester / researcher / security-engineer | ✅ | {n} |
+| P3: Test Implementation | tester / {executor} / reviewer | ✅ | {n} |
+| P4: Coverage & Verification | tester / tester / tech-lead | ✅ | {n} |
+
+## Summary
+Submissions: {n} | First-pass: {n} | Debates: {n} | Arbitrations: {n}
+Coverage: {pass/fail} | Health: {pass/fail} | Security: {pass/fail} | Perf: {pass/fail}
+Mailbox: `./reports/MAILBOX-{date}.md`
+
+## Next Actions
+1. ✅ **All Pass** → quality gates met (triangle-validated)
+2. ⚠️ **Partial** → failures categorized by severity
+3. 🔧 **Fix** → `/fix:team` | 📝 **Review** → `/review` | 🚀 **Deploy** → `/deploy:preview`
+```

package/commands/test.md

@@ -36,6 +36,9 @@ IF scope is comprehensive (full suite, E2E):
 IF scope is comprehensive AND clean execution focus is critical:
   → Route to /test:focus
 
+IF scope is comprehensive AND maximum quality with team collaboration needed:
+  → Route to /test:team
+
 IF unsure:
   → Default to /test:fast
 ```
@@ -49,6 +52,7 @@ IF unsure:
 | `/test:fast`   | Quick tests, unit tests                            |
 | `/test:hard`   | Full test suite, E2E                               |
 | `/test:focus` | Full testing with **enforced context optimization** |
+| `/test:team`  | Maximum quality with parallel agent team collaboration |
 
 ---
 
@@ -64,6 +68,7 @@ IF unsure:
 1. ⚡ **Fast** → `/test:fast` — Quick tests
 2. ⚡⚡⚡ **Hard** → `/test:hard` — Comprehensive testing
 3. 🔒 **Focus** → `/test:focus` — Comprehensive testing with **automatic context clearing** (focused execution)
+4. 👥 **Team** → `/test:team` — Full team collaboration (parallel agents, maximum quality)
 
 ⏳ Awaiting selection...
 ```

package/documents/SMART-SKILL-ORCHESTRATION-BLUEPRINT.md

@@ -37,13 +37,13 @@ The solution is a **Hybrid Skill Orchestration Layer** (HSOL) that:
 
 ## Prerequisites
 
-Before HSOL can function, the **find-skills** skill must exist at `{SKILLS_PATH}/find-skills/SKILL.md`, where **{SKILLS_PATH}** is the skills path for the **tool the user is currently using** (e.g. Cursor: `~/.cursor/skills/`, Copilot: `~/.copilot/skills/`, Antigravity: `~/.gemini/antigravity/skills/`). All verify and install actions apply **only to the current tool**; do not verify or install for all tools unless the user explicitly runs `install --all`.
+Before HSOL can function, the **find-skills** skill must exist at `{SKILLS_PATH}/find-skills/SKILL.md`, where **{SKILLS_PATH}** is the skills path for the **tool the user is currently using** (e.g. Cursor: `~/.cursor/skills/`, Copilot: `~/.copilot/skills/`, Codex: `~/.codex/skills/`, Antigravity: `~/.gemini/antigravity/skills/`). All verify and install actions apply **only to the current tool**; do not verify or install for all tools unless the user explicitly runs `install --all`.
 
 **Installation (current tool only, skip confirmation when using npx):**
 
 ```bash
 # Option 1: Automatic when user installs agent-assistant for a tool
-# User runs: npm run install:cursor (or install:copilot, install:antigravity)
+# User runs: npm run install:cursor (or install:copilot, install:antigravity, install:codex)
 # The CLI copies skills/ (including find-skills) to that tool's path only.
 
 # Option 2: Manual copy to CURRENT TOOL's path only
@@ -51,6 +51,8 @@ Before HSOL can function, the **find-skills** skill must exist at `{SKILLS_PATH}
 cp -r skills/find-skills ~/.cursor/skills/
 # For Copilot:
 cp -r skills/find-skills ~/.copilot/skills/
+# For Codex:
+cp -r skills/find-skills ~/.codex/skills/
 # For Antigravity:
 cp -r skills/find-skills ~/.gemini/antigravity/skills/
 # Do not copy to all tools unless the user explicitly wants that.

package/documents/business/business-prd.md

@@ -179,7 +179,8 @@ AI coding assistants are powerful but unstructured. Developers use AI tools in a
 | FR-005.2 | System SHALL support Cursor | Must-Have | ✅ Complete |
 | FR-005.3 | System SHALL support GitHub Copilot | Must-Have | ✅ Complete |
 | FR-005.4 | System SHALL support Antigravity/Gemini | Must-Have | ✅ Complete |
-| FR-005.5 | System SHALL provide CLI installer for all tools | Must-Have | ✅ Complete |
+| FR-005.5 | System SHALL support OpenAI Codex | Must-Have | ✅ Complete |
+| FR-005.6 | System SHALL provide CLI installer for all tools | Must-Have | ✅ Complete |
 
 #### FR-006: Documentation Generation
 

package/documents/business/business-workflows.md

@@ -31,7 +31,7 @@ Agent Assistant provides structured workflows for all phases of software develop
 **Prerequisites**:
 
 - Node.js 18+ installed
-- At least one supported AI tool (Claude Code, Cursor, Copilot, Antigravity)
+- At least one supported AI tool (Claude Code, Cursor, Copilot, Codex, Antigravity)
 
 **Workflow Diagram**:
 
@@ -45,7 +45,7 @@ Agent Assistant provides structured workflows for all phases of software develop
 ┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
 │    Ready to     │◀────│    Verify       │◀────│  Choose tool:   │
 │      use!       │     │  installation   │     │ cursor/copilot/ │
-└─────────────────┘     └─────────────────┘     │  antigravity    │
+└─────────────────┘     └─────────────────┘     │ codex/antigrav. │
                                                 └─────────────────┘
 ```
 

package/documents/knowledge-architecture.md

@@ -13,7 +13,7 @@ Agent Assistant is a **multi-agent orchestration framework** that transforms a s
 ```
 ┌─────────────────────────────────────────────────────────────────────────────┐
 │                              USER INTERFACE                                  │
-│  (Claude Code / Cursor / Copilot / Antigravity)                             │
+│  (Claude Code / Cursor / Copilot / Codex / Antigravity)                     │
 └─────────────────────────────────────────────────────────────────────────────┘
                                       │
                                       ▼
@@ -495,17 +495,17 @@ jit_loading:
 │                        CLI INSTALLER (cli/install.js)                        │
 └────────────────────────────────────┬────────────────────────────────────────┘
                                      │
-         ┌───────────────────────────┼───────────────────────────┐
-         ▼                           ▼                           ▼
-┌─────────────────┐       ┌─────────────────┐       ┌─────────────────┐
-│     CURSOR      │       │     COPILOT     │       │   ANTIGRAVITY   │
-├─────────────────┤       ├─────────────────┤       ├─────────────────┤
-│ ~/.cursor/      │       │ ~/.copilot/     │       │ ~/.gemini/      │
-│ ├─ rules/       │       │ ├─ commands/    │       │ └─ antigravity/ │
-│ ├─ commands/    │       │ ├─ skills/      │       │     ├─ agents/  │
-│ ├─ agents/      │       │ ├─ agents/      │       │     ├─ commands/│
-│ └─ skills/      │       │ └─ matrix-skills│       │     └─ skills/  │
-└─────────────────┘       └─────────────────┘       └─────────────────┘
+         ┌──────────────┬────────────┼────────────┬──────────────┐
+         ▼              ▼            ▼            ▼              ▼
+┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
+│     CURSOR      │ │     COPILOT     │ │   ANTIGRAVITY   │ │   CLAUDE CODE   │ │      CODEX      │
+├─────────────────┤ ├─────────────────┤ ├─────────────────┤ ├─────────────────┤ ├─────────────────┤
+│ ~/.cursor/      │ │ ~/.copilot/     │ │ ~/.gemini/      │ │ ~/.claude/      │ │ ~/.codex/       │
+│ ├─ rules/       │ │ ├─ commands/    │ │ └─ antigravity/ │ │ ├─ commands/    │ │ ├─ commands/    │
+│ ├─ commands/    │ │ ├─ skills/      │ │     ├─ agents/  │ │ ├─ skills/      │ │ ├─ skills/      │
+│ ├─ agents/      │ │ ├─ agents/      │ │     ├─ commands/│ │ ├─ agents/      │ │ ├─ agents/      │
+│ └─ skills/      │ │ └─ matrix-skills│ │     └─ skills/  │ │ └─ matrix-skills│ │ └─ matrix-skills│
+└─────────────────┘ └─────────────────┘ └─────────────────┘ └─────────────────┘ └─────────────────┘
 ```
 
 ### 6.2 Entry Point Files
@@ -515,6 +515,7 @@ jit_loading:
 | Claude Code | `CLAUDE.md` | `~/.claude/` |
 | Cursor | `rules/agent-assistant.mdc` | `~/.cursor/rules/` |
 | Copilot | `agent-assistant.agent.md` | `~/.copilot/` + VS Code prompts |
+| Codex | `AGENTS.md` (primary), `CODEX.md` (compat) | `~/.codex/` |
 | Antigravity | `GEMINI.md` | `~/.gemini/` |
 
 ---

package/documents/knowledge-domain.md

@@ -365,11 +365,11 @@ The CLI provides a command-line interface for installation and management.
 ```bash
 # Install framework for a tool
 agent-assistant install <tool>
-agent-assistant install cursor|copilot|antigravity|claude|--all
+agent-assistant install cursor|copilot|antigravity|claude|codex|--all
 
 # Uninstall framework from a tool
 agent-assistant uninstall <tool>
-agent-assistant uninstall cursor|copilot|antigravity|claude|--all
+agent-assistant uninstall cursor|copilot|antigravity|claude|codex|--all
 
 # List installation status
 agent-assistant list

package/documents/knowledge-overview.md

@@ -53,7 +53,7 @@ With Agent Assistant:
 | Matrix Domains    | 19    | Skill categories (backend, frontend, security, ai-ml, etc.)       |
 | Quality Gates     | 5     | Compile, lint, test, security, review                      |
 | Rule Files        | 8     | Orchestration protocols                                    |
-| Supported Tools   | 4     | Claude Code, Cursor, Copilot, Antigravity/Gemini           |
+| Supported Tools   | 5     | Claude Code, Cursor, Copilot, Codex, Antigravity/Gemini    |
 
 ### Measured Results
 
@@ -165,7 +165,7 @@ Load rules   Delegate   Delegate      Delegate    Summary
 ### Prerequisites
 
 - **Node.js 18+** installed
-- At least one supported AI tool (Claude Code, Cursor, Copilot, or Antigravity)
+- At least one supported AI tool (Claude Code, Cursor, Copilot, Codex, or Antigravity)
 
 ### Installation Options
 

package/documents/knowledge-source-base.md

@@ -19,6 +19,7 @@ agent-assistant/                     # Project root
 ├── skills/                          # 💡 310 domain skill definitions
 ├── AGENT-TEMPLATE.md                # 📝 Agent file template
 ├── CLAUDE.md                        # 🟣 Claude Code entry point
+├── CODEX.md                         # 💻 OpenAI Codex entry point
 ├── COPILOT.md                       # 🔵 GitHub Copilot entry point
 ├── CURSOR.md                        # 🟢 Cursor entry point
 ├── GEMINI.md                        # 🟡 Antigravity/Gemini entry point
@@ -255,6 +256,8 @@ code-assistants/
 │   └── GEMINI.md
 ├── claude-assistant/                # Claude Code integration
 │   └── CLAUDE.md
+├── codex-assistant/                 # OpenAI Codex integration
+│   └── CODEX.md
 ├── copilot-assistant/               # GitHub Copilot integration
 │   └── agent-assistant.agent.md
 └── cursor-assistant/                # Cursor integration
@@ -267,6 +270,7 @@ code-assistants/
 | Tool | Entry File | Method |
 |------|------------|--------|
 | Claude Code | `~/.claude/CLAUDE.md` | CLI → `~/.claude/` |
+| Codex | `~/.codex/AGENTS.md` (primary), `~/.codex/CODEX.md` (compat) | CLI → `~/.codex/` |
 | Cursor | agent-assistant.mdc | MDC rule file injection |
 | Copilot | agent-assistant.agent.md | VS Code prompts |
 | Antigravity | GEMINI.md | Global config |
@@ -325,7 +329,7 @@ All tool entry points follow the same pattern:
 ```markdown
 # ⚡ AGENT ASSISTANT v2.0
 
-> **LOAD**: `{HOME}/.cursor/skills/agent-assistant/rules/BOOTSTRAP.md`
+> **LOAD**: `{TOOL}/.cursor/skills/agent-assistant/rules/BOOTSTRAP.md`
 > **This file is the ENTRY POINT. BOOTSTRAP.md contains all orchestration rules.**
 
 ## 🆔 IDENTITY
@@ -521,17 +525,17 @@ Paths use placeholders that are resolved at runtime:
 
 | Placeholder | Resolution |
 |-------------|------------|
-| `{HOME}` | User home directory (`~`) |
+| `{TOOL}` | User home directory (`~`) |
 | `{TOOL}` | AI tool name (`cursor`, `copilot`, etc.) |
 
 ### 7.2 Standard Paths
 
 ```
-COMMANDS_PATH = {HOME}/.{TOOL}/skills/agent-assistant/commands/
-AGENTS_PATH   = {HOME}/.{TOOL}/skills/agent-assistant/agents/
-SKILLS_PATH   = {HOME}/.{TOOL}/skills/
-RULES_PATH    = {HOME}/.{TOOL}/skills/agent-assistant/rules/
-REPORTS_PATH  = ./reports/
+COMMANDS = {TOOL}/.{TOOL}/skills/agent-assistant/commands/
+AGENTS   = {TOOL}/.{TOOL}/skills/agent-assistant/agents/
+SKILLS   = {TOOL}/.{TOOL}/skills/
+RULES    = {TOOL}/.{TOOL}/skills/agent-assistant/rules/
+REPORTS  = ./reports/
 ```
 
 ### 7.3 Tool-Specific Installation Paths

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@namch/agent-assistant",
-  "version": "1.1.0",
-  "description": "Multi-agent orchestration framework for AI coding assistants (Cursor, Copilot, Antigravity, Claude Code) with Hybrid Skill Orchestration Layer (HSOL).",
+  "version": "1.2.0",
+  "description": "Multi-agent orchestration framework for AI coding assistants (Cursor, Copilot, Antigravity, Claude Code, Codex) with Hybrid Skill Orchestration Layer (HSOL).",
   "main": "cli/install.js",
   "bin": {
     "agent-assistant": "./cli/install.js"
@@ -10,10 +10,12 @@
     "install:cursor": "node cli/install.js install cursor",
     "install:copilot": "node cli/install.js install copilot",
     "install:antigravity": "node cli/install.js install antigravity",
+    "install:codex": "node cli/install.js install codex",
     "install:all": "node cli/install.js install --all",
     "uninstall:cursor": "node cli/install.js uninstall cursor",
     "uninstall:copilot": "node cli/install.js uninstall copilot",
     "uninstall:antigravity": "node cli/install.js uninstall antigravity",
+    "uninstall:codex": "node cli/install.js uninstall codex",
     "uninstall:all": "node cli/install.js uninstall --all",
     "list": "node cli/install.js list",
     "test": "node --test cli/*.test.js || echo 'No tests found yet - see cli/install.test.js.example'",
@@ -29,6 +31,7 @@
     "copilot",
     "antigravity",
     "gemini",
+    "codex",
     "cli",
     "automation",
     "agent-orchestration",

package/rules/AGENTS.md

@@ -110,6 +110,61 @@ result:
 
 ---
 
+## 🔺 AGENT TEAMS — GOLDEN TRIANGLE (`:team` variant only)
+
+> **LOAD**: `TEAMS.md` for full Golden Triangle protocol and debate mechanism.
+> Teams spawn exactly **3 agents per phase**: Tech Lead + Executor + Reviewer.
+> Adversarial collaboration produces higher quality than parallel cooperation.
+
+### Golden Triangle Roster
+
+| Domain | Tech Lead | Executor | Reviewer | Use When |
+|--------|-----------|----------|----------|----------|
+| `backend-team` | `tech-lead` | `backend-engineer` | `reviewer` | APIs, server logic, backend features |
+| `frontend-team` | `tech-lead` | `frontend-engineer` | `reviewer` | UI components, client-side features |
+| `fullstack-team` | `tech-lead` | `backend-engineer` + `frontend-engineer` | `reviewer` | End-to-end features |
+| `database-team` | `tech-lead` | `database-architect` | `reviewer` + security lens | Schema design, migrations, queries |
+| `research-team` | `researcher` | `scouter` | `brainstormer` (Devil's Advocate) | Discovery, codebase analysis, patterns |
+| `planning-team` | `planner` | `researcher` | `tech-lead` (feasibility critic) | Architecture planning, task decomposition |
+| `qa-team` | `tester` | `tester` (self-implements) | `security-engineer` + `performance-engineer` | Test strategy, coverage, quality |
+| `design-team` | `designer` | `frontend-engineer` | `reviewer` + UX/a11y lens | UI/UX design, component specs |
+| `debug-team` | `debugger` | `backend-engineer` | `reviewer` (root-cause validator) | Root cause analysis, issue resolution |
+| `devops-team` | `devops-engineer` | `backend-engineer` | `security-engineer` | CI/CD, infrastructure, deployment |
+| `security-team` | `security-engineer` | `backend-engineer` | `reviewer` (pen-test mindset) | Security assessment, vulnerability audit |
+| `game-team` | `tech-lead` | `game-engineer` | `reviewer` (game arch + 60fps) | Game development, engines, physics, ECS |
+| `mobile-team` | `tech-lead` | `mobile-engineer` | `reviewer` (UX + platform) | iOS, Android, React Native, Flutter |
+| `performance-team` | `performance-engineer` | `backend-engineer` | `reviewer` (measurement + regression) | Profiling, optimization, load testing |
+| `docs-team` | `docs-manager` | `researcher` | `reviewer` (accuracy + completeness) | Technical writing, API docs, architecture docs |
+| `project-team` | `project-manager` | `business-analyst` | `tech-lead` (feasibility critic) | Project planning, risk, delivery |
+| `report-team` | `reporter` | `scouter` | `reviewer` (data accuracy + insight) | Status reports, metrics, analytics |
+
+### Golden Triangle vs Single Agent
+
+| When | Use |
+|------|-----|
+| Standard `:fast`, `:hard`, `:focus` variants | Single agent per phase |
+| `:team` variant | Golden Triangle per phase |
+| User explicitly requests team review/collaboration | `:team` variant |
+| Maximum quality with adversarial debate is priority | `:team` variant |
+
+### Golden Triangle Definitions Location
+
+```
+agents/teams/{team-name}/
+├── techlead.md    # Coordinator, decomposer, arbitrator
+├── executor.md    # Builder, implementer, defender
+└── reviewer.md    # Devil's advocate, quality gatekeeper
+```
+
+### Communication Protocol
+
+- **Shared Task List**: Published by Tech Lead at phase start, tracks task status
+- **Mailbox**: `./reports/MAILBOX-{date}.md` — append-only log of all exchanges
+- **Debate**: Max 3 rounds per task → Tech Lead arbitrates
+- **Consensus**: `✅ CONSENSUS: TechLead ✓ | Executor ✓ | Reviewer ✓` required to release output
+
+---
+
 ## TASK → AGENT MAPPING
 
 | Task | Agent |