@xelth/eck-snapshot 4.1.0 → 4.2.0

package/src/utils/fileUtils.js

@@ -6,6 +6,61 @@ import { detectProjectType, getProjectSpecificFiltering } from './projectDetecto
 import { executePrompt as askClaude } from '../services/claudeCliService.js';
 import { getProfile, loadSetupConfig } from '../config.js';
 import micromatch from 'micromatch';
+import { minimatch } from 'minimatch';
+
+/**
+ * Scanner for detecting and redacting secrets (API keys, tokens)
+ */
+export const SecretScanner = {
+  patterns: [
+    // Service-specific patterns
+    { name: 'GitHub Token', regex: /gh[pous]_[a-zA-Z0-9]{36}/g },
+    { name: 'AWS Access Key', regex: /(?:AKIA|ASIA)[0-9A-Z]{16}/g },
+    { name: 'OpenAI API Key', regex: /sk-[a-zA-Z0-9]{32,}/g },
+    { name: 'Stripe Secret Key', regex: /sk_live_[0-9a-zA-Z]{24}/g },
+    { name: 'Google API Key', regex: /AIza[0-9A-Za-z\-_]{35}/g },
+    { name: 'Slack Token', regex: /xox[baprs]-[0-9a-zA-Z\-]{10,}/g },
+    { name: 'NPM Token', regex: /npm_[a-zA-Z0-9]{36}/g },
+    { name: 'Private Key', regex: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g },
+    // Generic high-entropy patterns near sensitive keywords
+    {
+      name: 'Generic Secret',
+      regex: /(?:api[_-]?key|secret|password|token|auth|pwd|credential)\s*[:=]\s*["']([a-zA-Z0-9\-_.]{16,})["']/gi
+    }
+  ],
+
+  /**
+   * Scans content and replaces detected secrets with a placeholder
+   * @param {string} content - File content to scan
+   * @param {string} filePath - Path for logging context
+   * @returns {{content: string, found: string[]}} Redacted content and list of found secret types
+   */
+  redact(content, filePath) {
+    let redactedContent = content;
+    const foundSecrets = [];
+
+    for (const pattern of this.patterns) {
+      // Reset regex lastIndex for global patterns
+      pattern.regex.lastIndex = 0;
+
+      const matches = [...content.matchAll(pattern.regex)];
+      if (matches.length > 0) {
+        for (const match of matches) {
+          // For generic pattern, use captured group; for specific patterns, use full match
+          const secretValue = match[1] || match[0];
+          const placeholder = `[REDACTED_${pattern.name.replace(/\s+/g, '_').toUpperCase()}]`;
+          redactedContent = redactedContent.replace(secretValue, placeholder);
+          foundSecrets.push(pattern.name);
+        }
+      }
+    }
+
+    return {
+      content: redactedContent,
+      found: [...new Set(foundSecrets)]
+    };
+  }
+};
 
 export function parseSize(sizeStr) {
   const units = { B: 1, KB: 1024, MB: 1024 ** 2, GB: 1024 ** 3 };
@@ -40,40 +95,43 @@ export function matchesPattern(filePath, patterns) {
   });
 }
 
+/**
+ * Checks if a file matches confidential patterns using minimatch
+ * @param {string} fileName - The file name to check
+ * @param {array} patterns - Array of glob patterns to match against
+ * @returns {boolean} True if the file matches any pattern
+ */
+function matchesConfidentialPattern(fileName, patterns) {
+  return patterns.some(pattern => minimatch(fileName, pattern, { nocase: true }));
+}
+
 /**
  * Applies smart filtering for files within the .eck directory.
  * Includes documentation files while excluding confidential files.
  * @param {string} fileName - The file name to check
  * @param {object} eckConfig - The eckDirectoryFiltering config object
- * @returns {boolean} True if the file should be included, false otherwise
+ * @returns {object} { include: boolean, isConfidential: boolean }
  */
 export function applyEckDirectoryFiltering(fileName, eckConfig) {
   if (!eckConfig || !eckConfig.enabled) {
-    return false; // .eck filtering disabled, exclude all
+    return { include: false, isConfidential: false }; // .eck filtering disabled, exclude all
   }
 
   const { confidentialPatterns = [], alwaysIncludePatterns = [] } = eckConfig;
 
-  // First check if file matches confidential patterns (always exclude)
-  if (matchesPattern(fileName, confidentialPatterns)) {
-    return false;
+  // First check if file matches confidential patterns
+  const isConfidential = matchesConfidentialPattern(fileName, confidentialPatterns);
+  if (isConfidential) {
+    return { include: false, isConfidential: true };
   }
 
   // Check if file matches always-include patterns
   if (matchesPattern(fileName, alwaysIncludePatterns)) {
-    return true;
+    return { include: true, isConfidential: false };
   }
 
   // Default: exclude files not in the include list
-  return false;
-}
-
-export async function checkGitAvailability() {
-  try {
-    await execa('git', ['--version']);
-  } catch (error) {
-    throw new Error('Git is not installed or not available in PATH');
-  }
+  return { include: false, isConfidential: false };
 }
 
 export async function checkGitRepository(repoPath) {
@@ -85,17 +143,18 @@ export async function checkGitRepository(repoPath) {
   }
 }
 
-export async function scanDirectoryRecursively(dirPath, config, relativeTo = dirPath, projectType = null) {
+export async function scanDirectoryRecursively(dirPath, config, relativeTo = dirPath, projectType = null, trackConfidential = false) {
   const files = [];
-  
+  const confidentialFiles = [];
+
   // Get project-specific filtering if not provided
   if (!projectType) {
     const detection = await detectProjectType(relativeTo);
     projectType = detection.type;
   }
-  
+
   const projectSpecific = await getProjectSpecificFiltering(projectType);
-  
+
   // Merge project-specific filters with global config
   const effectiveConfig = {
     ...config,
@@ -103,38 +162,47 @@ export async function scanDirectoryRecursively(dirPath, config, relativeTo = dir
     filesToIgnore: [...(config.filesToIgnore || []), ...(projectSpecific.filesToIgnore || [])],
     extensionsToIgnore: [...(config.extensionsToIgnore || []), ...(projectSpecific.extensionsToIgnore || [])]
   };
-  
+
   try {
     const entries = await fs.readdir(dirPath, { withFileTypes: true });
-    
+
     for (const entry of entries) {
       const fullPath = path.join(dirPath, entry.name);
       const relativePath = path.relative(relativeTo, fullPath).replace(/\\/g, '/');
-      
-      if (effectiveConfig.dirsToIgnore.some(dir => 
-        entry.name === dir.replace('/', '') || 
+
+      // Special handling for .eck directory - never ignore it when tracking confidential files
+      const isEckDirectory = entry.name === '.eck' && entry.isDirectory();
+      const isInsideEck = relativePath.startsWith('.eck/');
+
+      if (effectiveConfig.dirsToIgnore.some(dir =>
+        entry.name === dir.replace('/', '') ||
         relativePath.startsWith(dir)
-      )) {
+      ) && !isEckDirectory && !isInsideEck) {
         continue;
       }
-      
-      // Special handling for .eck directory - allow it even when hidden files are excluded
-      const isEckDirectory = entry.name === '.eck' && entry.isDirectory();
-      const isInsideEck = relativePath.startsWith('.eck/');
 
       if (!effectiveConfig.includeHidden && entry.name.startsWith('.') && !isEckDirectory && !isInsideEck) {
         continue;
       }
 
       if (entry.isDirectory()) {
-        const subFiles = await scanDirectoryRecursively(fullPath, effectiveConfig, relativeTo, projectType);
-        files.push(...subFiles);
+        const subResult = await scanDirectoryRecursively(fullPath, effectiveConfig, relativeTo, projectType, trackConfidential);
+        if (trackConfidential) {
+          files.push(...subResult.files);
+          confidentialFiles.push(...subResult.confidentialFiles);
+        } else {
+          files.push(...subResult);
+        }
       } else {
         // Apply smart filtering for files inside .eck directory
         if (isInsideEck) {
           const eckConfig = effectiveConfig.eckDirectoryFiltering;
-          if (!applyEckDirectoryFiltering(entry.name, eckConfig)) {
-            continue; // File doesn't pass .eck smart filtering
+          const filterResult = applyEckDirectoryFiltering(entry.name, eckConfig);
+
+          if (trackConfidential && filterResult.isConfidential) {
+            confidentialFiles.push(relativePath);
+          } else if (filterResult.include) {
+            files.push(relativePath);
           }
         } else {
           // Normal filtering for non-.eck files
@@ -142,16 +210,15 @@ export async function scanDirectoryRecursively(dirPath, config, relativeTo = dir
               matchesPattern(relativePath, effectiveConfig.filesToIgnore)) {
             continue;
           }
+          files.push(relativePath);
         }
-
-        files.push(relativePath);
       }
     }
   } catch (error) {
     console.warn(`⚠️ Warning: Could not read directory: ${dirPath} - ${error.message}`);
   }
-  
-  return files;
+
+  return trackConfidential ? { files, confidentialFiles } : files;
 }
 
 export async function loadGitignore(repoPath) {
@@ -194,6 +261,11 @@ export async function generateDirectoryTree(dir, prefix = '', allFiles, depth =
     const validEntries = [];
     
     for (const entry of sortedEntries) {
+      // Skip hidden directories and files (starting with '.')
+      // EXCEPT: show .eck as a placeholder at the first level
+      if (entry.name.startsWith('.')) {
+        continue;
+      }
       if (config.dirsToIgnore.some(d => entry.name.includes(d.replace('/', '')))) continue;
       const fullPath = path.join(dir, entry.name);
       const relativePath = path.relative(process.cwd(), fullPath).replace(/\\/g, '/');
@@ -205,10 +277,10 @@ export async function generateDirectoryTree(dir, prefix = '', allFiles, depth =
     for (let i = 0; i < validEntries.length; i++) {
       const { entry, fullPath, relativePath } = validEntries[i];
       const isLast = i === validEntries.length - 1;
-      
+
       const connector = isLast ? '└── ' : '├── ';
       const nextPrefix = prefix + (isLast ? '    ' : '│   ');
-      
+
       if (entry.isDirectory()) {
         tree += `${prefix}${connector}${entry.name}/\n`;
         tree += await generateDirectoryTree(fullPath, nextPrefix, allFiles, depth + 1, maxDepth, config);
@@ -216,7 +288,14 @@ export async function generateDirectoryTree(dir, prefix = '', allFiles, depth =
         tree += `${prefix}${connector}${entry.name}\n`;
       }
     }
-    
+
+    // Add .eck placeholder at root level
+    if (depth === 0) {
+      const isLast = validEntries.length === 0;
+      const connector = isLast ? '└── ' : '├── ';
+      tree += `${prefix}${connector}.eck/\n`;
+    }
+
     return tree;
   } catch (error) {
     console.warn(`⚠️ Warning: Could not read directory: ${dir}`);
@@ -336,14 +415,6 @@ export function generateTimestamp() {
   return `${YYYY}-${MM}-${DD}_${hh}-${mm}-${ss}`;
 }
 
-export function sanitizeForFilename(text) {
-  return text
-    .toLowerCase()
-    .replace(/\s+/g, '-') // Replace spaces with hyphens
-    .replace(/[^a-z0-9-]/g, '') // Remove invalid characters
-    .substring(0, 50); // Truncate to a reasonable length
-}
-
 /**
  * Displays project detection information in a user-friendly format
  * @param {object} detection - Project detection result
@@ -775,164 +846,89 @@ export async function initializeEckManifest(projectPath) {
     const staticFactsJson = JSON.stringify(staticFacts, null, 2);
     // --- END NEW LOGIC ---
     
-    // Template files with their content
-    const templateFiles = [
-      {
-        name: 'ENVIRONMENT.md',
-        prompt: `Given these static project analysis facts:\n${staticFactsJson}\n\nGenerate the raw YAML key-value content for an .eck/ENVIRONMENT.md file. Only include detected facts. DO NOT add any keys that are not present in the facts. DO NOT add conversational text or markdown wrappers. Your response MUST start directly with a YAML key (e.g., 'project_type: ...').`,
-        content: `# This file is for environment overrides. Add agent-specific settings here.\nagent_id: local_dev\n` // Simple static fallback
+    // 3. Define smarter templates and prompts with "STUB NOTICES"
+    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
+`
       },
-      {
-        name: 'CONTEXT.md',
-        prompt: `Given these static project analysis facts:\n${staticFactsJson}\n\nGenerate the raw Markdown content ONLY for a .eck/CONTEXT.md file. Use the facts to write ## Description, ## Architecture, and ## Key Technologies. DO NOT add conversational text (like "Here is the file..."). Your response MUST start *directly* with the '# Project Overview' heading.`,
-        content: `# Project Overview
+      '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
-Brief description of what this project does and its main purpose.
+(Placeholder: A ${staticFacts.type || 'project'} project)
 
 ## Architecture
-High-level overview of the system architecture, key components, and how they interact.
-
-## Key Technologies
-- Technology 1
-- Technology 2
-- Technology 3
-
-## Important Notes
-Any crucial information that developers should know when working on this project.
-`
-      },
-      {
-        name: 'OPERATIONS.md',
-        prompt: `Given these static project analysis facts (especially package.json scripts):
-${staticFactsJson}
-
-Generate the raw Markdown content ONLY for a .eck/OPERATIONS.md file. DO NOT add conversational text. Your response MUST start *directly* with the '# Common Operations' heading. List commands for ## Development Setup, ## Running the Project, and ## Testing.`,
-        content: `# Common Operations
-
-## Development Setup
-\`\`\`bash
-# Setup commands
-npm install
-# or yarn install
-\`\`\`
-
-## Running the Project
-\`\`\`bash
-# Development mode
-npm run dev
-
-# Production build
-npm run build
-\`\`\`
-
-## Testing
-\`\`\`bash
-# Run tests
-npm test
-
-# Run tests in watch mode
-npm run test:watch
-\`\`\`
-
-## Deployment
-\`\`\`bash
-# Deployment commands
-npm run deploy
-\`\`\`
-
-## Troubleshooting
-Common issues and their solutions.
-`
+(Placeholder: TBD)`
       },
-      {
-        name: 'JOURNAL.md',
-        content: `# Development Journal
+      '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]
 
-## Recent Changes
-Track significant changes, decisions, and progress here.
+## 🚨 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.
 
----
-
-### YYYY-MM-DD - Project Started
-- Initial project setup
-- Added basic structure
-`
-      },
-      {
-        name: 'ROADMAP.md',
-        prompt: `Given these static project analysis facts:\n${staticFactsJson}\n\nGenerate the raw Markdown content ONLY for a .eck/ROADMAP.md file. DO NOT add conversational text. Start *directly* with '# Project Roadmap'. Propose 1-2 *plausible* placeholder items for ## Current Sprint/Phase and ## Next Phase based on the project type.`,
-        content: `# Project Roadmap
-
-## Current Sprint/Phase
-- [ ] Feature 1
-- [ ] Feature 2
-- [ ] Bug fix 1
-
-## Next Phase
-- [ ] Future feature 1
-- [ ] Future feature 2
-
-## Long-term Goals
-- [ ] Major milestone 1
-- [ ] Major milestone 2
-
-## Completed
-- [x] Project initialization
-`
+## Setup
+${staticFacts.type === 'nodejs' ? 'npm install' : 'TBD'}`
       },
-      {
-        name: 'TECH_DEBT.md',
-        prompt: `Generate the raw Markdown content ONLY for a .eck/TECH_DEBT.md file. DO NOT add conversational text. Start *directly* with '# Technical Debt'. Propose 1-2 *common* placeholder items for ## Code Quality Issues and ## Refactoring Opportunities.`,
-        content: `# Technical Debt
-
-## Current Technical Debt
-Track technical debt, refactoring needs, and code quality issues.
-
-### Code Quality Issues
-- Issue 1: Description and priority
-- Issue 2: Description and priority
+      'ROADMAP.md': {
+        prompt: `Based on the project type (${staticFacts.type}), propose a 3-step roadmap. Start with '# Project Roadmap'.`,
+        fallback: `# [STUB: ROADMAP.MD]
 
-### Refactoring Opportunities
-- Opportunity 1: Description and impact
-- Opportunity 2: Description and impact
-
-### Performance Issues
-- Performance issue 1: Description and impact
-- Performance issue 2: Description and impact
+**ARCHITECT:** Set a real roadmap based on user goals. **CODER:** Remove this stub marker once a real goal is added.`
+      },
+      '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]
 
-### Security Concerns
-- Security concern 1: Description and priority
-- Security concern 2: Description and priority
+**CODER:** Scan for TODOs/FIXMEs or structural issues and list them here. Remove this stub marker.`
+      },
+      'JOURNAL.md': {
+        fallback: `# Development Journal
 
-## Resolved
-- [x] Resolved issue 1
-`
+## 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.`
       }
-    ];
+    };
     
     // Create each template file (only if it doesn't exist)
-    for (const file of templateFiles) {
-      const filePath = path.join(eckDir, file.name);
-      
+    for (const [fileName, config] of Object.entries(templateConfigs)) {
+      const filePath = path.join(eckDir, fileName);
+
       // Skip if file already exists
       try {
         await fs.stat(filePath);
-        console.log(`   ✅ ${file.name} already exists, skipping`);
+        console.log(`   ✅ ${fileName} already exists, skipping`);
         continue;
       } catch (error) {
         // File doesn't exist, create it
       }
-      
-      let fileContent = file.content; // Start with fallback
+
+      let fileContent = config.fallback; // Start with stub fallback
       let generatedByAI = false;
 
       // For files with a prompt, try to dynamically generate (only if enabled)
-      if (file.prompt && aiGenerationEnabled) {
+      if (config.prompt && aiGenerationEnabled) {
         try {
-          console.log(`   🧠 Attempting to auto-generate ${file.name} via Claude...`);
-          const aiResponseObject = await askClaude(file.prompt); // Use the prompt
-          const rawText = aiResponseObject.result; // Handle Claude response
+          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}`);
@@ -944,19 +940,19 @@ Track technical debt, refactoring needs, and code quality issues.
           if (cleanedResponse) {
             fileContent = cleanedResponse;
             generatedByAI = true;
-            console.log(`   ✨ AI successfully generated ${file.name}`);
+            console.log(`   ✨ AI successfully generated ${fileName}`);
           } else {
             throw new Error('AI returned empty content.');
           }
         } catch (error) {
-          console.warn(`   ⚠️ AI generation failed for ${file.name}: ${error.message}. Using static template.`);
-          // fileContent is already set to the fallback
+          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 ${file.name} (static template)`);
+          console.log(`   ✅ Created ${fileName} (stub template)`);
       }
     }
     

package/src/utils/tokenEstimator.js

@@ -8,7 +8,8 @@ import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const ESTIMATION_DATA_FILE = path.join(__dirname, '..', '..', '.eck-token-training.json');
+const ECK_DIR = path.join(__dirname, '..', '..', '.eck');
+const ESTIMATION_DATA_FILE = path.join(ECK_DIR, 'token-training.json');
 
 /**
  * Default coefficients for different project types (bytes to tokens ratio)
@@ -49,6 +50,8 @@ async function loadTrainingData() {
  * Save training data to file
  */
 async function saveTrainingData(data) {
+  // Ensure .eck directory exists
+  await fs.mkdir(ECK_DIR, { recursive: true });
   await fs.writeFile(ESTIMATION_DATA_FILE, JSON.stringify(data, null, 2));
 }
 

package/src/cli/commands/askGpt.js

@@ -1,29 +0,0 @@
-import { ask } from '../../services/gptService.js';
-
-/**
- * CLI entry point for ask-gpt command.
- * @param {string} payload - JSON payload string.
- * @param {{ verbose?: boolean, model?: string, reasoning?: string }} options - CLI options.
- */
-export async function askGpt(payload, options = {}) {
-  const verbose = Boolean(options.verbose);
-  const model = options.model || 'gpt-5-codex';
-  const reasoning = options.reasoning || 'high';
-
-  if (!payload) {
-    console.error('ask-gpt requires a JSON payload argument.');
-    process.exitCode = 1;
-    return;
-  }
-
-  try {
-    const result = await ask(payload, { verbose, model, reasoning });
-    console.log(JSON.stringify(result, null, 2));
-  } catch (error) {
-    console.error(error.message);
-    if (verbose && error?.stack) {
-      console.error(error.stack);
-    }
-    process.exitCode = 1;
-  }
-}

package/src/services/authService.js

@@ -1,20 +0,0 @@
-import ora from 'ora';
-import { execa } from 'execa';
-
-/**
- * Initiates the interactive login flow by spawning 'codex login'.
- * This will open a browser and wait for the user to complete authentication.
- * @returns {Promise<void>}
- */
-export async function initiateLogin() {
-  const spinner = ora('Authentication required. Please follow the browser instructions.').start();
-  try {
-    // Run `codex login` interactively, inheriting stdio to show user instructions.
-    await execa('codex', ['login'], { stdio: 'inherit' });
-    spinner.succeed('Login successful. Retrying original command...');
-  } catch (e) {
-    spinner.fail('Login process failed or was cancelled.');
-    // Re-throw to notify p-retry that the attempt failed.
-    throw new Error(`Login failed: ${e.message}`);
-  }
-}

package/src/services/dispatcherService.js

@@ -1,33 +0,0 @@
-import { ask as askGpt } from './gptService.js';
-import { executePrompt as askClaude } from './claudeCliService.js';
-
-/**
- * Dispatches an analytical task to the most efficient AI model with a fallback.
- * Priority 1: Codex (GPT) with low reasoning for speed and cost.
- * Priority 2: Claude as a reliable fallback.
- * @param {string} prompt The JSON payload or prompt string for the task.
- * @returns {Promise<object>} The result from the successful AI agent.
- */
-export async function dispatchAnalysisTask(prompt) {
-  try {
-    console.log('🧠 Dispatcher: Attempting analysis with Codex (low reasoning)...');
-    const gptOptions = {
-      model: 'gpt-5-codex',
-      reasoning: 'low'
-    };
-    // The 'ask' function expects payload as first arg, and options as second.
-    // Since prompt is a string here, we wrap it in an object for consistency if needed,
-    // but for simple prompts it can often be passed directly.
-    const payload = (typeof prompt === 'string' && prompt.startsWith('{')) ? prompt : JSON.stringify({ objective: prompt });
-    return await askGpt(payload, { verbose: false, ...gptOptions });
-  } catch (gptError) {
-    console.warn(`⚠️ Codex (low reasoning) failed: ${gptError.message}`);
-    console.log('🔄 Failing over to Claude for analysis...');
-    try {
-      return await askClaude(prompt);
-    } catch (claudeError) {
-      console.error(`❌ Critical Failure: Both Codex and Claude failed for analysis task.`);
-      throw new Error(`Primary (Codex) Error: ${gptError.message}\nFallback (Claude) Error: ${claudeError.message}`);
-    }
-  }
-}