@xelth/eck-snapshot 5.9.0 → 6.6.0

package/src/utils/fileUtils.js

@@ -1,13 +1,44 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { execa } from 'execa';
+
+/**
+ * Safely extracts metadata headers from Large ML models without loading them into memory.
+ */
+export async function readMlModelMetadata(filePath) {
+  let fileHandle;
+  try {
+    fileHandle = await fs.open(filePath, 'r');
+    const stats = await fileHandle.stat();
+    const readSize = Math.min(stats.size, 4096); // Read only the first 4KB
+    const buffer = Buffer.alloc(readSize);
+    await fileHandle.read(buffer, 0, readSize, 0);
+
+    let text = buffer.toString('utf8');
+    // Extract printable characters, keeping JSON structure intact, remove binary gibberish
+    let cleanText = text.replace(/[^\x20-\x7E\n\r\t"{}\[\]:,]/g, '').trim();
+
+    if (cleanText.length > 2000) {
+      cleanText = cleanText.substring(0, 2000) + '\n...';
+    }
+
+    return `[ML MODEL METADATA EXTRACTED]\nSize: ${formatSize(stats.size)}\n\nHeader Preview:\n${cleanText}\n\n[... BINARY DATA TRUNCATED ...]`;
+  } catch (error) {
+    return `[ML MODEL - Could not extract metadata: ${error.message}]`;
+  } finally {
+    if (fileHandle) await fileHandle.close();
+  }
+}
 import ignore from 'ignore';
-import { detectProjectType, getProjectSpecificFiltering } from './projectDetector.js';
-import { executePrompt as askClaude } from '../services/claudeCliService.js';
+import { detectProjectType, getProjectSpecificFiltering, getAllDetectedTypes } from './projectDetector.js';
 import { getProfile, loadSetupConfig } from '../config.js';
 import micromatch from 'micromatch';
 import { minimatch } from 'minimatch';
 
+// Global hard-ignore patterns (shared between git-based and scan-based file collection)
+const GLOBAL_HARD_IGNORE_DIRS = ['node_modules', '.git', '.idea', '.vscode', '.gradle', 'build', '__pycache__'];
+const GLOBAL_HARD_IGNORE_FILES = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'go.sum'];
+
 /**
  * Scanner for detecting and redacting secrets (API keys, tokens)
  */
@@ -29,6 +60,21 @@ export const SecretScanner = {
     }
   ],
 
+  /**
+   * Calculates Shannon Entropy of a string
+   */
+  calculateEntropy(str) {
+    const len = str.length;
+    const frequencies = Array.from(str).reduce((freq, c) => {
+      freq[c] = (freq[c] || 0) + 1;
+      return freq;
+    }, {});
+    return Object.values(frequencies).reduce((sum, f) => {
+      const p = f / len;
+      return sum - (p * Math.log2(p));
+    }, 0);
+  },
+
   /**
    * Scans content and replaces detected secrets with a placeholder
    * @param {string} content - File content to scan
@@ -55,6 +101,21 @@ export const SecretScanner = {
       }
     }
 
+    // Second pass: Shannon Entropy check for arbitrary hardcoded secrets
+    // Look for long strings assigned to variable names that might be keys
+    const entropyRegex = /(?:const|let|var|set|export|define)\s+([A-Za-z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD)[A-Za-z0-9_]*)\s*=\s*["']([a-zA-Z0-9+/=_-]{20,128})["']/gi;
+    const entropyMatches = [...redactedContent.matchAll(entropyRegex)];
+    
+    for (const match of entropyMatches) {
+      const secretValue = match[2];
+      // Check entropy - random base64 usually has entropy > 4.5
+      if (this.calculateEntropy(secretValue) > 4.5 && !secretValue.includes('REDACTED')) {
+        const placeholder = `[REDACTED_HIGH_ENTROPY_SECRET]`;
+        redactedContent = redactedContent.replace(secretValue, placeholder);
+        foundSecrets.push('High Entropy Secret');
+      }
+    }
+
     return {
       content: redactedContent,
       found: [...new Set(foundSecrets)]
@@ -143,17 +204,17 @@ export async function checkGitRepository(repoPath) {
   }
 }
 
-export async function scanDirectoryRecursively(dirPath, config, relativeTo = dirPath, projectType = null, trackConfidential = false) {
+export async function scanDirectoryRecursively(dirPath, config, relativeTo = dirPath, projectTypes = null, trackConfidential = false) {
   const files = [];
   const confidentialFiles = [];
 
-  // Get project-specific filtering if not provided
-  if (!projectType) {
+  // Get project-specific filtering for ALL detected types (polyglot monorepo support)
+  if (!projectTypes) {
     const detection = await detectProjectType(relativeTo);
-    projectType = detection.type;
+    projectTypes = getAllDetectedTypes(detection);
   }
 
-  const projectSpecific = await getProjectSpecificFiltering(projectType);
+  const projectSpecific = await getProjectSpecificFiltering(projectTypes);
 
   // Merge project-specific filters with global config
   const effectiveConfig = {
@@ -171,21 +232,10 @@ export async function scanDirectoryRecursively(dirPath, config, relativeTo = dir
       const relativePath = path.relative(relativeTo, fullPath).replace(/\\/g, '/');
 
       // --- GLOBAL HARD IGNORES (Zero-Config Safety) ---
-      // Explicitly skip heavy/system directories and lockfiles everywhere
-      if (entry.isDirectory()) {
-        if (entry.name === 'node_modules' ||
-            entry.name === '.git' ||
-            entry.name === '.idea' ||
-            entry.name === '.vscode') {
-          continue;
-        }
-      } else {
-        if (entry.name === 'package-lock.json' ||
-            entry.name === 'yarn.lock' ||
-            entry.name === 'pnpm-lock.yaml' ||
-            entry.name === 'go.sum') {
-          continue;
-        }
+      if (entry.isDirectory() && GLOBAL_HARD_IGNORE_DIRS.includes(entry.name)) {
+        continue;
+      } else if (!entry.isDirectory() && GLOBAL_HARD_IGNORE_FILES.includes(entry.name)) {
+        continue;
       }
       // -----------------------------------------------
 
@@ -205,7 +255,7 @@ export async function scanDirectoryRecursively(dirPath, config, relativeTo = dir
       }
 
       if (entry.isDirectory()) {
-        const subResult = await scanDirectoryRecursively(fullPath, effectiveConfig, relativeTo, projectType, trackConfidential);
+        const subResult = await scanDirectoryRecursively(fullPath, effectiveConfig, relativeTo, projectTypes, trackConfidential);
         if (trackConfidential) {
           files.push(...subResult.files);
           confidentialFiles.push(...subResult.confidentialFiles);
@@ -241,14 +291,23 @@ export async function scanDirectoryRecursively(dirPath, config, relativeTo = dir
 }
 
 export async function loadGitignore(repoPath) {
+  const ig = ignore();
+
   try {
     const gitignoreContent = await fs.readFile(path.join(repoPath, '.gitignore'), 'utf-8');
-    const ig = ignore().add(gitignoreContent);
-    return ig;
+    ig.add(gitignoreContent);
   } catch {
     console.log('ℹ️ No .gitignore file found or could not be read');
-    return ignore();
   }
+
+  try {
+    const eckignoreContent = await fs.readFile(path.join(repoPath, '.eckignore'), 'utf-8');
+    ig.add(eckignoreContent);
+  } catch {
+    // .eckignore is optional, silently skip if missing
+  }
+
+  return ig;
 }
 
 export async function readFileWithSizeCheck(filePath, maxFileSize) {
@@ -279,12 +338,19 @@ export async function generateDirectoryTree(dir, prefix = '', allFiles, depth =
     const validEntries = [];
     
     for (const entry of sortedEntries) {
+      // --- GLOBAL HARD IGNORES ---
+      if (entry.isDirectory() && GLOBAL_HARD_IGNORE_DIRS.includes(entry.name)) continue;
+      if (!entry.isDirectory() && GLOBAL_HARD_IGNORE_FILES.includes(entry.name)) continue;
+      // ---------------------------
+
       // Skip hidden directories and files (starting with '.')
       // EXCEPT: Allow .eck to be visible
       if (entry.name.startsWith('.') && entry.name !== '.eck') {
         continue;
       }
-      if (config.dirsToIgnore.some(d => entry.name.includes(d.replace('/', '')))) continue;
+      // Only skip directories (not files) and use exact name match to avoid
+      // substring false positives (e.g., "build/" hiding "build.gradle.kts")
+      if (entry.isDirectory() && config.dirsToIgnore.some(d => entry.name === d.replace('/', ''))) continue;
       const fullPath = path.join(dir, entry.name);
       const relativePath = path.relative(process.cwd(), fullPath).replace(/\\/g, '/');
 
@@ -598,7 +664,8 @@ export function displayProjectInfo(detection) {
   }
   
   if (detection.allDetections && detection.allDetections.length > 1) {
-    console.log(`   Other possibilities: ${detection.allDetections.slice(1).map(d => d.type).join(', ')}`);
+    const otherTypes = detection.allDetections.slice(1).map(d => d.type).join(', ');
+    console.log(`   Polyglot filtering: applying rules for [${detection.type}, ${otherTypes}]`);
   }
   
   console.log('');
@@ -635,48 +702,83 @@ function parseEnvironmentYaml(content) {
  */
 export async function loadProjectEckManifest(repoPath) {
   const eckDir = path.join(repoPath, '.eck');
-  
+
   try {
-    // Check if .eck directory exists
     const eckStats = await fs.stat(eckDir);
     if (!eckStats.isDirectory()) {
       return null;
     }
-    
-    console.log('📋 Found .eck directory - loading project manifest...');
-    
+
+    console.log('📋 Found .eck directory - dynamically loading project manifest...');
+
     const manifest = {
       environment: {},
       context: '',
       operations: '',
       journal: '',
       roadmap: '',
-      techDebt: ''
+      techDebt: '',
+      dynamicFiles: {}
     };
 
-    // Define the files to check
-    const files = [
-      { name: 'ENVIRONMENT.md', key: 'environment', parser: parseEnvironmentYaml },
-      { name: 'CONTEXT.md', key: 'context', parser: content => content },
-      { name: 'OPERATIONS.md', key: 'operations', parser: content => content },
-      { name: 'JOURNAL.md', key: 'journal', parser: content => content },
-      { name: 'ROADMAP.md', key: 'roadmap', parser: content => content },
-      { name: 'TECH_DEBT.md', key: 'techDebt', parser: content => content }
-    ];
-    
-    // Process each file
-    for (const file of files) {
-      const filePath = path.join(eckDir, file.name);
+    const entries = await fs.readdir(eckDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith('.md')) {
+        continue;
+      }
+
+      // Ignore secret/credential files AND internal tool files
+      const lower = entry.name.toLowerCase();
+      if (
+        lower.includes('secret') ||
+        lower.includes('credential') ||
+        lower.includes('server_access') ||
+        entry.name === 'profile_generation_guide.md'
+      ) {
+        continue;
+      }
+
+      const filePath = path.join(eckDir, entry.name);
       try {
         const content = await fs.readFile(filePath, 'utf-8');
-        manifest[file.key] = file.parser(content.trim());
-        console.log(`   ✅ Loaded ${file.name}`);
+        const cleanContent = content.trim();
+
+        // Map well-known files to their dedicated manifest keys
+        switch (entry.name) {
+          case 'ENVIRONMENT.md':
+            try {
+              manifest.environment = parseEnvironmentYaml(cleanContent);
+            } catch (e) {
+              manifest.dynamicFiles[entry.name] = cleanContent;
+            }
+            break;
+          case 'CONTEXT.md':
+            manifest.context = cleanContent;
+            break;
+          case 'OPERATIONS.md':
+            manifest.operations = cleanContent;
+            break;
+          case 'JOURNAL.md':
+            manifest.journal = cleanContent;
+            break;
+          case 'ROADMAP.md':
+            manifest.roadmap = cleanContent;
+            break;
+          case 'TECH_DEBT.md':
+            manifest.techDebt = cleanContent;
+            break;
+          default:
+            // All other .md files (ARCHITECTURE, RUNTIME_STATE, DEPLOY_CHECKLIST, etc.)
+            manifest.dynamicFiles[entry.name] = cleanContent;
+            break;
+        }
+        console.log(`   ✅ Loaded ${entry.name}`);
       } catch (error) {
-        // File doesn't exist or can't be read - that's okay, use default
-        console.log(`   ⚠️  ${file.name} not found or unreadable`);
+        console.log(`   ⚠️  ${entry.name} not found or unreadable`);
       }
     }
-    
+
     return manifest;
   } catch (error) {
     // .eck directory doesn't exist - that's normal
@@ -838,14 +940,11 @@ export async function applyProfileFilter(allFiles, profileString, repoPath) {
 export async function initializeEckManifest(projectPath) {
   const eckDir = path.join(projectPath, '.eck');
 
-  // Load setup configuration to check AI generation settings
-  let aiGenerationEnabled = false;
+  let setupConfig = null;
   try {
-    const setupConfig = await loadSetupConfig();
-    aiGenerationEnabled = setupConfig?.aiInstructions?.manifestInitialization?.aiGenerationEnabled ?? false;
+    setupConfig = await loadSetupConfig();
   } catch (error) {
-    // If setup config fails to load, default to disabled
-    console.warn(`   ⚠️ Could not load setup config: ${error.message}. AI generation disabled.`);
+    // If setup config fails to load, continue with defaults
   }
 
   try {
@@ -879,82 +978,45 @@ export async function initializeEckManifest(projectPath) {
     await fs.mkdir(eckDir, { recursive: true });
     console.log('📋 Initializing .eck manifest directory...');
 
-    // --- NEW HYBRID LOGIC --- 
-    // 1. Run static analysis first to gather facts.
+    // Gather basic project info for stub templates
     let staticFacts = {};
     try {
       staticFacts = await detectProjectType(projectPath);
-      console.log(`   🔍 Static analysis complete. Detected type: ${staticFacts.type}`);
     } catch (e) {
-      console.warn(`   ⚠️ Static project detection failed: ${e.message}. Proceeding with generic prompts.`);
+      // Non-critical
     }
 
-    // Prevent AI hallucination by removing low-confidence "other possibilities"
-    if (staticFacts && staticFacts.allDetections) {
-      delete staticFacts.allDetections;
-    }
-    
-    const staticFactsJson = JSON.stringify(staticFacts, null, 2);
-    // --- END NEW LOGIC ---
+    const projName = setupConfig?.projectContext?.name || path.basename(projectPath) || 'project';
+    const projType = setupConfig?.projectContext?.type || staticFacts.type || 'unknown';
+    const projStack = (setupConfig?.projectContext?.architecture?.stack?.length > 0)
+      ? setupConfig.projectContext.architecture.stack.join(', ')
+      : 'TBD';
     
-    // 3. Define smarter templates and prompts with "STUB NOTICES"
+    // Static stub templates — AI agents fill these in via their AGENTS.md/CLAUDE.md instructions
     const templateConfigs = {
       'ENVIRONMENT.md': {
-        prompt: `Generate raw YAML for .eck/ENVIRONMENT.md based on these project facts:\n${staticFactsJson}\nInclude project_type, runtime, and agent_id: local_dev. NO markdown fences.`,
-        fallback: `project_type: ${staticFacts.type || 'unknown'}
-# [STUB: ENVIRONMENT.MD]
-# ARCHITECT: Task Coder to verify environment variables.
-# CODER: Scan project for .env files or config files and fill this. Remove this stub notice.
-agent_id: local_dev
-`
+        content: `project_type: ${projType}\nagent_id: local_dev\n`
       },
       'CONTEXT.md': {
-        prompt: `Analyze these project files and dependencies:\n${staticFactsJson}\nGenerate a professional # Project Overview in Markdown. Describe the actual architecture and purpose of this specific project. Be technical and concise. Start with '# Project Overview'.`,
-        fallback: `# [STUB: CONTEXT.MD]
-
-## 🚨 ATTENTION ARCHITECT & CODER
-**ARCHITECT:** This file is EMPTY. You MUST prioritize a task for the Coder to analyze the source code and define the Project Overview, Architecture, and Key Technologies.
-**CODER:** Use your tools to read the code, write the real content, and DELETE this entire stub header.
-
-## Description
-(Placeholder: A ${staticFacts.type || 'project'} project)
-
-## Architecture
-(Placeholder: TBD)`
+        content: `# [STUB: CONTEXT.md]\n\nProject: ${projName} | Type: ${projType} | Stack: ${projStack}\n\nAI Agent: please update this file based on your analysis of the codebase.\n`
       },
       'OPERATIONS.md': {
-        prompt: `Look at the dependencies and files:\n${staticFactsJson}\nGenerate a Markdown guide for common operations (Setup, Run, Test, Build) using the correct commands for this tech stack. Start with '# Common Operations'.`,
-        fallback: `# [STUB: OPERATIONS.MD]
-
-## 🚨 ATTENTION
-**CODER:** Run \`npm run\`, check Makefile, or build files to identify REAL commands for Setup, Running, and Testing. Replace this stub with actual commands. Remove this notice.
-
-## Setup
-${staticFacts.type === 'nodejs' ? 'npm install' : 'TBD'}`
+        content: `# [STUB: OPERATIONS.md]\n\nAI Agent: please update with actual setup, run, and test commands.\n\n## Setup\n${staticFacts.type === 'nodejs' ? '\\`\\`\\`bash\\nnpm install\\n\\`\\`\\`' : 'TBD'}\n`
       },
       'ROADMAP.md': {
-        prompt: `Based on the project type (${staticFacts.type}), propose a 3-step roadmap. Start with '# Project Roadmap'.`,
-        fallback: `# [STUB: ROADMAP.MD]
-
-**ARCHITECT:** Set a real roadmap based on user goals. **CODER:** Remove this stub marker once a real goal is added.`
+        content: `# [STUB: ROADMAP.md]\n\nAI Agent: please set a real roadmap based on project goals.\n`
       },
       'TECH_DEBT.md': {
-        prompt: `Given this is a ${staticFacts.type} project, list 2-3 common technical debt items. Start with '# Technical Debt'.`,
-        fallback: `# [STUB: TECH_DEBT.MD]
-
-**CODER:** Scan for TODOs/FIXMEs or structural issues and list them here. Remove this stub marker.`
+        content: `# [STUB: TECH_DEBT.md]\n\nAI Agent: please scan for TODOs/FIXMEs or structural issues and list them here.\n`
+      },
+      'DEPLOY_CHECKLIST.md': {
+        content: `# [STUB: DEPLOY_CHECKLIST.md]\n\n- [ ] Verify all tests pass\n- [ ] Build assets\n- [ ] Check environment variables\n\nAI Agent: please update with actual deploy steps.\n`
+      },
+      'RUNTIME_STATE.md': {
+        content: `# [STUB: RUNTIME_STATE.md]\n\nAI Agent: check actual runtime state (ports, processes, env vars) and update this file.\n\n- **Server:** TBD\n- **Services:** TBD\n`
       },
       'JOURNAL.md': {
-        fallback: `# Development Journal
-
-## Recent Changes
----
-type: feat
-scope: project
-summary: Initial manifest generated (PENDING REVIEW)
-date: ${new Date().toISOString().split('T')[0]}
----
-- NOTICE: Some .eck files are STUBS. They need manual or AI-assisted verification.`
+        content: `# Development Journal\n\n## Recent Changes\n---\ntype: feat\nscope: project\nsummary: Initial manifest generated (PENDING REVIEW)\ndate: ${new Date().toISOString().split('T')[0]}\n---\n- NOTICE: Some .eck files are STUBS. They need manual or AI-assisted verification.\n`
       }
     };
     
@@ -971,40 +1033,8 @@ date: ${new Date().toISOString().split('T')[0]}
         // File doesn't exist, create it
       }
 
-      let fileContent = config.fallback; // Start with stub fallback
-      let generatedByAI = false;
-
-      // For files with a prompt, try to dynamically generate (only if enabled)
-      if (config.prompt && aiGenerationEnabled) {
-        try {
-          console.log(`   🧠 Attempting to auto-generate ${fileName} via Claude...`);
-          const aiResponseObject = await askClaude(config.prompt);
-          const rawText = aiResponseObject.result;
-
-          if (!rawText || typeof rawText.replace !== 'function') {
-             throw new Error(`AI returned invalid content type: ${typeof rawText}`);
-          }
-
-          // Basic cleanup of potential markdown code blocks from Claude
-          const cleanedResponse = rawText.replace(/^```(markdown|yaml)?\n|```$/g, '').trim();
-
-          if (cleanedResponse) {
-            fileContent = cleanedResponse;
-            generatedByAI = true;
-            console.log(`   ✨ AI successfully generated ${fileName}`);
-          } else {
-            throw new Error('AI returned empty content.');
-          }
-        } catch (error) {
-          console.warn(`   ⚠️ AI generation failed for ${fileName}: ${error.message}. Using stub template.`);
-          // fileContent is already set to the stub fallback
-        }
-      }
-
-      await fs.writeFile(filePath, fileContent);
-      if (!generatedByAI) {
-          console.log(`   ✅ Created ${fileName} (stub template)`);
-      }
+      await fs.writeFile(filePath, config.content);
+      console.log(`   ✅ Created ${fileName} (stub template)`);
     }
     
     console.log('📋 .eck manifest initialized! Edit the files to provide project-specific context.');
@@ -1014,3 +1044,41 @@ date: ${new Date().toISOString().split('T')[0]}
     console.warn(`⚠️  Warning: Could not initialize .eck manifest: ${error.message}`);
   }
 }
+
+
+
+function isHiddenPath(filePath) {
+  const parts = filePath.split('/');
+  return parts.some(part => part.startsWith('.') && part !== '.eck');
+}
+
+/**
+ * Gets project files using git ls-files (preferred) or scanDirectoryRecursively as fallback.
+ * Applies global hard-ignore filters and project-specific filtering.
+ */
+export async function getProjectFiles(projectPath, config) {
+  const isGitRepo = await checkGitRepository(projectPath);
+  if (isGitRepo) {
+    const { stdout } = await execa('git', ['ls-files'], { cwd: projectPath });
+    const gitFiles = stdout.split('\n').filter(Boolean);
+
+    const dirsToIgnore = [...GLOBAL_HARD_IGNORE_DIRS, ...(config.dirsToIgnore || []).map(d => d.replace(/\/$/, ''))];
+    const filesToIgnore = [...GLOBAL_HARD_IGNORE_FILES, ...(config.filesToIgnore || [])];
+    const extensionsToIgnore = config.extensionsToIgnore || [];
+
+    const filteredFiles = gitFiles.filter(file => {
+      if (isHiddenPath(file)) return false;
+      const fileName = file.split('/').pop();
+      const fileExt = path.extname(fileName);
+      const pathParts = file.split('/');
+      for (let i = 0; i < pathParts.length - 1; i++) {
+        if (dirsToIgnore.includes(pathParts[i])) return false;
+      }
+      if (filesToIgnore.includes(fileName)) return false;
+      if (fileExt && extensionsToIgnore.includes(fileExt)) return false;
+      return true;
+    });
+    return filteredFiles;
+  }
+  return scanDirectoryRecursively(projectPath, config);
+}

package/src/utils/gitUtils.js

@@ -25,14 +25,18 @@ export async function getGitAnchor(repoPath) {
   }
 }
 
-export async function getChangedFiles(repoPath, anchorHash) {
-  try {
-    const { stdout } = await execa('git', ['diff', '--name-only', anchorHash, 'HEAD'], { cwd: repoPath });
-    return stdout.split('\n').filter(Boolean);
-  } catch (e) {
-    throw new Error(`Failed to get git diff: ${e.message}`);
-  }
-}
+export async function getChangedFiles(repoPath, anchorHash, includeWorkingTree = false) {
+  try {
+    const args = ['diff', '--name-only', anchorHash];
+    if (!includeWorkingTree) {
+      args.push('HEAD');
+    }
+    const { stdout } = await execa('git', args, { cwd: repoPath });
+    return stdout.split('\n').filter(Boolean);
+  } catch (e) {
+    throw new Error(`Failed to get git diff: ${e.message}`);
+  }
+}
 
 export async function getGitDiffOutput(repoPath, anchorHash, excludeFiles = []) {
   try {

package/src/utils/opencodeAgentsGenerator.js

@@ -1,5 +1,9 @@
 import fs from 'fs/promises';
 import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 
 /**
  * Generates AGENTS.md for OpenCode integration (GLM Z.AI ecosystem only)
@@ -30,11 +34,12 @@ export async function generateOpenCodeAgents(repoPath, mode, tree, confidentialF
       color: '#10a37f'
     };
 
-    const templatePath = path.join(repoPath, '..', '..', 'src', 'templates', 'opencode', 'junior-architect.template.md');
+    const templatePath = path.join(__dirname, '..', 'templates', 'opencode', 'junior-architect.template.md');
     try {
       let templateContent = await fs.readFile(templatePath, 'utf-8');
       body = templateContent.replace('{{tree}}', tree);
     } catch (error) {
+      console.warn(`⚠️ Could not load JAZ template from ${templatePath}: ${error.message}`);
       body = `# 🧠 ROLE: Swarm Orchestrator (GLM-4.7)\n\nDirectory:\n\`\`\`\n${tree}\n\`\`\``;
     }
   } else {
@@ -48,10 +53,11 @@ export async function generateOpenCodeAgents(repoPath, mode, tree, confidentialF
       color: '#44BA81'
     };
 
-    const templatePath = path.join(repoPath, '..', '..', 'src', 'templates', 'opencode', 'coder.template.md');
+    const templatePath = path.join(__dirname, '..', 'templates', 'opencode', 'coder.template.md');
     try {
       body = await fs.readFile(templatePath, 'utf-8');
     } catch (error) {
+      console.warn(`⚠️ Could not load Coder template from ${templatePath}: ${error.message}`);
       body = `# 🛠️ ROLE: Expert Developer`;
     }
   }