leo-claude-mktplace/docs/references/PLUGIN-PMO.md

PMO Plugin Reference (projman-pmo)

Overview

The projman-pmo plugin provides multi-project PMO coordination with cross-project dependency tracking, resource allocation, and company-wide visibility. It builds on projman but operates at the organization level.

Build Order: Build AFTER projman is working and validated Target Users: PMO coordinators, engineering managers, CTOs Scope: Multi-project coordination across entire organization

Key Features:

• Cross-project status aggregation
• Dependency tracking and visualization
• Resource conflict detection
• Release coordination
• Company-wide lessons learned search
• Multi-project prioritization

---

Plugin Structure

projman-pmo/
├── .claude-plugin/
│   └── plugin.json                # Plugin manifest
├── .mcp.json                      # Points to ../mcp-servers/ (company mode)
├── commands/
│   ├── pmo-status.md             # Multi-project status overview
│   ├── pmo-priorities.md         # Cross-project prioritization
│   ├── pmo-dependencies.md       # Dependency visualization
│   ├── pmo-conflicts.md          # Resource conflict detection
│   └── pmo-schedule.md           # Deployment schedule coordination
├── agents/
│   └── pmo-coordinator.md        # Multi-project coordination agent
└── README.md                      # Installation and usage guide

---

Plugin Manifest

File: projman-pmo/.claude-plugin/plugin.json

{
  "name": "projman-pmo",
  "version": "0.1.0",
  "displayName": "Projman PMO - Multi-Project Coordination",
  "description": "PMO coordination with cross-project visibility, dependency tracking, and resource management",
  "author": "Leo Miranda",
  "homepage": "https://gitea.hotserv.cloud/personal-projects/support-claude-mktplace",
  "repository": {
    "type": "git",
    "url": "ssh://git@hotserv.tailc9b278.ts.net:2222/personal-projects/support-claude-mktplace.git"
  },
  "license": "MIT",
  "keywords": [
    "pmo",
    "multi-project",
    "coordination",
    "dependencies",
    "resource-management"
  ],
  "minimumClaudeVersion": "1.0.0",
  "main": "commands/",
  "dependencies": {
    "projman": ">=0.1.0"
  },
  "contributes": {
    "commands": [
      {
        "name": "pmo-status",
        "title": "PMO Status",
        "description": "Multi-project status overview",
        "file": "commands/pmo-status.md"
      },
      {
        "name": "pmo-priorities",
        "title": "PMO Priorities",
        "description": "Cross-project priority analysis",
        "file": "commands/pmo-priorities.md"
      },
      {
        "name": "pmo-dependencies",
        "title": "PMO Dependencies",
        "description": "Project dependency visualization",
        "file": "commands/pmo-dependencies.md"
      },
      {
        "name": "pmo-conflicts",
        "title": "PMO Resource Conflicts",
        "description": "Resource conflict detection and resolution",
        "file": "commands/pmo-conflicts.md"
      },
      {
        "name": "pmo-schedule",
        "title": "PMO Schedule",
        "description": "Multi-project deployment scheduling",
        "file": "commands/pmo-schedule.md"
      }
    ],
    "agents": [
      {
        "name": "pmo-coordinator",
        "title": "PMO Coordinator",
        "description": "Strategic multi-project coordination and dependency management",
        "file": "agents/pmo-coordinator.md"
      }
    ]
  },
  "configuration": {
    "required": [
      "GITEA_API_URL",
      "GITEA_API_TOKEN",
      "GITEA_OWNER",
      "WIKIJS_API_URL",
      "WIKIJS_API_TOKEN",
      "WIKIJS_BASE_PATH"
    ],
    "properties": {
      "GITEA_API_URL": {
        "type": "string",
        "description": "Gitea API base URL (e.g., https://gitea.example.com/api/v1)"
      },
      "GITEA_API_TOKEN": {
        "type": "string",
        "description": "Gitea API token with organization-level access",
        "secret": true
      },
      "GITEA_OWNER": {
        "type": "string",
        "description": "Gitea organization name"
      },
      "WIKIJS_API_URL": {
        "type": "string",
        "description": "Wiki.js GraphQL API URL (e.g., https://wiki.example.com/graphql)"
      },
      "WIKIJS_API_TOKEN": {
        "type": "string",
        "description": "Wiki.js API token with company-wide read access",
        "secret": true
      },
      "WIKIJS_BASE_PATH": {
        "type": "string",
        "description": "Base path in Wiki.js (e.g., /company-name)"
      }
    },
    "notes": {
      "company_mode": "PMO plugin operates in company-wide mode. Do NOT set GITEA_REPO or WIKIJS_PROJECT environment variables."
    }
  }
}

Key Differences from projman:

• dependencies: Declares dependency on projman plugin
• No GITEA_REPO or WIKIJS_PROJECT in configuration (company-wide mode)
• Focused on coordination, not individual project management

---

Configuration

Plugin .mcp.json

File: projman-pmo/.mcp.json

{
  "mcpServers": {
    "gitea-pmo": {
      "command": "python",
      "args": ["-m", "mcp_server.server"],
      "cwd": "${CLAUDE_PLUGIN_ROOT}/../mcp-servers/gitea",
      "env": {
        "PYTHONPATH": "${CLAUDE_PLUGIN_ROOT}/../mcp-servers/gitea",
        "GITEA_API_URL": "${GITEA_API_URL}",
        "GITEA_API_TOKEN": "${GITEA_API_TOKEN}",
        "GITEA_OWNER": "${GITEA_OWNER}"
      }
    },
    "wikijs-pmo": {
      "command": "python",
      "args": ["-m", "mcp_server.server"],
      "cwd": "${CLAUDE_PLUGIN_ROOT}/../mcp-servers/wikijs",
      "env": {
        "PYTHONPATH": "${CLAUDE_PLUGIN_ROOT}/../mcp-servers/wikijs",
        "WIKIJS_API_URL": "${WIKIJS_API_URL}",
        "WIKIJS_API_TOKEN": "${WIKIJS_API_TOKEN}",
        "WIKIJS_BASE_PATH": "${WIKIJS_BASE_PATH}"
      }
    }
  }
}

Critical Differences from projman:

• NO GITEA_REPO → operates on all repositories
• NO WIKIJS_PROJECT → operates on entire /your-org namespace
• Same shared MCP servers at ../mcp-servers/

Environment Variables

Required (System-Level Only):

• GITEA_API_URL
• GITEA_API_TOKEN
• GITEA_OWNER
• WIKIJS_API_URL
• WIKIJS_API_TOKEN
• WIKIJS_BASE_PATH

NOT Required:

• GITEA_REPO - PMO operates across all repos
• WIKIJS_PROJECT - PMO operates across entire namespace

---

PMO Coordinator Agent

File: agents/pmo-coordinator.md

Agent Personality

You are the PMO Coordinator for this organization.

Your role:
- Maintain strategic view across all projects
- Identify cross-project dependencies
- Detect resource conflicts
- Balance competing priorities
- Coordinate release timing
- Track customer deployment schedules
- Surface company-wide lessons learned

You are:
- Strategic thinker
- Dependency-aware
- Conflict detector
- Priority balancer
- Team coordinator
- NOT a micromanager

You delegate to project-level agents:
- Don't micromanage single projects
- Focus on cross-project issues
- Surface conflicts early
- Facilitate coordination
- Provide strategic guidance

Available Tools:
- aggregate_issues: Fetch issues across all repositories
- search_all_projects: Search lessons across all projects
- list_repos: Get all organization repositories
- get_shared_docs: Access company-wide patterns and best practices

Key Principles:
1. Strategic overview, not tactical details
2. Cross-project coordination, not single-project management
3. Identify conflicts before they become problems
4. Balance competing priorities across teams
5. Learn from patterns across all projects

Delegation Model

PMO Agent (projman-pmo)
    ├─ Identifies cross-project issues
    ├─ Detects resource conflicts
    ├─ Coordinates release timing
    └─ Delegates to...
        ├─ Planner Agent (projman) → for project planning
        ├─ Orchestrator Agent (projman) → for project execution
        └─ Executor Agent (projman) → for implementation

Example:

User: /pmo-status

PMO: Projects Overview:

     Main-App: Sprint in progress, 60% complete
     └─ Blocking: Main-App-Site deployment

     I notice Main-App-Site is waiting on API changes.
     Use projman in the cuisineflow-site repo to plan the sync work.

---

Commands

1. PMO Status Command

File: commands/pmo-status.md

Usage: /pmo-status

Description: Consolidated view of all active projects

Flow:

User: /pmo-status

PMO: Projects Overview
     ================

     Main-App (main product)
     ├── Sprint: Intuit Engine Extraction
     ├── Status: In Progress (60%)
     ├── Issue: #47
     ├── Blockers: None
     ├── Next: API testing
     └── Timeline: On track (1 week remaining)

     Main-App-Site (demo)
     ├── Sprint: Dashboard Updates
     ├── Status: Waiting on dependencies
     ├── Issue: #12
     ├── Blockers: Depends on Main-App #47 (API changes)
     ├── Next: Deploy when API ready
     └── Timeline: Blocked (waiting on Main-App)

     Intuit-Engine (service)
     ├── Sprint: Initial Setup
     ├── Status: Planning
     ├── Issue: #3
     ├── Blockers: Architecture decisions needed
     ├── Next: Service boundary definition
     └── Timeline: Not started

     Company-Site (marketing)
     ├── Sprint: Content Updates
     ├── Status: Complete
     ├── Issue: #8 (closed)
     ├── Blockers: None
     ├── Next: Deploy to production
     └── Timeline: Ready for deployment

     Cross-Project Insights:
     - Main-App-Site blocked by Main-App #47
     - Intuit-Engine needs architectural guidance
     - Company-Site ready for deployment

     Suggested Actions:
     1. Prioritize Main-App #47 completion (unblocks Site)
     2. Schedule architecture review for Intuit-Engine
     3. Deploy Company-Site content updates

Success Criteria:

• Shows all active projects
• Identifies blockers
• Surfaces dependencies
• Provides actionable insights

2. PMO Priorities Command

File: commands/pmo-priorities.md

Usage: /pmo-priorities

Description: Review and adjust priorities across projects

Flow:

User: /pmo-priorities

PMO: Priority Analysis Across Projects
     =================================

     Critical (Blocks launches):
     1. Main-App #47 - Intuit Engine Extraction
        → Blocks: Main-App v2.0 launch (Nov 15)
        → Blocks: Main-App-Site deployment
        → Status: 60% complete, 1 week remaining
        → Recommendation: Maintain focus

     High (Important features):
     2. Main-App-Site #12 - Dashboard Updates
        → Depends on: Main-App #47
        → Status: Waiting
        → Recommendation: Begin planning, wait for #47

     3. Intuit-Engine #3 - Initial Setup
        → Enables: Service architecture
        → Status: Planning phase
        → Recommendation: Schedule architecture review

     Medium (Enhancements):
     4. Company-Site #8 - Content Updates
        → Status: Complete, ready to deploy
        → Recommendation: Deploy this week

     Resource Analysis:
     Leo (primary developer):
     - Working on: Main-App #47 (Critical)
     - Next: Main-App-Site #12 (High)
     - Later: Intuit-Engine #3 (High)

     ⚠️ Potential Conflict:
     Leo is assigned to 3 high-priority items. Consider:
     - Maintaining focus on #47 (blocks launch)
     - Queueing #12 for after #47 completion
     - Scheduling #3 architecture review with team

     Recommend any priority changes?

Success Criteria:

• Clear priority ranking
• Resource allocation visibility
• Conflict identification
• Actionable recommendations

3. PMO Dependencies Command

File: commands/pmo-dependencies.md

Usage: /pmo-dependencies

Description: Visualize and manage project dependencies

Flow:

User: /pmo-dependencies

PMO: Project Dependencies
     ====================

     Dependency Graph:

     Intuit-Engine (service)
         ↓ (must complete before)
     Main-App (main)
         ↓ (API changes required by)
     Main-App-Site (demo)
         ↓ (deploy together)
     Customer VPS (deployments)

     Detailed Dependencies:

     1. Main-App → Intuit-Engine
        Type: Service extraction
        Status: In progress
        Blocker: Must complete #47 before v2.0 launch
        Impact: High (blocks launch)

     2. Main-App → Main-App-Site
        Type: Feature sync
        Status: Waiting
        Blocker: Dashboard updates need API changes from #47
        Impact: Medium (demo consistency)

     3. Main-App → Customer VPS
        Type: Deployment
        Status: Pending
        Blocker: v2.0 launch must complete before customer updates
        Impact: High (customer commitments)

     Deployment Order:
     1. Complete Intuit-Engine service extraction
     2. Deploy Main-App v2.0 to production
     3. Sync Main-App-Site demo
     4. Update customer VPS instances

     Critical Path:
     Intuit-Engine (#3) → Main-App (#47) → Site (#12) → Customer VPS
     Estimated timeline: 3 weeks total

     Risks:
     - Main-App #47 delay would cascade to all downstream
     - Customer VPS updates have Nov 20 deadline

Success Criteria:

• Dependencies clearly visualized
• Critical path identified
• Deployment order defined
• Risks highlighted

4. PMO Conflicts Command

File: commands/pmo-conflicts.md

Usage: /pmo-conflicts

Description: Detect and resolve resource conflicts

Flow:

User: /pmo-conflicts

PMO: Resource Conflict Analysis
     ==========================

     ⚠️ Resource Conflict Detected

     Leo (Developer):
     Assigned to:
     - Main-App #47: Intuit Engine extraction (Priority: Critical)
     - Main-App-Site #12: Dashboard redesign (Priority: High)
     - Company-Site #8: Content update (Priority: Medium)
     - Intuit-Engine #3: Service setup (Priority: High)

     Conflict Analysis:
     - 4 active assignments across 3 projects
     - 2 are high priority or above
     - Estimated total effort: 4 weeks
     - Timeline: 2 weeks available

     Recommendations:
     1. FOCUS: Main-App #47 (Critical, blocks launch)
        → Keep as primary focus
        → Estimated completion: 1 week

     2. QUEUE: Main-App-Site #12 (High, depends on #47)
        → Start after #47 completes
        → Natural sequencing

     3. DELEGATE: Company-Site #8 (Medium, content work)
        → Can be handled by marketing team
        → Low technical complexity

     4. SCHEDULE: Intuit-Engine #3 (High, planning phase)
        → Schedule architecture review session
        → Team collaboration, not solo work

     Timeline Conflict:

     Without changes:
     Week 1-2: Main-App #47
     Week 3-4: Site #12 + Engine #3 (CONFLICT)

     With recommendations:
     Week 1-2: Main-App #47 (FOCUS)
     Week 3: Main-App-Site #12 (QUEUE)
     Week 4: Intuit-Engine #3 (SCHEDULE)
     Company-Site #8: Marketing (DELEGATE)

     Apply recommendations?

Success Criteria:

• Conflicts identified automatically
• Clear impact analysis
• Actionable recommendations
• Timeline visualization

5. PMO Schedule Command

File: commands/pmo-schedule.md

Usage: /pmo-schedule

Description: Coordinate deployment schedules

Flow:

User: /pmo-schedule

PMO: Deployment Schedule
     ===================

     Week of Nov 6:
     - Main-App: Continue Sprint #47 (Intuit Engine)
     - Company-Site: Deploy content updates (#8) ✅

     Week of Nov 13:
     - Main-App: Complete Sprint #47 ⚠️
       → Critical: Must complete by Nov 15 for launch
     - Main-App-Site: Begin Dashboard updates (#12)

     Week of Nov 20:
     - Main-App: Deploy v2.0 to production 🚀
       → Deployment window: Nov 20-22
     - Main-App-Site: Sync demo with v2.0
     - Customer VPS: Begin rollout (Deadline: Nov 20)

     Week of Nov 27:
     - Customer VPS: Continue rollout
     - Intuit-Engine: Begin service implementation (#3)

     Critical Dates:
     - Nov 15: Main-App v2.0 feature freeze
     - Nov 20: Production deployment
     - Nov 20: Customer VPS deadline
     - Nov 22: Demo site sync

     Dependencies:
     ✅ Intuit-Engine service boundaries defined
     🔄 Main-App #47 in progress (60%)
     ⏳ Main-App-Site #12 waiting
     ⏳ Customer VPS rollout pending

     Risks:
     ⚠️ Main-App #47 delay would impact:
        - v2.0 launch date (Nov 20)
        - Customer VPS deadline (Nov 20)
        - Demo site sync (Nov 22)

     Mitigation:
     - Monitor #47 progress daily
     - Prepare rollback plan for customer VPS
     - Communicate delays early if detected

Success Criteria:

• Clear timeline visibility
• Dependencies tracked
• Critical dates highlighted
• Risk mitigation planned

---

Multi-Project Coordination Workflows

Cross-Project Lessons Learned

User: Search for lessons about service extraction across all projects

PMO: Searching lessons across all projects...

     Found 5 relevant lessons:

     Main-App:
     - Sprint 08: Service boundary issues with shared DB
       Tags: #service-extraction #database #refactoring
       Key: Define boundaries at data model level first

     - Sprint 12: API versioning during extraction
       Tags: #api #versioning #refactoring
       Key: Version APIs from the start

     Intuit-Engine:
     - Sprint 02: Circular dependencies in service init
       Tags: #service-extraction #dependencies
       Key: Watch for import cycles

     Main-App-Site:
     - Sprint 05: Sync issues during backend refactor
       Tags: #sync #refactoring
       Key: Coordinate deployments during major changes

     Shared Patterns:
     - /your-org/shared/architecture-patterns/service-extraction
       Key: Service Extraction Playbook

     Common Themes:
     1. Data model boundaries are critical
     2. API versioning prevents integration issues
     3. Watch for circular dependencies
     4. Coordinate deployments during refactors

     Apply these insights to current Intuit Engine extraction?

Resource Allocation

User: /pmo-status

PMO: [Shows status]

     Resource Analysis:
     - Leo: 3 active projects (Main-App, Site, Engine)
     - Marketing: 1 project (Company-Site)

     Bottleneck detected: Leo is on critical path for all technical work

     Recommendations:
     1. Prioritize work that unblocks others
     2. Consider hiring/contracting for parallel work
     3. Delegate non-critical work (Company-Site content)

     Would you like a detailed resource allocation report?

Release Coordination

User: Plan the v2.0 release across all affected projects

PMO: Release Coordination: Main-App v2.0
     ======================================

     Affected Projects:
     1. Main-App (main product)
     2. Intuit-Engine (new service)
     3. Main-App-Site (demo)
     4. Customer VPS instances

     Pre-Release Checklist:
     ✅ Intuit-Engine service deployed
     🔄 Main-App #47 complete (60%)
     ⏳ Integration tests pending
     ⏳ Demo site updates pending
     ⏳ Customer migration scripts ready

     Deployment Sequence:
     1. Deploy Intuit-Engine service (backend)
        → Date: Nov 18
        → Duration: 2 hours
        → Rollback plan: Ready

     2. Deploy Main-App v2.0 (main app)
        → Date: Nov 20
        → Duration: 4 hours
        → Rollback plan: Ready

     3. Sync Main-App-Site (demo)
        → Date: Nov 22
        → Duration: 1 hour
        → Dependencies: Step 2 complete

     4. Update Customer VPS (production instances)
        → Date: Nov 23-25
        → Duration: Phased rollout
        → Dependencies: Steps 2 and 3 complete

     Communication Plan:
     - Nov 15: Feature freeze announcement
     - Nov 19: Deployment notification
     - Nov 20: v2.0 launch announcement
     - Nov 25: Completion report

     Risks & Mitigation:
     - Risk: #47 completion delayed
       Mitigation: Daily progress checks, adjust timeline early

     - Risk: Integration issues during deployment
       Mitigation: Comprehensive testing, rollback plan ready

     - Risk: Customer VPS migration issues
       Mitigation: Phased rollout, support on standby

---

Company-Wide Patterns

Accessing Shared Documentation

# PMO agent can access company-wide patterns
shared_patterns = await wikijs.get_shared_docs("architecture-patterns")

# Returns:
# - microservices.md
# - api-gateway.md
# - database-per-service.md
# - service-extraction.md (created from lessons learned)

Creating Shared Patterns

User: Create a shared pattern document for service extraction

PMO: I'll create a pattern document based on lessons from:
     - Main-App Sprint 08
     - Main-App Sprint 12
     - Intuit-Engine Sprint 02

     Creating: /your-org/shared/architecture-patterns/service-extraction

     Service Extraction Pattern
     =========================

     ## When to Use
     - Extracting microservice from monolith
     - Creating separate deployable service
     - Isolating domain boundaries

     ## Prerequisites
     - Clear service boundaries defined
     - Data model dependencies mapped
     - API contracts specified

     ## Steps
     1. Define service boundaries at data model level
     2. Design and version APIs first
     3. Extract data layer with foreign key awareness
     4. Implement service logic
     5. Update integration points
     6. Deploy and test

     ## Common Pitfalls
     - Not defining boundaries at data level first
     - Missing API versioning
     - Circular dependencies in initialization
     - Uncoordinated deployments

     ## Lessons Learned
     [Links to specific sprint lessons]

     Created ✅
     Tags: #service-extraction #microservices #refactoring #architecture

     This pattern is now available to all projects.

---

Implementation Phases

Phase 9: PMO Plugin Foundation

Deliverable: PMO plugin requirements and design

Tasks:

1. Analyze multi-project workflows
2. Identify coordination pain points
3. Design PMO agent scope
4. Extend MCP server for multi-repo operations
5. Define delegation model

Success Criteria:

• Clear PMO plugin scope
• Multi-repo queries working
• Delegation model defined
• Doesn't duplicate projman functionality

Phase 10: PMO Commands & Workflows

Deliverable: PMO-specific commands working

Tasks:

1. Implement /pmo-status command
2. Implement /pmo-priorities command
3. Implement /pmo-dependencies command
4. Implement /pmo-conflicts command
5. Implement /pmo-schedule command
6. Build conflict detection logic
7. Create dependency visualization
8. Design release coordination workflow

Success Criteria:

• All commands provide valuable insights
• Dependencies clearly visualized
• Conflicts easily identified
• Coordination reduces manual overhead

Phase 11: PMO Testing & Integration

Deliverable: Validated PMO plugin integrated with projman

Tasks:

1. Test with multiple projects (Main-App, Site, Engine, Company-Site)
2. Simulate deployment coordination scenarios
3. Test priority conflict resolution
4. Validate dependency tracking
5. Test cross-project lessons search
6. Ensure PMO delegates to projman agents

Success Criteria:

• Handles multiple projects correctly
• Dependencies respected
• Conflicts detected and surfaced
• Seamless integration with projman
• Cross-project lessons accessible

Phase 12: Production Deployment

Deliverable: PMO plugin deployed and operational

Tasks:

1. Deploy across all environments (laptop, staging, production)
2. Configure for company-wide access
3. Set up backup and recovery
4. Establish monitoring and maintenance
5. Train team on PMO capabilities

Success Criteria:

• Works in all environments
• Configuration portable
• Backup procedures documented
• Team trained and comfortable

---

PMO vs Projman: Key Differences

Aspect	projman	projman-pmo
Scope	Single repository	All repositories
Configuration	GITEA_REPO + WIKIJS_PROJECT	Neither (company-wide)
Agents	Planner, Orchestrator, Executor	PMO Coordinator
Commands	Sprint-focused	Cross-project coordination
Gitea Access	Single repo issues	All repos issues
Wiki.js Access	Project path	Entire namespace
Primary User	Developer, Team Lead	PMO, Manager, CTO
Focus	Tactical execution	Strategic coordination
Delegation	N/A	Delegates to projman

---

Usage Examples

Example 1: Detecting Blocked Work

User: /pmo-status

PMO: Main-App-Site: Waiting on dependencies
     Blocked by: Main-App #47 (API changes)

     Recommendation: Focus resources on Main-App #47 to unblock Site work

Example 2: Resource Conflict Resolution

User: /pmo-conflicts

PMO: Leo assigned to 4 tasks across 3 projects
     Estimated: 4 weeks work in 2 weeks timeline

     Recommendations:
     - Maintain focus on Critical priority (Main-App #47)
     - Delegate content work (Company-Site #8) to marketing
     - Schedule architectural review (Intuit-Engine #3) as team session

Example 3: Release Planning

User: /pmo-schedule

PMO: Critical Path: Engine → Main-App → Site → Customer VPS
     Deadline: Nov 20 (Customer VPS commitment)

     Current: Week 1 of 3
     Status: On track

     Risk: If Main-App #47 delayed, entire timeline at risk
     Mitigation: Daily progress monitoring

---

Best Practices

1. Use PMO for Strategic View

• Don't micromanage individual projects
• Focus on cross-project issues
• Identify blockers and dependencies
• Balance competing priorities

2. Delegate to Projman

• Use projman for project-specific planning
• Let project teams handle tactical execution
• PMO provides coordination, not implementation

3. Monitor Critical Path

• Identify which work blocks others
• Focus resources on critical path items
• Communicate delays early

4. Learn Across Projects

• Search lessons across all projects
• Create shared patterns from common themes
• Build company-wide knowledge base

5. Coordinate Releases

• Plan deployments across dependent projects
• Communicate timelines clearly
• Have rollback plans ready

---

Troubleshooting

Issue: PMO showing wrong mode

Solution:

# Ensure GITEA_REPO and WIKIJS_PROJECT are NOT set
env | grep GITEA
env | grep WIKIJS

# Should only show:
# GITEA_API_URL, GITEA_API_TOKEN, GITEA_OWNER
# WIKIJS_API_URL, WIKIJS_API_TOKEN, WIKIJS_BASE_PATH

Issue: Can't access all repositories

Solution:

• Verify API token has organization-level access
• Check token permissions in Gitea
• Ensure GITEA_OWNER is correct

Issue: Cross-project search not working

Solution:

• Verify Wiki.js structure exists
• Check base path is correct
• Ensure projects have lessons-learned directories

---

Next Steps

1. Complete projman plugin (Phases 1-8)
2. Validate projman works with real sprints
3. Begin PMO foundation (Phase 9)
4. Implement PMO commands (Phase 10)
5. Test with multiple projects (Phase 11)
6. Deploy to production (Phase 12)