trinity-method-sdk 2.0.8 → 2.1.0

package/CHANGELOG.md

@@ -7,18 +7,253 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.1.0] - 2026-01-21
+
 ### Added
 
+- **NEW: Trinity-docs-update command** - Comprehensive documentation update system for maintaining existing docs
+  - **Command:** `/maintenance:trinity-docs-update` - Updates existing documentation to reflect codebase changes
+  - **Architecture:** JUNO audit → 3 parallel APO instances → JUNO verification loop → Final quality audit
+  - **Autonomous Execution:** Runs from start to finish without user intervention unless errors occur
+  - **Version:** 2.0.9
+  - **Last Updated:** 2026-01-19
+
+- **Trinity-docs-update - JUNO audit system** - Phase 1 comprehensive codebase analysis with mandatory verification protocols
+  - **Database Verification Protocol (Mandatory):**
+    - Step 1: Detect database presence via bash detection script
+    - Step 2: **MANDATORY** production database connection attempt if database detected
+    - Documents connection info search (.env, docker-compose.yml, config files)
+    - Documents connection attempt method and result (success/failure with reason)
+    - Falls back to schema files ONLY after documented connection failure
+    - Prevents documentation based on outdated schema files
+  - **Environment Configuration Verification Protocol (All Projects):**
+    - Priority 1: Check actual environment files (.env, .env.local) FIRST
+    - Priority 2: Check template files (.env.example)
+    - Priority 3: Check code defaults (|| fallback values)
+    - Documents all findings and discrepancies
+    - Source of truth order: Actual config > Template > Code defaults
+    - **Prevents false positives:** Won't flag correct docs as wrong by verifying against actual config
+  - **Business Logic Discovery:** Scans controllers, services, models, utilities at function-level granularity
+  - **Output:** `trinity/reports/DOCS-UPDATE-AUDIT-{{DATE}}.md` with APO work assignments
+
+- **Trinity-docs-update - Configuration false positive prevention** - Resolution rules prevent incorrect audit findings
+  - **Resolution Rule 1:** If .env sets value X, then X is correct (docs showing X are correct)
+  - **Resolution Rule 2:** Code defaults contradicting .env should be fixed (not docs)
+  - **Resolution Rule 3:** Documentation showing actual config value is NEVER wrong
+  - **Example:** Port 3001 in docs + .env, but code shows `|| 4000` → docs are correct, code default needs fixing
+  - **Impact:** Eliminates false positives where JUNO would flag correct documentation as wrong
+
+- **Trinity-docs-update - Scope boundary with consistency exceptions** - Defines strict boundaries with limited exceptions
+  - **ALLOWED:** Read any file, write/edit files in docs/ directory only
+  - **FORBIDDEN:** Modify source code, database schemas, config files, build files, tests
+  - **EXCEPTIONS (APO-1 only):**
+    - Fix hardcoded default values contradicting documented standards (e.g., `|| 4000` → `|| 3001`)
+    - Update .env.example template values to match actual standards
+    - ONLY simple constant/default changes (no logic modifications)
+    - MUST verify against actual .env first
+  - **Scenario C Example:** Docs show port 3001, .env has 3001, code default is 4000 → Fix code default to 3001
+
+- **Trinity-docs-update - APO parallel execution system** - Phase 2 launches three documentation specialists concurrently
+  - **APO-1:** Base documentation updates (architecture, setup, guides)
+    - **NEW:** Configuration consistency fixes (simple defaults that contradict standards)
+    - Update .env.example to match actual standards
+    - Align configuration values across codebase and docs
+    - Restriction: Only simple constants (no logic changes)
+  - **APO-2:** Update existing business logic documentation OR new docs (first half)
+  - **APO-3:** New business logic documentation (second half)
+  - Each APO creates personal checklist from JUNO's audit report
+  - All APOs verify changes against actual codebase (not assumptions)
+  - Output: Updated/new documentation files in docs/
+
+- **Trinity-docs-update - APO verification requirements** - Mandatory codebase verification for all documentation changes
+  - **For EVERY change, APO must:**
+    1. Identify what needs to change (from JUNO's assignment)
+    2. Verify correct value in codebase (read .env, source files, config)
+    3. Document verification in task (which files read, what found)
+    4. Use Read tool BEFORE making changes
+    5. Use Edit tool with verified information only
+    6. DO NOT make assumptions or guesses
+  - **Verification examples:**
+    - API ports → Read .env, server.js, app.js
+    - Table names → Read init.sql or check production database
+    - Endpoint URLs → Read route files
+    - Method signatures → Read actual source file
+    - Configuration values → Read config files
+  - **Documentation format:**
+    ```markdown
+    - [x] docs/api/README.md
+      - Verification: Read backend/.env - confirmed port is 3001
+      - Changes made: Updated 49 instances of port number to 3001
+    ```
+
+- **Trinity-docs-update - JUNO verification loop** - Phase 3 ensures 100% completion before final audit
+  - **Step 3.1:** JUNO checks all three APO checklists for completion status
+    - Counts total tasks vs completed tasks per APO
+    - Calculates completion percentage
+    - Determines next action (PROCEED or RESTART)
+  - **Step 3.1A:** Re-launch incomplete APOs automatically
+    - Identifies incomplete APOs from JUNO's report
+    - Restarts only incomplete APOs with resume instructions
+    - Loops until all APOs reach 100%
+  - **Step 3.2:** JUNO final quality audit (only when all APOs 100% complete)
+    - Verifies files created/updated
+    - Checks content accuracy against codebase
+    - Validates no hallucinated components
+    - Generates verification report with pass/fail status
+  - **Output:** `trinity/reports/DOCS-UPDATE-VERIFICATION-{{DATE}}.md`
+
+- **Trinity-docs-update - Three template files** - Command template and two checklist templates deployed via CLI
+  - **Command Template:** `src/templates/.claude/commands/maintenance/trinity-docs-update.md.template`
+    - Deployed to: `.claude/commands/maintenance/trinity-docs-update.md`
+    - Updated by: `trinity update` command via `updateCommands()` function
+  - **JUNO Checklist:** `src/templates/trinity/templates/documentation/reports/juno-docs-update-checklist.md.template`
+    - Deployed to: `trinity/templates/documentation/reports/juno-docs-update-checklist.md`
+    - Updated by: `trinity update` command via `updateTemplates()` function (recursively copies all documentation templates)
+  - **APO Checklist:** `src/templates/trinity/templates/documentation/reports/apo-docs-update-checklist.md.template`
+    - Deployed to: `trinity/templates/documentation/reports/apo-docs-update-checklist.md`
+    - Updated by: `trinity update` command via `updateTemplates()` function (recursively copies all documentation templates)
+  - All templates automatically deployed during `trinity deploy` and updated during `trinity update`
+
+- **Trinity-docs command - Complete architectural overhaul** - Transformed from single-agent to multi-agent orchestration
+  - **New Architecture:** JUNO audit → 3 parallel APO instances → Verification
+  - **JUNO Agent Integration:** Read-only codebase audit creates documentation checklist before generation
+  - **Parallel APO Execution:** APO-1 (diagrams), APO-2 (guides/API), APO-3 (config) run concurrently
+  - **Performance:** 3x faster execution via parallel agent orchestration
+  - **Context Efficiency:** Each agent receives focused instructions (<100 lines) vs single 2,577-line spec
+
+- **Trinity-docs command - External template system** - Created 28 reusable documentation templates
+  - **Template Directory:** `trinity/templates/documentation/` with 8 categories
+  - **Mermaid Diagrams (4 templates):** MVC flow, database ER, API endpoint map, component hierarchy
+  - **Guides (4 templates):** Getting started, API development, deployment, contributing
+  - **API Documentation (1 template):** API README with endpoint structure
+  - **Configuration (2 templates):** Documentation structure, env-example generator
+  - **Discovery (4 templates):** Framework detection, component discovery, API endpoint scanner, env variable extraction
+  - **Validation (3 templates):** APO self-validation checklists for all 3 agents
+  - **Processes (6 templates):** APO workflows (common, diagram-specific, guide-specific, config-specific), error handling, fallback mechanisms
+  - **Reports (2 templates):** JUNO internal report, ROOT-README for template organization
+  - **Template Variables:** All templates use `{{UPPERCASE_UNDERSCORE}}` syntax for dynamic content replacement
+
+- **Trinity-docs command - Template validation phase** - Optional Phase 0.2 validates template syntax
+  - Validates `{{VARIABLE}}` syntax (must be UPPERCASE_UNDERSCORE)
+  - Detects nested variables (not supported)
+  - Checks balanced braces
+  - Non-blocking warnings for template issues
+
+- **Trinity-docs command - Retry mechanism** - Phase 0.25 handles transient failures
+  - Retries operations up to 3 times with 500ms delay
+  - Handles filesystem delays and race conditions
+  - Graceful degradation for non-critical operations
+
+- **Trinity-docs command - JUNO documentation audit** - Phase 1 performs comprehensive codebase analysis
+  - **Framework Detection:** Analyzes package.json for Express, NestJS, React, Next.js, Django, Flask, FastAPI
+  - **Component Discovery:** Scans for React/Vue/Angular/Svelte components with zero-tolerance for fake components
+  - **API Endpoint Scanning:** Detects Express/Fastify/NestJS/Koa routes with enhanced patterns
+  - **Database Detection:** PostgreSQL, MySQL, MongoDB, SQLite, Redis via dependency analysis
+  - **Environment Variables:** Extracts from .env and process.env usage patterns
+  - **Checklist Report:** Generates `trinity/templates/documentation/reports/juno-internal-report.md` with all discovered metadata
+
+- **Trinity-docs command - Fallback mechanism** - Handles missing JUNO data gracefully
+  - Uses discovery templates when JUNO variables missing
+  - Framework detection fallback via package.json analysis
+  - Component discovery fallback for frontend frameworks
+  - API endpoint scanner fallback for backend frameworks
+  - Environment variable extraction fallback
+  - Default template paths when discovery fails
+
+- **Trinity-docs command - APO self-validation** - Each APO validates its own work before completion
+  - APO-1 validates: 4 diagram files created, correct paths, no placeholders, proper Mermaid syntax
+  - APO-2 validates: Guide completeness, API documentation accuracy, no fake examples
+  - APO-3 validates: Config files exist, no hardcoded secrets, proper .env.example format
+  - Security checks for APO-3: No API keys, passwords, tokens, or sensitive data in generated files
+
+- **Trinity-docs command - Enhanced verification phase** - Phase 4 performs comprehensive quality checks
+  - Verifies all JUNO checklist items completed
+  - Validates file existence and content quality
+  - Checks for placeholders and fake data
+  - Ensures proper Mermaid syntax in diagrams
+  - Validates security (no secrets in config files)
+  - Generates final completion report with pass/fail status
+
 ### Changed
 
+- **Trinity-docs command - File relocation** - Moved from `src/templates/shared/claude-commands/` to `src/templates/.claude/commands/execution/`
+  - Aligns with new command categorization structure
+  - Distinguishes execution commands from utility/session/planning commands
+
+- **Trinity-docs command - Diagram output path** - Changed from `docs/architecture/diagrams/` to `docs/architecture/`
+  - Simplified directory structure
+  - All architecture files (diagrams, overview, ADRs) now in single directory
+  - Updated all references throughout command specification (lines 1079, 1205-1208)
+
+- **Trinity-docs command - API endpoint scanner enhancement** - Added 3 missing route detection patterns
+  - Added `router.route('...').get|post|put|patch|delete()` pattern
+  - Added `app.route('...').get|post|put|patch|delete()` pattern
+  - Added `router.all('...')` wildcard route pattern
+  - Fixes endpoint count variance (33 vs 34 detected endpoints)
+
+- **Trinity-docs command - Configuration directory consolidation** - Merged `config/` into `configuration/`
+  - Moved `env-example-generator.md.template` from `config/` to `configuration/`
+  - Removed duplicate directory structure
+  - Now single `configuration/` directory with 2 templates
+
+- **Trinity-docs command - Version update** - Updated to v2.0.9
+  - Reflects architectural overhaul and template externalization
+  - Command now references 28 external templates vs inline logic
+
 ### Deprecated
 
 ### Removed
 
+- **Trinity-docs command - Inline documentation logic** - Removed 808+ lines of inline instructions (WO-004)
+  - Phase 1 codebase analysis logic → `trinity/templates/documentation/discovery/` templates
+  - Phase 2 content seeding → `trinity/templates/documentation/guides/` templates
+  - Diagram generation → `trinity/templates/documentation/mermaid-diagrams/` templates
+  - Validation logic → `trinity/templates/documentation/validation/` templates
+
+- **Trinity-docs command - Single-agent architecture** - Replaced with multi-agent orchestration
+  - Old: Single APO reads 2,577-line spec and performs all work
+  - New: JUNO audit + 3 parallel APO instances with focused instructions
+  - Reduces context fatigue and improves reliability
+
 ### Fixed
 
 ### Security
 
+## [2.0.9] - 2026-01-12
+
+### Changed
+
+- **Trinity-docs command specification** - Added evidence-based documentation verification
+  - Added Rule 2: Evidence-Based Documentation Only - prevents documenting uninstalled tools
+  - Added Phase 1 Step 6: Tool & Feature Verification for all project types
+  - Added tool verification report to Phase 5 output
+  - Prevents aspirational/best-practice content that doesn't exist in codebase
+  - Addresses incident where Lighthouse was documented without being installed
+
+- **Trinity-readme command specification** - Removed Trinity self-documentation conflicts
+  - Deleted Type C Template that documented Trinity infrastructure (violated Rule 1)
+  - Added Rule 1 Enforcement Checklist with verification commands
+  - Added Phase 1 Step 4.5: Filter Gitignored and Trinity Directories
+  - Added Trinity Detection Warning to explicitly skip trinity/ and .claude/
+  - Removed trinity/ from glob patterns and project structure examples
+  - Addresses incident where trinity/ was included in README file tree despite being gitignored
+
+- **Trinity-readme command specification** - Added LICENSE file verification for badges
+  - Added Phase 1 Step 7: License Verification - reads actual LICENSE file
+  - LICENSE file is now source of truth (priority over package.json)
+  - Detects license type from file header (MIT, ISC, Apache, GPL, BSD, etc.)
+  - Warns when package.json license field doesn't match LICENSE file
+  - Falls back to package.json only if LICENSE file doesn't exist
+  - Addresses incident where ISC badge was generated despite MIT LICENSE file
+
+- **Trinity-docs command specification** - Added Trinity reference sanitization enforcement
+  - Added Rule 1 Forbidden Patterns - explicit list of patterns that must not appear in docs/
+  - Added Phase 4.5: Trinity Reference Sanitization - scans and removes Trinity references
+  - Added Rule 1 Compliance verification to Phase 5 report with pass/fail status
+  - Removed Trinity report link from docs/README.md template footer
+  - Prevents Trinity Method, agent names, commands, and infrastructure references in user docs
+  - Addresses incident where 7 documentation files contained Trinity Method references
+
 ## [2.0.8] - 2026-01-08
 
 ### Added

package/README.md

@@ -89,7 +89,7 @@ Trinity Method SDK is a **production-ready development methodology** that transf
 
 ### The 19-Agent Team
 
-Trinity SDK includes **19 specialized agents** (core team of 14 primary agents + 5 infrastructure agents):
+Trinity SDK includes **19 specialized agents** organized across 5 functional teams:
 
 **Planning Layer:**
 
@@ -116,17 +116,18 @@ Trinity SDK includes **19 specialized agents** (core team of 14 primary agents +
 - **ALY** - Chief Technology Officer (investigation orchestration, strategic coordination)
 - **JUNO** - Quality Auditor (comprehensive codebase audits, deployment verification)
 
-**Infrastructure (5 agents):**
+**Infrastructure & Legacy:**
 
 - **TAN** - Structure Specialist (directory structure validation)
 - **ZEN** - Knowledge Base Specialist (comprehensive documentation)
 - **INO** - Context Specialist (CLAUDE.md hierarchy management)
 - **EIN** - CI/CD Specialist (continuous integration/deployment automation)
+- **AJ-CC** - Claude Code Orchestrator (specialized v2.0 orchestration)
 - **AJ MAESTRO** - Legacy Orchestrator (deprecated v1.0, replaced by ALY in v2.0)
 
 ### What Gets Deployed
 
-Trinity deploys **64 production-ready components** in 90 seconds:
+Trinity deploys **88 production-ready components** in 90 seconds:
 
 **Methodology Infrastructure:**
 
@@ -141,9 +142,9 @@ Trinity deploys **64 production-ready components** in 90 seconds:
   - DOCUMENTATION-CRITERIA.md (documentation standards)
   - AI-DEVELOPMENT-GUIDE.md (AI-assisted development best practices)
 - `trinity/templates/` - Reusable templates
-  - `documentation/` - Documentation templates
-  - `investigations/` - 5 investigation templates (Bug, Performance, Security, System Analysis, Incident)
-  - `work-orders/` - Work order templates
+  - `documentation/` - Documentation templates (2 README templates + 23 report templates)
+  - `investigations/` - 5 investigation templates (bug, feature, performance, security, technical)
+  - `work-orders/` - 6 work order templates
 - `trinity/investigations/` - Active investigations with execution plans
 - `trinity/sessions/` - Session archives
 - `trinity/reports/` - Audit and integration reports
@@ -154,15 +155,16 @@ Trinity deploys **64 production-ready components** in 90 seconds:
 **Agent System:**
 
 - `.claude/agents/` - 19 specialized agents organized by category:
-  - `aj-team/` - AJ MAESTRO orchestration agents
-  - `audit/` - JUNO quality auditor
-  - `deployment/` - 6 deployment specialists (BON, CAP, EIN, INO, TAN, ZEN)
-  - `leadership/` - ALY strategic leadership
+  - `aj-team/` - 7 execution agents (APO, BAS, BON, CAP, DRA, KIL, URO)
+  - `audit/` - 1 quality auditor (JUNO)
+  - `deployment/` - 4 infrastructure agents (EIN, INO, TAN, ZEN)
+  - `leadership/` - 3 orchestration agents (ALY, AJ-CC, AJ-MAESTRO)
   - `planning/` - 4 planning agents (MON, ROR, EUS, TRA)
-- `.claude/commands/` - 20 slash commands organized in 6 categories:
-  - `execution/` - 5 commands (orchestrate, audit, readme, docs, changelog)
-  - `infrastructure/` - 1 command (trinity-init)
-  - `investigation/` - 3 commands (create, plan, templates)
+- `.claude/commands/` - 20 slash commands organized in 7 categories:
+  - `execution/` - 2 commands (orchestrate, audit)
+  - `infrastructure/` - 1 command (init)
+  - `investigation/` - 3 commands (create-investigation, plan-investigation, investigate-templates)
+  - `maintenance/` - 4 commands (readme, docs, docs-update, changelog)
   - `planning/` - 4 commands (requirements, design, decompose, plan)
   - `session/` - 3 commands (start, continue, end)
   - `utility/` - 3 commands (verify, agents, workorder)
@@ -256,7 +258,8 @@ After deployment, access Trinity functionality through Claude Code slash command
 - `/trinity-orchestrate` - Execute with ALY orchestration
 - `/trinity-audit` - Run codebase audit (JUNO)
 - `/trinity-readme` - Update README coverage (APO)
-- `/trinity-docs` - Organize docs/ directory (APO)
+- `/trinity-docs` - Generate new documentation (JUNO + 3 parallel APOs)
+- `/trinity-docs-update` - Update existing documentation (JUNO audit → 3 APOs → verification loop)
 - `/trinity-changelog` - Maintain CHANGELOG.md (APO)
 
 **Investigation:**
@@ -364,11 +367,11 @@ After deploying Trinity to your project, comprehensive documentation is availabl
 
 Your project contains:
 
-- **64 production-ready components** deployed in 90 seconds
-- **19 specialized agents** in `.claude/agents/` (organized by category: aj-team, audit, deployment, leadership, planning)
-- **20 slash commands** in `.claude/commands/` (organized by category: execution, infrastructure, investigation, planning, session, utility)
+- **88 production-ready components** deployed in 90 seconds
+- **19 specialized agents** in `.claude/agents/` (7 execution + 1 audit + 4 infrastructure + 3 leadership + 4 planning)
+- **20 slash commands** in `.claude/commands/` (2 execution + 1 infrastructure + 3 investigation + 4 maintenance + 4 planning + 3 session + 3 utility)
 - **Complete knowledge base** in `trinity/knowledge-base/` (ARCHITECTURE.md, ISSUES.md, To-do.md, Technical-Debt.md)
-- **Investigation templates** in `trinity/templates/investigations/` (bug, performance, security, system analysis, incident)
+- **Investigation templates** in `trinity/templates/investigations/` (bug, feature, performance, security, technical)
 - **Work order templates** in `trinity/templates/work-orders/`
 - **Session archives** in `trinity/sessions/`
 - **Audit reports** in `trinity/reports/`
@@ -380,15 +383,16 @@ Your project contains:
 your-project/
 ├── .claude/
 │   ├── agents/
-│   │   ├── aj-team/              # AJ MAESTRO orchestration agents
-│   │   ├── audit/                # JUNO quality auditor
-│   │   ├── deployment/           # Deployment specialists (BON, CAP, EIN, INO, TAN, ZEN)
-│   │   ├── leadership/           # ALY strategic leadership
-│   │   └── planning/             # MON, ROR, EUS, TRA agents
+│   │   ├── aj-team/              # 7 execution agents (APO, BAS, BON, CAP, DRA, KIL, URO)
+│   │   ├── audit/                # 1 quality auditor (JUNO)
+│   │   ├── deployment/           # 4 infrastructure agents (EIN, INO, TAN, ZEN)
+│   │   ├── leadership/           # 3 orchestration agents (ALY, AJ-CC, AJ-MAESTRO)
+│   │   └── planning/             # 4 planning agents (MON, ROR, EUS, TRA)
 │   ├── commands/
-│   │   ├── execution/            # trinity-orchestrate, trinity-audit, trinity-readme, trinity-docs, trinity-changelog
+│   │   ├── execution/            # trinity-orchestrate, trinity-audit
 │   │   ├── infrastructure/       # trinity-init
 │   │   ├── investigation/        # trinity-create-investigation, trinity-plan-investigation, trinity-investigate-templates
+│   │   ├── maintenance/          # trinity-readme, trinity-docs, trinity-docs-update, trinity-changelog
 │   │   ├── planning/             # trinity-requirements, trinity-design, trinity-decompose, trinity-plan
 │   │   ├── session/              # trinity-start, trinity-continue, trinity-end
 │   │   └── utility/              # trinity-verify, trinity-agents, trinity-workorder
@@ -396,9 +400,9 @@ your-project/
 ├── trinity/
 │   ├── knowledge-base/           # ARCHITECTURE.md, ISSUES.md, To-do.md, Technical-Debt.md, Trinity.md
 │   ├── templates/
-│   │   ├── documentation/        # Documentation templates
-│   │   ├── investigations/       # Bug, performance, security, system analysis, incident templates
-│   │   └── work-orders/          # Work order templates
+│   │   ├── documentation/        # 2 README templates + 23 report templates
+│   │   ├── investigations/       # 5 investigation templates (bug, feature, performance, security, technical)
+│   │   └── work-orders/          # 6 work order templates
 │   ├── investigations/           # Active investigations
 │   │   └── plans/                # Investigation execution plans
 │   ├── sessions/                 # Session archives
@@ -460,7 +464,7 @@ Trinity uses GitHub Actions for comprehensive continuous integration and deploym
 
 - ✅ Multi-platform testing (Ubuntu, Windows, macOS)
 - ✅ Multi-version testing (Node.js 18.x, 20.x, 22.x)
-- ✅ Trinity component validation (19 agents, 19+ slash commands, knowledge base, CI/CD templates)
+- ✅ Trinity component validation (19 agents, 20 slash commands, knowledge base, CI/CD templates)
 - ✅ Test suite execution (unit, integration, e2e, performance)
 - ✅ Code coverage validation (80%+ threshold enforced)
 - ✅ Linting and type checking
@@ -492,7 +496,7 @@ npm run build
 npm publish --access public
 
 # 3. Create git tag and push
-git tag -a v2.0.8 -m "Release v2.0.8"
+git tag -a v2.0.9 -m "Release v2.0.9"
 git push origin main --follow-tags
 ```
 
@@ -526,11 +530,6 @@ MIT License - see [LICENSE](LICENSE) for details
 
 - **API Documentation**: [docs/](docs/) - Generated TypeDoc API reference
 - **Contributing Guide**: [CONTRIBUTING.md](CONTRIBUTING.md) - Development setup, workflow, and standards
-- **Architectural Decisions**: [docs/adr/](docs/adr/) - ADRs documenting major technical decisions
-  - [ADR-001: CLI Architecture](docs/adr/ADR-001-cli-architecture.md)
-  - [ADR-002: Template System Design](docs/adr/ADR-002-template-system-design.md)
-  - [ADR-003: ESLint Flat Config](docs/adr/ADR-003-eslint-flat-config.md)
-  - [ADR-004: Test Strategy](docs/adr/ADR-004-test-strategy.md)
 - **Changelog**: [CHANGELOG.md](CHANGELOG.md) - Version history and release notes
 
 ---

package/dist/cli/commands/deploy/agents.js

@@ -42,7 +42,7 @@ export async function deployAgents(templatesPath, variables, spinner) {
     ];
     for (const { dir, agents } of agentDirs) {
         for (const agent of agents) {
-            const templatePath = path.join(templatesPath, 'agents', dir, `${agent}.template`);
+            const templatePath = path.join(templatesPath, '.claude/agents', dir, `${agent}.template`);
             if (await fs.pathExists(templatePath)) {
                 const content = await fs.readFile(templatePath, 'utf8');
                 const processed = processTemplate(content, variables);

package/dist/cli/commands/deploy/claude-setup.js

@@ -26,7 +26,7 @@ export async function deployClaudeSetup(templatesPath, variables, spinner) {
     spinner.succeed('Claude Code settings created (empty - customize as needed)');
     // Deploy Employee Directory
     spinner.start('Deploying Employee Directory...');
-    const employeeDirectoryTemplate = path.join(templatesPath, 'claude', 'EMPLOYEE-DIRECTORY.md.template');
+    const employeeDirectoryTemplate = path.join(templatesPath, '.claude', 'EMPLOYEE-DIRECTORY.md.template');
     if (await fs.pathExists(employeeDirectoryTemplate)) {
         const content = await fs.readFile(employeeDirectoryTemplate, 'utf8');
         const processed = processTemplate(content, variables);
@@ -48,41 +48,34 @@ export async function deployClaudeSetup(templatesPath, variables, spinner) {
     await fs.ensureDir(`${commandsDir}/execution`);
     await fs.ensureDir(`${commandsDir}/investigation`);
     await fs.ensureDir(`${commandsDir}/infrastructure`);
+    await fs.ensureDir(`${commandsDir}/maintenance`);
     await fs.ensureDir(`${commandsDir}/utility`);
-    // Command categorization map
-    const commandCategories = {
-        'trinity-start.md.template': 'session',
-        'trinity-continue.md.template': 'session',
-        'trinity-end.md.template': 'session',
-        'trinity-requirements.md.template': 'planning',
-        'trinity-design.md.template': 'planning',
-        'trinity-decompose.md.template': 'planning',
-        'trinity-plan.md.template': 'planning',
-        'trinity-orchestrate.md.template': 'execution',
-        'trinity-audit.md.template': 'execution',
-        'trinity-readme.md.template': 'execution',
-        'trinity-docs.md.template': 'execution',
-        'trinity-changelog.md.template': 'execution',
-        'trinity-create-investigation.md.template': 'investigation',
-        'trinity-plan-investigation.md.template': 'investigation',
-        'trinity-investigate-templates.md.template': 'investigation',
-        'trinity-init.md.template': 'infrastructure',
-        'trinity-agents.md.template': 'utility',
-        'trinity-verify.md.template': 'utility',
-        'trinity-workorder.md.template': 'utility',
-    };
-    const commandsTemplatePath = path.join(templatesPath, 'shared/claude-commands');
-    const commandFiles = await fs.readdir(commandsTemplatePath);
-    for (const file of commandFiles) {
-        if (file.endsWith('.md.template') && commandCategories[file]) {
-            const sourcePath = path.join(commandsTemplatePath, file);
-            const category = commandCategories[file];
-            // Remove .template extension for deployed files
-            const deployedName = file.replace('.template', '');
-            const destPath = path.join(commandsDir, category, deployedName);
-            await fs.copy(sourcePath, destPath);
-            commandsDeployed++;
-            filesDeployed++;
+    // Commands are now organized by category in source templates
+    const commandsTemplatePath = path.join(templatesPath, '.claude/commands');
+    const categories = [
+        'session',
+        'planning',
+        'execution',
+        'investigation',
+        'infrastructure',
+        'maintenance',
+        'utility',
+    ];
+    for (const category of categories) {
+        const categoryPath = path.join(commandsTemplatePath, category);
+        if (await fs.pathExists(categoryPath)) {
+            const commandFiles = await fs.readdir(categoryPath);
+            for (const file of commandFiles) {
+                if (file.endsWith('.md.template')) {
+                    const sourcePath = path.join(categoryPath, file);
+                    // Remove .template extension for deployed files
+                    const deployedName = file.replace('.template', '');
+                    const destPath = path.join(commandsDir, category, deployedName);
+                    await fs.copy(sourcePath, destPath);
+                    commandsDeployed++;
+                    filesDeployed++;
+                }
+            }
         }
     }
     spinner.succeed(`Deployed ${commandsDeployed} Trinity slash commands (6 categories)`);

package/dist/cli/commands/deploy/index.js

@@ -98,7 +98,7 @@ export async function deploy(options) {
             PACKAGE_MANAGER: stack.packageManager || 'npm',
             BACKEND_FRAMEWORK: stack.framework,
             CURRENT_DATE: new Date().toISOString(),
-            TRINITY_VERSION: pkg.version || '2.0.8',
+            TRINITY_VERSION: pkg.version || '2.1.0',
         };
         // STEP 4: Create directory structure
         const directoriesCreated = await createDirectories(spinner);

package/dist/cli/commands/deploy/knowledge-base.js

@@ -30,7 +30,7 @@ export async function deployKnowledgeBase(templatesPath, variables, stack, metri
         'DOCUMENTATION-CRITERIA.md',
     ];
     for (const template of kbTemplates) {
-        const templatePath = path.join(templatesPath, 'knowledge-base', `${template}.template`);
+        const templatePath = path.join(templatesPath, 'trinity/knowledge-base', `${template}.template`);
         if (await fs.pathExists(templatePath)) {
             const content = await fs.readFile(templatePath, 'utf8');
             const processed = processTemplate(content, variables);

package/dist/cli/commands/deploy/root-files.js

@@ -39,7 +39,7 @@ async function deployRootClaudeMarkdown(templatesPath, variables) {
  */
 async function deployVersionFile(pkgVersion) {
     const versionPath = validatePath('trinity/VERSION');
-    await fs.writeFile(versionPath, pkgVersion || '2.0.8');
+    await fs.writeFile(versionPath, pkgVersion || '2.1.0');
     return 1;
 }
 /**

package/dist/cli/commands/deploy/sdk-install.js

@@ -24,7 +24,7 @@ export async function installSDK(spinner) {
                 if (!packageJson.dependencies) {
                     packageJson.dependencies = {};
                 }
-                packageJson.dependencies['trinity-method-sdk'] = '^2.0.8';
+                packageJson.dependencies['trinity-method-sdk'] = '^2.1.0';
                 await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
                 spinner.text = 'Installing Trinity Method SDK (this may take a moment)...';
                 // Install dependencies

package/dist/cli/commands/deploy/templates.js

@@ -27,7 +27,7 @@ export async function deployTemplates(templatesPath, variables, spinner) {
     ];
     await fs.ensureDir('trinity/templates/work-orders');
     for (const template of woTemplates) {
-        const templatePath = path.join(templatesPath, 'work-orders', template);
+        const templatePath = path.join(templatesPath, 'trinity/templates/work-orders', template);
         if (await fs.pathExists(templatePath)) {
             const content = await fs.readFile(templatePath, 'utf8');
             const processed = processTemplate(content, variables);
@@ -50,7 +50,7 @@ export async function deployTemplates(templatesPath, variables, spinner) {
     ];
     await fs.ensureDir('trinity/templates/investigations');
     for (const template of investigationTemplates) {
-        const templatePath = path.join(templatesPath, 'investigations', template);
+        const templatePath = path.join(templatesPath, 'trinity/templates/investigations', template);
         if (await fs.pathExists(templatePath)) {
             const content = await fs.readFile(templatePath, 'utf8');
             const processed = processTemplate(content, variables);
@@ -62,23 +62,36 @@ export async function deployTemplates(templatesPath, variables, spinner) {
         }
     }
     spinner.succeed(`Investigation templates deployed (${investigationTemplates.length} templates)`);
-    // Deploy documentation templates
+    // Deploy documentation templates (all 28 templates including subdirectories)
     spinner.start('Deploying documentation templates...');
-    const documentationTemplates = ['ROOT-README.md.template', 'SUBDIRECTORY-README.md.template'];
-    await fs.ensureDir('trinity/templates/documentation');
-    for (const template of documentationTemplates) {
-        const templatePath = path.join(templatesPath, 'documentation', template);
-        if (await fs.pathExists(templatePath)) {
-            const content = await fs.readFile(templatePath, 'utf8');
-            const processed = processTemplate(content, variables);
-            const deployedName = template.replace('.template', '');
-            // Validate destination path for security
-            const destPath = validatePath(`trinity/templates/documentation/${deployedName}`);
-            await fs.writeFile(destPath, processed);
-            templatesDeployed++;
+    const docSourcePath = path.join(templatesPath, 'trinity/templates/documentation');
+    const docDestPath = 'trinity/templates/documentation';
+    await fs.ensureDir(docDestPath);
+    // Recursively copy all documentation templates, removing .template extension
+    async function copyDocTemplates(sourcePath, destPath) {
+        const items = await fs.readdir(sourcePath);
+        for (const item of items) {
+            const sourceItemPath = path.join(sourcePath, item);
+            const stat = await fs.stat(sourceItemPath);
+            if (stat.isDirectory()) {
+                // Create subdirectory and recurse
+                const destSubDir = path.join(destPath, item);
+                await fs.ensureDir(destSubDir);
+                await copyDocTemplates(sourceItemPath, destSubDir);
+            }
+            else if (item.endsWith('.md.template')) {
+                // Process template file and remove .template extension
+                const content = await fs.readFile(sourceItemPath, 'utf8');
+                const processed = processTemplate(content, variables);
+                const deployedName = item.replace('.template', '');
+                const destFilePath = validatePath(path.join(destPath, deployedName));
+                await fs.writeFile(destFilePath, processed);
+                templatesDeployed++;
+            }
         }
     }
-    spinner.succeed(`Documentation templates deployed (${documentationTemplates.length} templates)`);
+    await copyDocTemplates(docSourcePath, docDestPath);
+    spinner.succeed(`Documentation templates deployed (${templatesDeployed - 11} templates)`);
     return templatesDeployed;
 }
 //# sourceMappingURL=templates.js.map

package/dist/cli/commands/update/agents.js

@@ -16,7 +16,7 @@ const AGENT_DIRS = ['leadership', 'planning', 'aj-team', 'deployment', 'audit'];
 export async function updateAgents(spinner, stats) {
     spinner.start('Updating agents...');
     const sdkPath = await getSDKPath();
-    const agentsTemplatePath = path.join(sdkPath, 'dist/templates/agents');
+    const agentsTemplatePath = path.join(sdkPath, 'dist/templates/.claude/agents');
     for (const agentDir of AGENT_DIRS) {
         const sourcePath = path.join(agentsTemplatePath, agentDir);
         const targetPath = path.join('.claude/agents', agentDir);

package/dist/cli/commands/update/commands.d.ts

@@ -7,6 +7,7 @@ import { Ora } from 'ora';
 import { UpdateStats } from './types.js';
 /**
  * Update slash command files from SDK to .claude/commands/
+ * Commands are now organized by category in source templates
  * @param spinner - ora spinner instance for status display
  * @param stats - update statistics to track progress
  */