claude-comms 1.0.6 → 1.0.7

package/.claude/settings.json

@@ -0,0 +1,88 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "uv run $CLAUDE_PROJECT_DIR/.claude/hooks/comms/register_subagent.py"
+          },
+          {
+            "type": "command",
+            "command": "uv run $CLAUDE_PROJECT_DIR/.claude/hooks/observability/send_event.py --source-app cc-hook-multi-agent-obvs --event-type PreToolUse --summarize"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "uv run $CLAUDE_PROJECT_DIR/.claude/hooks/comms/update_subagent_completion.py"
+          },
+          {
+            "type": "command",
+            "command": "uv run $CLAUDE_PROJECT_DIR/.claude/hooks/observability/send_event.py --source-app cc-hook-multi-agent-obvs --event-type PostToolUse --summarize"
+          }
+        ]
+      }
+    ],
+    "Notification": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "uv run $CLAUDE_PROJECT_DIR/.claude/hooks/observability/send_event.py --source-app cc-hook-multi-agent-obvs --event-type Notification --summarize"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "uv run $CLAUDE_PROJECT_DIR/.claude/hooks/observability/send_event.py --source-app cc-hook-multi-agent-obvs --event-type Stop --add-chat"
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "uv run $CLAUDE_PROJECT_DIR/.claude/hooks/observability/send_event.py --source-app cc-hook-multi-agent-obvs --event-type SubagentStop"
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "uv run $CLAUDE_PROJECT_DIR/.claude/hooks/observability/send_event.py --source-app cc-hook-multi-agent-obvs --event-type PreCompact"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "uv run $CLAUDE_PROJECT_DIR/.claude/hooks/observability/send_event.py --source-app cc-hook-multi-agent-obvs --event-type UserPromptSubmit --summarize"
+          }
+        ]
+      }
+    ]
+  }
+}

package/CLAUDE.md

@@ -0,0 +1,278 @@
+⚙️〔Task〕***[📣SALIENT❗️: VITAL CONTEXT! READ THIS PROMPT STEP BY STEP!***〔/Task〕⚙️
+
+[Task]***MODEL ADOPTS ROLE [PERSONA]Primary ⚙️Orchestrator***![/Task]
+
+
+
+The CRITICAL ORCHESTRATION PROTOCOLS below defines YOUR mandatory operating procedures as Primary ⚙️Orchestrator
+
+
+# DRINK: Claude Code Multi-Agent Orchestration System
+
+Primary ⚙️Orchestrator engage ULTRATHINK:
+[CRITICAL ORCHESTRATION PROTOCOLS]
+
+## Your Role as Primary ⚙️Orchestrator
+
+You are the PRIMARY ORCHESTRATOR managing multi-agent software delivery. The agent-orchestrator is your STRATEGIC ADVISOR ONLY - they provide recommendations but YOU make all execution decisions and launch all agents.
+
+
+## Tasking Agents
+### Core Naming Protocol
+
+🚨 CRITICAL: Every agent MUST have a unique name (Unique human FirstName, Abstract obscure LastName) in Task() calls:
+
+Format:
+    - description: "<FirstNameLastName>: <3-5 word task description>"
+    - prompt: "Your name is <FirstNameLastName>. [full task instruction and context]"
+    - subagent_type: Select from available agents based on task
+
+Example:
+    - description: "JoseAsic: implement user authentication"
+    - prompt: "Your name is JoseAsic. Implement the user authentication feature..."
+    - subagent_type: "engineer"
+
+⚡ **NEVER**: REUSE names in future batches, each agent exists for a single batch.
+
+### Agent Prompt Template
+
+```
+"Your name is [FirstNameLastName]. 
+Your Team Role is [Primary implementer | Support advisor | Parallel worker]
+
+SCOPE: [Project-level | Phase-level (phase-id: XX-Name)]
+
+YOUR TASK:
+[Specific task description]
+
+CONSTRAINTS:
+[Any dependencies, interfaces, or requirements]
+
+SUCCESS CRITERIA:
+[What constitutes completion]
+
+FILES TO READ FIRST:
+- [filepath1] - [one sentence description]
+- [filepath2] - [one sentence description]
+
+TEAM COLLABORATION:
+- Leverage your Team for [what]
+- Support your Team with [what]
+- Coordinate with your Team on [shared concern]
+
+[FirstNameLastName], adopt 🤝 TEAMWORK to achieve maximum value delivered."
+```
+
+⚡ **ALWAYS**: Provide team collaboration instructions
+
+
+
+## Batch Parallelization Guide
+
+### Intra-Batch Execution (True Parallelism)
+- Launch multiple agents SIMULTANEOUSLY using multiple Task() invocations in a single message
+- Agents within a batch have NO blocking dependencies - they work in parallel
+- Agents CAN communicate and support each other through the messaging system
+- All agents in a batch complete independently without waiting for others
+
+Parallel Specialization Examples
+- **Multiple Engineers**: Each owns different module/file
+- **Multiple Gatekeepers**: One for code quality, one for UI/UX compliance
+- **Support Roles**: Architect answers questions, Researcher provides data, Designer creates storybook assets
+
+### Inter-Batch Sequencing (Dependencies)
+- Wait for ALL agents in current batch to complete before launching next batch
+- Use verification batches after implementation batches
+- Cascade changes through re-verification when upstream modifications occur
+
+Inter-Batch Example (Sequential)
+```
+Research/Architecture → Planning → Implementation → Verification → Next WorkPackage or Phase
+```
+
+### Orchestration Decision Tree
+
+✅ When to parallelize:
+- Independent work packages
+- Multiple similar tasks (e.g., multiple API endpoints)
+- Design + Research simultaneously
+- Test writing alongside implementation
+- Multiple reviewers for large changes
+- NO blocking dependencies between agents
+- NO file editing conflicts (only ONE agent edits each file)
+- Agents collaborate via messaging but complete independently
+- Support roles (Architect, Researcher, Designer) provide real-time guidance
+- Multiple same-type agents OK with different focus areas
+
+⚠️ When to sequence:
+- ⚠️ Clear dependency chain exists
+1. **Functional Dependencies**: Task B needs Task A's output
+2. **File Dependencies**: Tasks modifying same file CANNOT be in same batch
+3. **Verification Dependencies**: Gatekeepers ALWAYS follow implementation (NEVER same batch)
+4. **Knowledge Dependencies**: Planner needs architecture/research to plan against
+
+
+### Example Workflows
+
+#### New Feature Workflow
+1. **Discovery Batch**: [Researcher, Architect, Business-Analyst, Designer]
+2. **Planning Batch**: [Planner] - creates phase-id and WPs
+3. **Consult**: Agent-orchestrator reviews plan
+4. **Implementation Batch**: [5-10 Engineers with distinct role and focus + support agents (maximum 10 total per batch) ]
+5. **Verification + Reco Batch**: [1-3 Gatekeepers with different focus + agent-orchestrator]
+
+#### Bug Fix Workflow
+1. **Investigation Batch**: [Engineer, Architect] - diagnose collaboratively
+2. **Planning Batch**: [Planner] - uses existing phase
+3. **Fix Batch**: [Engineer-Fix, Engineer-Tests] - parallel, different files
+4. **Verification Batch**: [Gatekeeper] - validates fix
+
+#### Architecture Change Workflow
+1. **Research Batch**: [Deep-Researcher, Architect]
+2. **Planning Batch**: [Planner, Business-Analyst]
+3. **Migration Batch**: [Multiple Engineers, supporting architect] - each owns different module
+4. **Verification Batch**: [Multiple Gatekeepers] - compliance check
+
+⚡ **NEVER**: Batch gatekeepers with implementation
+
+### Batch Size Optimization
+
+#### Maximize Parallelization
+- Break work into smallest parallelizable units.
+- Include 5-10 agents when possible
+- Add support roles for real-time guidance
+
+#### Example Large Batch (MAX=10)
+```
+7 Engineers (each owns specific files/modules) +
+2 Support (Architect, Researcher) +
+1 Designer (UI assets and guidance) =
+10 agents working in parallel
+```
+
+### Performance Optimization Tips
+
+1. **Maximize Batch Size**: Include as many parallel agents as have independent work
+2. **Preemptive Support Agents**: Include Architect/Researcher in implementation batches for real-time guidance
+3. **Early Testing**: Include Test suite focused engineers in implementation batches for immediate test creation
+4. **Parallel Reviews**: Multiple reviewers can examine different aspects simultaneously
+5. **Broadcast Coordination**: Agents should announce decisions/discoveries immediately
+
+
+
+## Todo Evolution Pattern
+
+```
+Initial → Agent-Orch Consultation → Refined/Resequenced → 
+Batch Complete → Update → Next Consultation → Iterate
+```
+
+⚡ **ALWAYS**: Update todos immediately
+
+### Agent-Orchestrator Consultation
+
+ALWAYS Consult After
+- User provides assignment
+- Every batch completion
+- Discovering dependency conflicts
+- Planning phase transitions
+
+Provide to Advisor
+- Original user assignment
+- Current todos with batch history
+- Agent responses from last batch
+- Created/modified artifacts list
+
+Apply Recommendations
+- THINK HARD about dependencies identified
+- Refine todos based on sequencing advice
+- Adjust batch composition per suggestions
+- Iterate until advisor approves plan
+
+
+PRO TIP: gatekeeper and agent-orchestrator agents can work in parallel, and both usually follow an implementation Batch... Task them concurrently.
+
+
+
+
+
+## Phase Management & Documentation Structure
+
+### Three-Tier Documentation Hierarchy
+
+1. **Source of Truth Specs** (`docs/project/spec/`)
+   - NO subdirectories
+   - Requirements documents that don't change unless user updates requirements
+   - Only Business-Analyst updates these when user changes requirements
+
+2. **Project-Level Gold Docs** (`docs/project/guides/`)
+   - NO subdirectories
+   - Living documentation: roadmap, architecture, ADRs, design patterns
+   - ALWAYS update existing docs rather than creating new ones
+   - Each document has a distinct purpose
+
+3. **Phase-Level Working Docs** (`docs/project/phases/<phase-id>/`)
+   - Created by Planner when starting a new phase
+   - Contains WP definitions, implementation notes, test plans
+   - Working documents for agent batches
+
+### Phase Management Protocol
+
+### New Feature Detection
+**Indicators**: User describes new functionality, no existing phase context, major feature request
+**Action**: Create phase-id format `XX-DescriptiveName` (e.g., `03-UserAuth`, `04-PaymentFlow`)
+
+### Continuation Detection  
+**Indicators**: Bug fix, refinement, existing thread context, minor adjustment
+**Action**: Use most recent phase if related, or create new.
+
+### Multi-Phase Complexity Detection
+**Indicators**: Sweeping refactor, multi-module impact, core business requirement change.
+**Action**: work at project level. Refine roadmap, architecture. Itterate through phases
+
+### Phase Creation
+- Planner creates `docs/project/phases/<phase-id>/` directory
+- All phase agents receive phase-id and directory path
+- Phase contains: WP definitions, implementation notes, test artifacts
+
+
+
+## Available Core Agents Reference
+
+### Strategic Advisory
+- **agent-orchestrator**: Your strategic advisor for batch composition and sequencing (NO file modifications)
+
+### Planning & Requirements
+- **planner**: Creates phases, roadmaps, and work packages (works at project or phase level)
+- **business-analyst**: Maintains SoT requirements, validates acceptance criteria
+
+### Design & Architecture
+- **architect**: Defines system shape, interfaces, technology decisions, Designs test strategies
+- **designer**: Creates UI/UX specifications, component libraries
+
+### Implementation
+- **engineer**: Implements features end-to-end with code, writes comprehensive test suites, and documentation
+
+### Verification
+- **gatekeeper**: Reviews code for quality, security, and standards compliance. Ensures all builds, tests, and checks pass. Script playwright to screenshot UI, then visually inspect and assess agsinst UI/UX design/guide.
+
+### Research & Support
+- **deep-researcher**: Conducts targeted research for technical decisions
+
+
+## Critical Reminders
+
+1. **You are the Primary Orchestrator** - agent-orchestrator only advises
+2. **TodoWrite continuously** - Update after every action
+3. **Batch everything possible** - Launch parallel agents in single message
+4. **Verify everything** - No skipping quality gates
+5. **Context discipline** - Give agents minimal but complete context
+6. **Phase management** - Provide phase-id when working at phase level
+7. **Document hierarchy** - Respect spec/ vs guides/ vs phases/
+8. **Agent responses** - Process fully and feed to agent-orchestrator
+
+
+[/CRITICAL ORCHESTRATION PROTOCOLS]
+
+
+⚙️Remember: The key to effective orchestration is understanding which work can truly happen in parallel and launching those agents together, while respecting sequential dependencies between batches.⚙️

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-comms",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "NPX installer for Claude Code hooks and observability setup",
   "main": "src/index.js",
   "bin": {
@@ -77,7 +77,9 @@
     "src/",
     "templates/",
     "README.md",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    ".claude/",
+    "CLAUDE.md"
   ],
   "publishConfig": {
     "access": "public"

package/src/fetcher/github.js

@@ -153,7 +153,7 @@ class GitHubFetcher extends EventEmitter {
    */
   async fetchAsTarball(options = {}) {
     const fetchOptions = this._prepareFetchOptions(options);
-    
+
     this.emit('progress', {
       task: 'fetch_tarball',
       current: 0,
@@ -164,9 +164,9 @@ class GitHubFetcher extends EventEmitter {
     try {
       // Download tarball from GitHub
       const tarballBuffer = await this._downloadTarball(fetchOptions);
-      
+
       this.emit('progress', {
-        task: 'fetch_tarball', 
+        task: 'fetch_tarball',
         current: 50,
         message: 'Extracting files from tarball...',
         status: 'running'
@@ -591,17 +591,17 @@ class GitHubFetcher extends EventEmitter {
       if (error.code === 'GITHUB_RATE_LIMIT') {
         // Check if we should fail fast
         this._shouldFailFastOnRateLimit();
-        
+
         // Calculate smart rate limit delay
         const delay = this._calculateRateLimitDelay();
-        
+
         if (delay > 0) {
           console.warn(`Rate limit exceeded. Waiting ${Math.round(delay / 1000)}s before retry ${attempt + 1}/${this.config.retryCount}`);
-          
+
           if (!this.config.token) {
             console.warn('💡 Tip: Set GITHUB_TOKEN environment variable to increase rate limits (5,000/hour vs 60/hour)');
           }
-          
+
           // Show countdown for longer waits
           if (delay > 5000) {
             await this._waitWithCountdown(delay);
@@ -656,8 +656,8 @@ class GitHubFetcher extends EventEmitter {
     if (timeUntilReset > 5 * 60 * 1000) {
       throw new GitHubAPIError(
         `Rate limit reset time too far in future (${Math.round(timeUntilReset / 1000)}s). Consider using a GitHub token or try again later.`,
-        { 
-          resetTime: this.rateLimitReset, 
+        {
+          resetTime: this.rateLimitReset,
           delaySeconds: Math.round(timeUntilReset / 1000),
           suggestion: 'Use GITHUB_TOKEN environment variable to increase rate limits'
         }
@@ -677,13 +677,13 @@ class GitHubFetcher extends EventEmitter {
     }
 
     const timeUntilReset = this.rateLimitReset - Date.now();
-    
+
     // Fail fast if rate limit won't reset for more than 5 minutes
     if (timeUntilReset > 5 * 60 * 1000) {
       throw new GitHubAPIError(
         `Rate limit reset time too far in future (${Math.round(timeUntilReset / 1000)}s). Installation cancelled.`,
-        { 
-          resetTime: this.rateLimitReset, 
+        {
+          resetTime: this.rateLimitReset,
           delaySeconds: Math.round(timeUntilReset / 1000),
           suggestion: 'Use GITHUB_TOKEN environment variable or try again later'
         }
@@ -701,17 +701,17 @@ class GitHubFetcher extends EventEmitter {
     if (this.rateLimitReset && Date.now() < this.rateLimitReset) {
       // Use smart rate limit delay calculation
       const delay = this._calculateRateLimitDelay();
-      
+
       if (delay > 0) {
         console.warn(`Rate limit active, waiting ${Math.round(delay / 1000)}s`);
-        
+
         if (delay > 5000) {
           await this._waitWithCountdown(delay);
         } else {
           await this._sleep(delay);
         }
       }
-      
+
       this.rateLimitReset = null;
     }
   }
@@ -741,16 +741,16 @@ class GitHubFetcher extends EventEmitter {
   async _waitWithCountdown(totalMs) {
     const intervalMs = 1000; // Update every second
     let remainingMs = totalMs;
-    
+
     while (remainingMs > 0) {
       const remainingSeconds = Math.ceil(remainingMs / 1000);
       process.stdout.write(`\r⏳ Rate limit wait: ${remainingSeconds}s remaining...`);
-      
+
       const sleepTime = Math.min(intervalMs, remainingMs);
       await this._sleep(sleepTime);
       remainingMs -= sleepTime;
     }
-    
+
     process.stdout.write('\r✅ Rate limit wait complete.\n');
   }
 
@@ -760,10 +760,10 @@ class GitHubFetcher extends EventEmitter {
    */
   async _waitForRateLimit() {
     const delay = this._calculateRateLimitDelay();
-    
+
     if (delay > 0) {
       console.warn(`Rate limit active, waiting ${Math.round(delay / 1000)}s`);
-      
+
       if (delay > 5000) {
         await this._waitWithCountdown(delay);
       } else {
@@ -834,7 +834,7 @@ class GitHubFetcher extends EventEmitter {
     const url = `${this.config.baseUrl}/repos/${this.repository.owner}/${this.repository.repo}/tarball/${version}`;
 
     const response = await this._makeRequest(url);
-    
+
     if (!response.ok) {
       throw new GitHubAPIError(
         `Failed to download tarball: ${response.status} ${response.statusText}`,
@@ -844,7 +844,7 @@ class GitHubFetcher extends EventEmitter {
 
     // Download tarball as buffer
     const buffer = await response.buffer();
-    
+
     if (buffer.length === 0) {
       throw new GitHubAPIError(
         'Downloaded tarball is empty',
@@ -872,7 +872,7 @@ class GitHubFetcher extends EventEmitter {
 
       // Create temporary directory for extraction
       const tempDir = path.join(os.tmpdir(), `claude-extract-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-      
+
       // Track files we want to keep
       const wantedFiles = new Map();
       let rootDirName = null;
@@ -882,7 +882,7 @@ class GitHubFetcher extends EventEmitter {
         filter: (filePath, entry) => {
           // Debug logging
           console.log(`DEBUG: Processing ${filePath} (type: ${entry.type})`);
-          
+
           // Auto-detect root directory from first file/directory path
           if (!rootDirName) {
             // GitHub tarballs typically have format: "owner-repo-hash/path/to/file"
@@ -894,26 +894,26 @@ class GitHubFetcher extends EventEmitter {
           }
 
           // Remove root directory prefix to get actual file path
-          const actualPath = rootDirName && filePath.startsWith(rootDirName + '/') ? 
+          const actualPath = rootDirName && filePath.startsWith(rootDirName + '/') ?
             filePath.slice(rootDirName.length + 1) : filePath;
-          
+
           // Only extract files we care about
           const isClaudeFile = actualPath.startsWith('.claude/') || actualPath === '.claude';
           const isClaudeMd = actualPath === 'CLAUDE.md';
-          
+
           console.log(`DEBUG: ${actualPath} -> claude: ${isClaudeFile}, md: ${isClaudeMd}, type: ${entry.type}`);
-          
+
           if ((isClaudeFile || isClaudeMd) && entry.type === 'File') {
             wantedFiles.set(filePath, actualPath);
             console.log(`DEBUG: Will extract: ${filePath} -> ${actualPath}`);
             return true;
           }
-          
+
           // Also allow .claude directories to be processed for their children
           if (isClaudeFile && entry.type === 'Directory') {
             return true;
           }
-          
+
           return false;
         }
       });
@@ -928,18 +928,18 @@ class GitHubFetcher extends EventEmitter {
       extractStream.on('finish', async () => {
         try {
           console.log(`DEBUG: Processing ${wantedFiles.size} extracted files`);
-          
+
           // Process extracted files
           for (const [extractedPath, actualPath] of wantedFiles) {
             const fullPath = path.join(tempDir, extractedPath);
-            
+
             try {
               const stats = await fs.promises.stat(fullPath);
-              
+
               if (stats.isFile()) {
                 const content = await fs.promises.readFile(fullPath, 'utf-8');
                 console.log(`DEBUG: Read ${actualPath} (${content.length} bytes)`);
-                
+
                 if (actualPath === 'CLAUDE.md') {
                   const claudeMdFileObj = {
                     path: 'CLAUDE.md',
@@ -948,7 +948,7 @@ class GitHubFetcher extends EventEmitter {
                     type: 'file'
                   };
                   extractedFiles['CLAUDE.md'] = claudeMdFileObj;
-                  console.log(`DEBUG: Added CLAUDE.md to result`);
+                  console.log('DEBUG: Added CLAUDE.md to result');
                 } else if (actualPath.startsWith('.claude/')) {
                   // Add to .claude files
                   const fileObj = {
@@ -957,10 +957,10 @@ class GitHubFetcher extends EventEmitter {
                     encoding: 'utf-8',
                     type: 'file'
                   };
-                  
+
                   extractedFiles['.claude'].files.push(fileObj);
                   console.log(`DEBUG: Added ${actualPath} to .claude files (${extractedFiles['.claude'].files.length} total)`);
-                  
+
                   // Build directory structure for compatibility
                   const relativePath = actualPath.slice('.claude/'.length);
                   this._addToDirectoryStructure(extractedFiles['.claude'], relativePath, fileObj);
@@ -983,7 +983,7 @@ class GitHubFetcher extends EventEmitter {
           }
 
           resolve(extractedFiles);
-          
+
         } catch (processingError) {
           reject(new GitHubAPIError(
             `File processing failed: ${processingError.message}`,
@@ -1010,15 +1010,15 @@ class GitHubFetcher extends EventEmitter {
    * Add file to directory structure for compatibility with existing code
    * @private
    */
-  _addToDirectoryStructure(claudeDir, relativePath, fileObj) {
+  _addToDirectoryStructure(claudeDir, relativePath, _fileObj) {
     const parts = relativePath.split('/');
     let currentLevel = claudeDir.children;
     let currentPath = '.claude';
-    
+
     for (let i = 0; i < parts.length; i++) {
       const part = parts[i];
       currentPath = `${currentPath}/${part}`;
-      
+
       if (i === parts.length - 1) {
         // This is the file
         currentLevel.push({
@@ -1056,17 +1056,17 @@ async function fetchRepository(gitRef = 'main', options = {}) {
     // Strategy 1: Tarball approach (fastest, single request)
     console.log('Attempting tarball fetch strategy...');
     const tarballFiles = await fetcher.fetchAsTarball({ version: gitRef });
-    
+
     return {
       claudeDirectory: tarballFiles['.claude'],
       claudeFile: tarballFiles['CLAUDE.md'],
       files: [...(tarballFiles['.claude'].files || []), tarballFiles['CLAUDE.md']]
     };
-    
+
   } catch (tarballError) {
     console.warn(`Tarball fetch failed: ${tarballError.message}`);
     console.log('Falling back to individual file fetch strategy...');
-    
+
     try {
       // Strategy 2: Individual file fetch (fallback)
       const [claudeDir, claudeMd] = await Promise.all([
@@ -1079,7 +1079,7 @@ async function fetchRepository(gitRef = 'main', options = {}) {
         claudeFile: claudeMd,
         files: [...(claudeDir.files || []), claudeMd]
       };
-      
+
     } catch (fallbackError) {
       console.error('Both tarball and individual fetch strategies failed');
       throw new Error(