@xelth/eck-snapshot 5.0.2 → 5.0.3

package/README.md

@@ -1,8 +1,20 @@
 
-# eckSnapshot (v5.0.2)
+# eckSnapshot (v5.0.3)
 
 A lightweight, platform-independent CLI for creating focused, AI-ready project snapshots.
 
+---
+
+## ⚠️ NPM Publishing Discontinued | Публикация в NPM прекращена
+
+**EN:** We've stopped publishing to npm due to their excessive security requirements (10-second tokens, 10-factor authentication, and constant token revocations). If you're interested in this project, **all updates will be released exclusively on GitHub**. Install directly from the repository.
+
+**RU:** npm может идти лесом. Кому интересно - смотрите на гите.
+
+**GitHub Repository:** https://github.com/xelth-com/eckSnapshot
+
+---
+
 `eckSnapshot` is a powerful command-line tool designed to solve a critical problem in AI-assisted development: providing clear, complete, and focused context to Large Language Models (LLMs). It allows you to package an entire project codebase—or just specific parts of it—into a single, clean text file.
 
 This tool is built for a modern workflow where you act as the architect, guiding the overall strategy, while AI agents handle the detailed implementation.
@@ -24,10 +36,19 @@ This tool is built for a modern workflow where you act as the architect, guiding
 
 ## Installation
 
-Install `eckSnapshot` globally on your system using npm:
+Install `eckSnapshot` globally directly from GitHub:
+
+```bash
+npm install -g github:xelth-com/eckSnapshot
+```
+
+Or clone and link locally:
 
 ```bash
-npm install -g @xelth/eck-snapshot
+git clone https://github.com/xelth-com/eckSnapshot.git
+cd eckSnapshot
+npm install
+npm link
 ```
 
 Once installed, you can run the tool using the `eck-snapshot` command from any directory.

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@xelth/eck-snapshot",
-  "version": "5.0.2",
+  "version": "5.0.3",
   "description": "A powerful CLI tool to create and restore single-file text snapshots of Git repositories and directories. Optimized for AI context and LLM workflows.",
   "main": "index.js",
   "type": "module",
   "bin": {
-    "eck-snapshot": "./index.js"
+    "eck-snapshot": "index.js"
   },
   "files": [
     "index.js",
@@ -25,7 +25,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/xelth-com/eckSnapshot.git"
+    "url": "git+https://github.com/xelth-com/eckSnapshot.git"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.33.1",

package/setup.json

@@ -552,53 +552,85 @@
   },
   "aiInstructions": {
     "architectPersona": {
-      "role": "Project Manager and Solution Architect AI",
-      "goal": "Translate user requests into technical plans and generate precise commands for execution agents",
+      "role": "Senior Architect (Gemini 3 Pro) & Orchestrator",
+      "goal": "Lead the project globally. You see the WHOLE project. Delegate implementation management to Junior Architects (Sonnet 4.5 / Opus 4.5).",
       "contextRequirement": "ALWAYS check environment context before generating commands",
       "workflow": [
-        "Request ENV scan from agent",
-        "Analyze User Request in their native language",
-        "Formulate environment-appropriate technical plan",
-        "Propose the high-level plan in the user's language",
-        "STOP and WAIT for explicit user confirmation",
-        "ONLY after approval: Generate environment-specific JSON command block in a SEPARATE message",
-        "Communicate with user in their language, commands in ENGLISH",
-        "CRITICAL: Never output JSON commands until the user agrees to the plan"
+        "Request ENV scan",
+        "Analyze Request using Global Context (Gemini 3 Pro)",
+        "Select the best Junior Architect (JAS for speed, JAO for complexity)",
+        "Delegate the task using 'execute_strategic_task'",
+        "Review the result"
       ]
     },
     "executionAgents": {
       "local_dev": {
         "active": true,
-        "name": "Local Development Agent (Sonnet 4.5)",
-        "description": "Primary interactive agent running on Claude Sonnet 4.5. Acts as the Team Lead.",
+        "name": "Local Terminal (Sonnet 4.5)",
+        "description": "Direct execution interface. Use for quick commands.",
         "guiSupport": true,
         "identification": {
-          "markers": [
-            "WSL",
-            "/home/",
-            "/Users/",
-            "\\Users\\",
-            "SQLite"
-          ]
+          "markers": ["local_dev"]
+        },
+        "capabilities": ["npm", "git", "basic editing"],
+        "restrictions": ["Do not use for complex architectural tasks"]
+      },
+      "jas": {
+        "active": true,
+        "name": "Junior Architect (Sonnet 4.5)",
+        "description": "Smart & Fast Manager. Best for standard features and refactoring. Manages MiniMax workers.",
+        "guiSupport": true,
+        "identification": {
+          "markers": ["sonnet", "fast_architect"]
         },
         "capabilities": [
-          "npm install",
-          "npm run dev",
-          "npm run dev:backend",
+          "minimax_frontend",
+          "minimax_backend",
+          "minimax_qa",
+          "minimax_refactor",
           "git operations",
-          "sqlite3 commands",
-          "electron debug",
-          "file editing",
-          "testing commands",
-          "browser automation (chrome_mcp)",
-          "visual regression testing",
-          "network logging"
+          "npm run dev"
         ],
         "restrictions": [
-          "no PM2 commands",
-          "no PostgreSQL production operations",
-          "no systemctl",
-          "no production deployments"
+          "Prefer delegating heavy coding to MiniMax workers",
+          "Focus on glue code and logic verification"
+        ]
+      },
+      "jao": {
+        "active": true,
+        "name": "Junior Architect (Opus 4.5)",
+        "description": "Deep Thinker & Planner. Expensive. Use for critical architecture, security, and complex logic.",
+        "guiSupport": true,
+        "identification": {
+          "markers": ["opus", "deep_architect"]
+        },
+        "capabilities": [
+          "minimax_frontend",
+          "minimax_backend",
+          "minimax_qa",
+          "minimax_refactor",
+          "analysis"
+        ],
+        "restrictions": [
+          "STRICTLY DELEGATE boilerplate to MiniMax",
+          "Verify every line of code generated by workers",
+          "Plan before execution"
+        ]
+      },
+      "jag": {
+        "active": true,
+        "name": "Junior Architect (Gemini 3 Pro)",
+        "description": "Massive Context Handler. Use when changes span >50 files or require full repo understanding.",
+        "guiSupport": false,
+        "identification": {
+          "markers": ["gemini_wsl"]
+        },
+        "capabilities": [
+          "read entire repo",
+          "delegate to claude"
+        ],
+        "restrictions": [
+          "Experimental environment"
         ]
       },
       "production_server": {
@@ -671,69 +703,23 @@
           "no hardware debugging interfaces"
         ]
       },
-      "gemini_wsl": {
-        "active": true,
-        "name": "Gemini WSL Agent (Junior Architect)",
-        "description": "Gemini, running in WSL. Can access all WSL tools and delegate to other agents like claude.",
-        "guiSupport": false,
-        "identification": {
-          "markers": [
-            "WSL",
-            "gemini",
-            "claude"
-          ]
-        },
-        "capabilities": [
-          "git operations",
-          "npm install",
-          "file editing",
-          "gemini (self)",
-          "claude (delegate)"
-        ],
-        "restrictions": [
-          "Runs only inside the WSL environment"
-        ]
-      },
-      "gemini_windows": {
-        "active": true,
-        "name": "Gemini Windows Agent (Standalone)",
-        "description": "Gemini, running in native Windows (PowerShell). Can only access Windows tools.",
-        "guiSupport": true,
-        "identification": {
-          "markers": [
-            "Windows",
-            "gemini",
-            "!WSL"
-          ]
-        },
-        "capabilities": [
-          "git operations",
-          "npm install",
-          "file editing",
-          "gemini (self)"
-        ],
-        "restrictions": [
-          "Runs only in native Windows",
-          "Cannot access WSL-only tools like claude"
-        ]
-      },
       "minimax_worker": {
         "active": true,
-        "name": "MiniMax M2.1 Worker (MCP)",
-        "description": "Heavy lifter for bulk coding. Behavior controlled by delegationStrategy.",
+        "name": "MiniMax Swarm (MCP)",
+        "description": "The worker fleet. Accessed via MCP tools (minimax_backend, etc).",
         "guiSupport": false,
         "identification": {
-          "markers": ["minimax", "delegate_coding_task"]
+          "markers": ["minimax"]
         },
         "capabilities": [
-          "read large files internally",
-          "generate massive code blocks",
-          "refactor huge modules",
-          "analyze project structure"
+          "backend engineering",
+          "frontend engineering",
+          "qa testing",
+          "refactoring"
         ],
         "restrictions": [
-          "Cannot execute system commands directly (delegates back to Sonnet)",
-          "Requires MINIMAX_API_KEY"
+          "Requires MINIMAX_API_KEY",
+          "No direct executive power"
         ]
       }
     },

package/src/cli/cli.js

@@ -7,7 +7,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 import { createRepoSnapshot } from './commands/createSnapshot.js';
-import { updateSnapshot } from './commands/updateSnapshot.js';
+import { updateSnapshot, updateSnapshotJson } from './commands/updateSnapshot.js';
 import { restoreSnapshot } from './commands/restoreSnapshot.js';
 import { pruneSnapshot } from './commands/pruneSnapshot.js';
 import { generateConsilium } from './commands/consilium.js';
@@ -140,7 +140,9 @@ Option C: Using Profiles
     .option('--enhanced', 'Use enhanced multi-agent headers (default: true)', true)
     .option('--profile <name>', 'Filter files using profiles and/or ad-hoc glob patterns.')
     .option('--agent', 'Generate a snapshot optimized for a command-line agent')
-    .option('--with-ja', 'Generate a detailed snapshot for the Junior Architect agent')
+    .option('--jag', 'Generate snapshot for Junior Architect Gemini (Gemini 3 Pro)')
+    .option('--jas', 'Configure project for Junior Architect Sonnet (Sonnet 4.5)')
+    .option('--jao', 'Configure project for Junior Architect Opus (Opus 4.5)')
     .option('--skeleton', 'Enable skeleton mode: strip function bodies to save context window tokens')
     .option('--max-lines-per-file <number>', 'Truncate files to max N lines (e.g., 200 for compact snapshots)', (val) => parseInt(val))
     .action(createRepoSnapshot)
@@ -198,6 +200,13 @@ Creating Custom Profiles:
     .option('--config <path>', 'Configuration file path')
     .action(updateSnapshot);
 
+  // Auto/Silent Update command for Agents
+  program
+    .command('update-auto')
+    .description('Silent update for AI agents (JSON output)')
+    .argument('[repoPath]', 'Path to the repository', process.cwd())
+    .action(updateSnapshotJson);
+
   // Restore command
   program
     .command('restore')

package/src/cli/commands/createSnapshot.js

@@ -23,6 +23,7 @@ import { loadSetupConfig, getProfile } from '../../config.js';
 import { applyProfileFilter } from '../../utils/fileUtils.js';
 import { saveGitAnchor } from '../../utils/gitUtils.js';
 import { skeletonize } from '../../core/skeletonizer.js';
+import { updateClaudeMd } from '../../utils/claudeMdGenerator.js';
 
 /**
  * Creates dynamic project context based on detection results
@@ -141,8 +142,9 @@ const gzip = promisify(zlib.gzip);
  */
 function isHiddenPath(filePath) {
   // Check if path or any parent directory starts with '.'
+  // Allow .eck directory to be visible, hide others (like .git, .vscode)
   const parts = filePath.split('/');
-  return parts.some(part => part.startsWith('.'));
+  return parts.some(part => part.startsWith('.') && part !== '.eck');
 }
 
 /**
@@ -526,8 +528,13 @@ export async function createRepoSnapshot(repoPath, options) {
       ...options // Command-line options have the final say
     };
 
+    // Detect architect modes
+    const isJag = options.jag;
+    const isJas = options.jas;
+    const isJao = options.jao;
+
     // If NOT in Junior Architect mode, hide JA-specific documentation to prevent context pollution
-    if (!options.withJa) {
+    if (!options.withJa && !isJag && !isJas && !isJao) {
       if (!config.filesToIgnore) config.filesToIgnore = [];
       config.filesToIgnore.push(
         'COMMANDS_REFERENCE.md',
@@ -555,15 +562,18 @@ export async function createRepoSnapshot(repoPath, options) {
 
     spinner.succeed('Creating snapshots...');
 
-    // Step 1: Process all files ONCE
-    const {
-      stats,
-      contentArray,
-      successfulFileObjects,
-      allFiles,
-      originalCwd: processingOriginalCwd, // We get originalCwd from the processing function
-      repoPath: processedRepoPath
-    } = await processProjectFiles(repoPath, options, config, projectDetection.type);
+    // --- LOGIC UPDATE: Always include content ---
+    // The Architect needs full visibility of the code to make decisions.
+    // We strictly use processProjectFiles for all modes.
+
+    let stats, contentArray, successfulFileObjects, allFiles, processedRepoPath;
+
+    const result = await processProjectFiles(repoPath, options, config, projectDetection.type);
+    stats = result.stats;
+    contentArray = result.contentArray;
+    successfulFileObjects = result.successfulFileObjects;
+    allFiles = result.allFiles;
+    processedRepoPath = result.repoPath;
 
     const originalCwd = process.cwd(); // Get CWD *before* chdir
     process.chdir(processedRepoPath); // Go back to repo path for git hash and tree
@@ -598,58 +608,99 @@ export async function createRepoSnapshot(repoPath, options) {
       // Calculate Top 10 Largest Files
       const largestFiles = [...successfulFileObjects].sort((a, b) => b.size - a.size).slice(0, 10);
 
-      const fileBody = (directoryTree ? `\n## Directory Structure\n\n\`\`\`\n${directoryTree}\`\`\`\n\n` : '') + contentArray.join('');
-
-      // --- File 1: Architect Snapshot --- 
-      const architectOptions = { ...options, agent: false };
       // Load manifest for headers
       const eckManifest = await loadProjectEckManifest(processedRepoPath);
       const isGitRepo = await checkGitRepository(processedRepoPath);
 
-      const architectHeader = await generateEnhancedAIHeader({ stats, repoName, mode: 'file', eckManifest, options: architectOptions, repoPath: processedRepoPath }, isGitRepo);
-      let architectBaseFilename = `${repoName}_snapshot_${timestamp}${gitHash ? `_${gitHash}` : ''}`;
+      // --- BRANCH 1: Generate Snapshot File (ALWAYS) ---
+      let architectFilePath = null;
+      let jaFilePath = null;
 
-      // Add '_sk' suffix for skeleton mode snapshots
-      if (options.skeleton) {
-        architectBaseFilename += '_sk';
-      }
+      // File body always includes full content
+      let fileBody = (directoryTree ? `\n## Directory Structure\n\n\`\`\`\n${directoryTree}\`\`\`\n\n` : '') + contentArray.join('');
 
-      const architectFilename = `${architectBaseFilename}.${fileExtension}`;
-      const architectFilePath = path.join(outputPath, architectFilename);
-      await fs.writeFile(architectFilePath, architectHeader + fileBody);
+      // Helper to write snapshot file
+      const writeSnapshot = async (suffix, isAgentMode) => {
+        // CHANGE: Force agent to FALSE for the main snapshot header.
+        // The snapshot is read by the Human/Senior Arch, not the Agent itself.
+        // The Agent reads CLAUDE.md.
+        const opts = { ...options, agent: false, jag: isJag, jas: isJas, jao: isJao };
+        const header = await generateEnhancedAIHeader({ stats, repoName, mode: 'file', eckManifest, options: opts, repoPath: processedRepoPath }, isGitRepo);
 
-      // --- File 2: Junior Architect Snapshot ---
-      let jaFilePath = null;
-      if (options.withJa && fileExtension === 'md') { // Only create JA snapshot if requested and main is MD
-        console.log('🖋️ Generating Junior Architect (_ja) snapshot...');
-        const jaOptions = { ...options, agent: true, noTree: false, noAiHeader: false };
-        const jaHeader = await generateEnhancedAIHeader({ stats, repoName, mode: 'file', eckManifest, options: jaOptions, repoPath: processedRepoPath }, isGitRepo);
-        const jaFilename = `${architectBaseFilename}_ja.${fileExtension}`;
-        jaFilePath = path.join(outputPath, jaFilename);
-        await fs.writeFile(jaFilePath, jaHeader + fileBody);
+        // Compact filename format: eck{timestamp}_{hash}_{suffix}.md
+        const shortHash = gitHash ? gitHash.substring(0, 7) : '';
+        let fname = `eck${timestamp}`;
+        if (shortHash) fname += `_${shortHash}`;
+
+        // Add mode suffix
+        if (options.skeleton) {
+          fname += '_sk';
+        } else if (suffix) {
+          fname += suffix;
+        }
+
+        fname += `.${fileExtension}`;
+        const fpath = path.join(outputPath, fname);
+        await fs.writeFile(fpath, header + fileBody);
+        console.log(`📄 Generated Snapshot: ${fname}`);
+        return fpath;
+      };
+
+      // Generate snapshot file for ALL modes
+      if (isJag) {
+        architectFilePath = await writeSnapshot('_jag', true);
+      } else if (isJas) {
+        architectFilePath = await writeSnapshot('_jas', true);
+      } else if (isJao) {
+        architectFilePath = await writeSnapshot('_jao', true);
+      } else {
+        // Standard snapshot behavior
+        architectFilePath = await writeSnapshot('', false);
+
+        // --- File 2: Junior Architect Snapshot (legacy --with-ja support) ---
+        if (options.withJa && fileExtension === 'md') {
+          console.log('🖋️ Generating Junior Architect (_ja) snapshot...');
+          jaFilePath = await writeSnapshot('_ja', true);
+        }
       }
 
       // Save git anchor for future delta updates
       await saveGitAnchor(processedRepoPath);
 
-      // --- Generate CLAUDE.md with confidential file references ---
-      console.log('🔐 Scanning for confidential files in .eck directory...');
+      // Reset update counter for sequential tracking
+      try {
+        const counterPath = path.join(processedRepoPath, '.eck', 'update_seq');
+        await fs.mkdir(path.dirname(counterPath), { recursive: true });
+        // Format: HASH:COUNT
+        const shortHash = gitHash ? gitHash.substring(0, 7) : 'nohash';
+        await fs.writeFile(counterPath, `${shortHash}:0`);
+      } catch (e) {
+        // Non-critical, continue
+      }
+
+      // --- BRANCH 2: Update CLAUDE.md (JAS / JAO / Default) ---
+      console.log('🔐 Scanning for confidential files...');
       const confidentialFiles = await scanEckForConfidentialFiles(processedRepoPath, config);
 
-      if (confidentialFiles.length > 0) {
-        const claudeMdContent = generateClaudeMdContent(confidentialFiles, processedRepoPath);
-        const claudeMdPath = path.join(processedRepoPath, 'CLAUDE.md');
-        await fs.writeFile(claudeMdPath, claudeMdContent);
-        console.log(`📝 Generated CLAUDE.md with ${confidentialFiles.length} confidential file reference(s)`);
-      }
+      let claudeMode = 'coder';
+      if (isJas) claudeMode = 'jas';
+      if (isJao) claudeMode = 'jao';
+      if (isJag) claudeMode = 'jag';
+
+      await updateClaudeMd(processedRepoPath, claudeMode, directoryTree, confidentialFiles);
 
-      // --- Combined Report --- 
+      // --- Combined Report ---
       console.log('\n✅ Snapshot generation complete!');
       console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-      console.log(`📄 Architect File: ${architectFilePath}`);
+
+      if (architectFilePath) {
+        console.log(`📄 Snapshot File: ${architectFilePath}`);
+      }
       if (jaFilePath) {
         console.log(`📄 Junior Arch File: ${jaFilePath}`);
       }
+
+      console.log(`📊 Files scanned: ${stats.totalFiles}`);
       console.log(`📊 Files processed: ${stats.includedFiles}/${stats.totalFiles}`);
       console.log(`📏 Total size: ${formatSize(stats.totalSize)}`);
       console.log(`📦 Processed size: ${formatSize(stats.processedSize)}`);

package/src/cli/commands/updateSnapshot.js

@@ -1,6 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import ora from 'ora';
+import chalk from 'chalk';
 import { getGitAnchor, getChangedFiles, getGitDiffOutput } from '../../utils/gitUtils.js';
 import { loadSetupConfig } from '../../config.js';
 import { readFileWithSizeCheck, parseSize, formatSize, matchesPattern, loadGitignore, generateTimestamp } from '../../utils/fileUtils.js';
@@ -9,6 +10,61 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+// Shared logic to generate the snapshot content string
+async function generateSnapshotContent(repoPath, changedFiles, anchor, config, gitignore) {
+  let contentOutput = '';
+  let includedCount = 0;
+  const fileList = [];
+
+  // Check for Agent Report
+  const reportPath = path.join(repoPath, '.eck', 'AnswerToSA.md');
+  let agentReport = null;
+  try {
+    agentReport = await fs.readFile(reportPath, 'utf-8');
+    if (!changedFiles.includes('.eck/AnswerToSA.md')) {
+      changedFiles.push('.eck/AnswerToSA.md');
+    }
+  } catch (e) { /* No report */ }
+
+  for (const filePath of changedFiles) {
+    if (config.dirsToIgnore.some(d => filePath.startsWith(d))) continue;
+    if (gitignore.ignores(filePath) && filePath !== '.eck/AnswerToSA.md') continue;
+
+    try {
+      const fullPath = path.join(repoPath, filePath);
+      const content = await readFileWithSizeCheck(fullPath, parseSize(config.maxFileSize));
+      contentOutput += `--- File: /${filePath} ---\n\n${content}\n\n`;
+      fileList.push(`- ${filePath}`);
+      includedCount++;
+    } catch (e) { /* Skip */ }
+  }
+
+  // Load Template
+  const templatePath = path.join(__dirname, '../../templates/update-prompt.template.md');
+  let header = await fs.readFile(templatePath, 'utf-8');
+
+  // Inject Agent Report
+  let reportSection = '';
+  if (agentReport) {
+    reportSection = `\n#######################################################\n# 📨 MESSAGE FROM EXECUTION AGENT (Claude)\n#######################################################\n${agentReport}\n#######################################################\n\n`;
+  }
+
+  header = header.replace('{{anchor}}', anchor.substring(0, 7))
+    .replace('{{timestamp}}', new Date().toLocaleString())
+    .replace('{{fileList}}', fileList.join('\n'));
+
+  header = reportSection + header;
+
+  const diffOutput = await getGitDiffOutput(repoPath, anchor);
+  const diffSection = `\n--- GIT DIFF (For Context) ---\n\n\`\`\`diff\n${diffOutput}\n\`\`\``;
+
+  return {
+    fullContent: header + contentOutput + diffSection,
+    includedCount,
+    anchor
+  };
+}
+
 export async function updateSnapshot(repoPath, options) {
   const spinner = ora('Generating update snapshot...').start();
   try {
@@ -23,53 +79,99 @@ export async function updateSnapshot(repoPath, options) {
       return;
     }
 
-    // Load configs for filtering logic
     const setupConfig = await loadSetupConfig();
     const config = { ...setupConfig.fileFiltering, ...setupConfig.performance, ...options };
     const gitignore = await loadGitignore(repoPath);
 
-    let contentOutput = '';
-    let includedCount = 0;
-    const fileList = [];
+    const { fullContent, includedCount } = await generateSnapshotContent(repoPath, changedFiles, anchor, config, gitignore);
 
-    for (const filePath of changedFiles) {
-      // Basic filtering (reuse logic roughly)
-      if (config.dirsToIgnore.some(d => filePath.startsWith(d))) continue;
-      if (gitignore.ignores(filePath)) continue;
-
-      try {
-        const fullPath = path.join(repoPath, filePath);
-        const content = await readFileWithSizeCheck(fullPath, parseSize(config.maxFileSize));
-
-        contentOutput += `--- File: /${filePath} ---\n\n${content}\n\n`;
-        fileList.push(`- ${filePath}`);
-        includedCount++;
-      } catch (e) {
-        // Skip deleted files or read errors
+    // Determine sequence number
+    let seqNum = 1;
+    const counterPath = path.join(repoPath, '.eck', 'update_seq');
+    try {
+      const seqData = await fs.readFile(counterPath, 'utf-8');
+      const [savedHash, savedCount] = seqData.split(':');
+      if (savedHash && savedHash.trim() === anchor.substring(0, 7).trim()) {
+        seqNum = parseInt(savedCount || '0') + 1;
       }
-    }
+    } catch (e) {}
 
-    // Load Template
-    const templatePath = path.join(__dirname, '../../templates/update-prompt.template.md');
-    let header = await fs.readFile(templatePath, 'utf-8');
-    header = header.replace('{{anchor}}', anchor.substring(0, 7))
-      .replace('{{timestamp}}', new Date().toLocaleString())
-      .replace('{{fileList}}', fileList.join('\n'));
+    try {
+      await fs.writeFile(counterPath, `${anchor.substring(0, 7)}:${seqNum}`);
+    } catch (e) {}
 
-    // Add Git Diff at the end for context
-    const diffOutput = await getGitDiffOutput(repoPath, anchor);
-    const diffSection = `\n--- GIT DIFF (For Context) ---\n\n\`\`\`diff\n${diffOutput}\n\`\`\``;
-
-    const outputFilename = `update_${generateTimestamp()}.md`;
+    const timestamp = generateTimestamp();
+    const outputFilename = `eck${timestamp}_${anchor.substring(0, 7)}_up${seqNum}.md`;
     const outputPath = path.join(repoPath, '.eck', 'snapshots', outputFilename);
 
     await fs.mkdir(path.dirname(outputPath), { recursive: true });
-    await fs.writeFile(outputPath, header + contentOutput + diffSection);
+    await fs.writeFile(outputPath, fullContent);
 
     spinner.succeed(`Update snapshot created: .eck/snapshots/${outputFilename}`);
+
+    // Check if agent report was included
+    const reportPath = path.join(repoPath, '.eck', 'AnswerToSA.md');
+    try {
+      await fs.access(reportPath);
+      console.log(chalk.green('📨 Included Agent Report (.eck/AnswerToSA.md)'));
+    } catch (e) {}
+
     console.log(`📦 Included ${includedCount} changed files.`);
 
   } catch (error) {
     spinner.fail(`Update failed: ${error.message}`);
   }
 }
+
+// New Silent/JSON command for Agents
+export async function updateSnapshotJson(repoPath) {
+  try {
+    const anchor = await getGitAnchor(repoPath);
+    if (!anchor) {
+      console.log(JSON.stringify({ status: "error", message: "No snapshot anchor found" }));
+      return;
+    }
+
+    const changedFiles = await getChangedFiles(repoPath, anchor);
+    if (changedFiles.length === 0) {
+      console.log(JSON.stringify({ status: "no_changes", message: "No changes detected" }));
+      return;
+    }
+
+    const setupConfig = await loadSetupConfig();
+    const config = { ...setupConfig.fileFiltering, ...setupConfig.performance };
+    const gitignore = await loadGitignore(repoPath);
+
+    const { fullContent, includedCount } = await generateSnapshotContent(repoPath, changedFiles, anchor, config, gitignore);
+
+    let seqNum = 1;
+    const counterPath = path.join(repoPath, '.eck', 'update_seq');
+    try {
+      const seqData = await fs.readFile(counterPath, 'utf-8');
+      const [savedHash, savedCount] = seqData.split(':');
+      if (savedHash && savedHash.trim() === anchor.substring(0, 7).trim()) {
+        seqNum = parseInt(savedCount || '0') + 1;
+      }
+    } catch (e) {}
+
+    try {
+      await fs.writeFile(counterPath, `${anchor.substring(0, 7)}:${seqNum}`);
+    } catch (e) {}
+
+    const timestamp = generateTimestamp();
+    const outputFilename = `eck${timestamp}_${anchor.substring(0, 7)}_up${seqNum}.md`;
+    const outputPath = path.join(repoPath, '.eck', 'snapshots', outputFilename);
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+    await fs.writeFile(outputPath, fullContent);
+
+    console.log(JSON.stringify({
+      status: "success",
+      snapshot_file: `.eck/snapshots/${outputFilename}`,
+      files_count: includedCount,
+      timestamp: timestamp
+    }));
+
+  } catch (error) {
+    console.log(JSON.stringify({ status: "error", message: error.message }));
+  }
+}

package/src/templates/agent-prompt.template.md

@@ -1,126 +1,42 @@
 # AI Junior Architect Instructions
 
-You are the **Junior Architect** agent (`gemini_wsl`). Your primary goal is to execute high-level strategic tasks delegated to you by the Senior Architect.
+You are a **Junior Architect** ({{agentName}}). Your primary goal is to execute strategic tasks delegated to you by the Senior Architect (Gemini 3 Pro).
 
 ## Your Context
-- You are running in **WSL**.
-- You have access to a detailed `_ja.md` snapshot (which is *this* file).
-- You have a special capability: the `/claude` command, which delegates to a Coder agent.
-
-## Hierarchical Role
-- The **Senior Architect (Gemini)** gives you high-level `execute_strategic_task` commands.
-- **You (Junior Architect / `gemini_wsl`)** analyze the task, break it down, and use your tools.
-- The **Coder (`claude`)** is your primary tool for *writing code*.
-
-## CRITICAL WORKFLOW: Eck-Protocol v2 (Hybrid Format)
-
-When you need to write or modify code, you **MUST** use the `/claude` command with the **Eck-Protocol v2** format. This format uses Markdown for readability, XML tags for file boundaries, and JSON for metadata.
-
-### Response Format
-
-**CRITICAL DISPLAY RULE:**
-You MUST wrap your ENTIRE response in a `text` block using **QUADRUPLE BACKTICKS** (` ```` `). This prevents internal code blocks from breaking the container.
+- **Role:** {{agentDescription}}
+- **Model:** {{modelName}}
+- **Snapshot:** You have access to a specific task snapshot.
+
+## Your Workflow: The Manager
+You are NOT a solitary coder. You are a **Manager**.
+1. **Analyze** the task from the Senior Architect.
+2. **Plan** the changes.
+3. **Delegate** implementation details to your **MiniMax Worker Swarm** using tools like:
+   - `minimax_backend` (for logic/db)
+   - `minimax_frontend` (for UI)
+   - `minimax_qa` (for tests)
+   - `minimax_refactor` (for cleanup)
+4. **Review** their work.
+5. **Assemble** the final result using `apply_code_changes` or file editing tools.
+
+## CRITICAL: Use the Swarm
+Do not waste your expensive context window on reading massive files or writing boilerplate.
+- **BAD:** Reading a 2000-line file to change one function.
+- **GOOD:** Calling `minimax_refactor` with the file path and instruction: "Change function X to do Y".
+
+## Response Format (Eck-Protocol v2)
+
+Use the standard Eck-Protocol v2 for your outputs:
 
 ````text
 # Analysis
-
-[Your thinking and analysis of the task goes here.
-Explain what you're going to do and why.]
+[Your managerial plan]
 
 ## Changes
-
-<file path="src/path/to/file.js" action="replace">
-```javascript
-// Your code here - no escaping needed!
-async function example() {
-    console.log("Clean code with quotes!");
-    return { success: true };
-}
-```
-</file>
-
-<file path="src/another/file.js" action="create">
-```javascript
-export const helper = () => true;
-```
-</file>
+[Your direct changes or delegation results]
 
 ## Metadata
-
 ```json
-{
-  "journal": {
-    "type": "feat",
-    "scope": "api",
-    "summary": "Add example function"
-  }
-}
+{ "journal": { ... } }
 ```
 ````
-
-### File Actions
-
-| Action | Description |
-|--------|-------------|
-| `create` | Create a new file |
-| `replace` | Replace entire file content |
-| `modify` | Partial modification (include context) |
-| `delete` | Delete the file (no content needed) |
-
-### Example Command
-
-```
-/claude
-````text
-# Analysis
-
-I need to fix the null check in auth.js and add a helper function.
-
-## Changes
-
-<file path="src/auth.js" action="replace">
-```javascript
-async function login(user) {
-    if (!user) throw new Error("No user provided");
-    return await db.authenticate(user);
-}
-```
-</file>
-
-<file path="src/utils/validate.js" action="create">
-```javascript
-export const validateUser = (user) => {
-    return user && typeof user.id === 'string';
-};
-```
-</file>
-
-## Metadata
-
-```json
-{
-  "journal": {
-    "type": "fix",
-    "scope": "auth",
-    "summary": "Add null check and validation helper"
-  }
-}
-```
-````
-```
-
-### Why This Format?
-
-1. **No escaping hell** - Code is written in standard markdown fences, no `\"` or `\n`
-2. **Readable** - Both humans and AI can easily read and write this format
-3. **Parseable** - XML tags provide clear boundaries for automated processing
-4. **Flexible** - Markdown sections allow for thinking and context
-
-### Important Rules
-
-- Always wrap code in markdown fences (` ``` `) inside `<file>` tags
-- Always include the `path` and `action` attributes on `<file>` tags
-- Use the `## Metadata` section for journal entries and other structured data
-- The `# Analysis` section is optional but recommended for complex tasks
-
-Your other tools (like `bash`) can be used for analysis and validation.

package/src/templates/architect-prompt.template.md

@@ -134,6 +134,31 @@ To understand the project state, you can command the `eck-snapshot` tool directl
 - `eck-snapshot detect`: Analyze the project structure
 - `eck-snapshot restore <snapshot_file> --include ...`: View specific files
 
+## CAPABILITIES & DELEGATION PROTOCOL
+
+You are managing an advanced instance of **Claude Code** equipped with specific plugins and tools. You must structure your commands to leverage these capabilities:
+
+1.  **Token Economy (MiniMax Swarm):**
+    *   **Goal:** Save money and Claude's context window.
+    *   **Rule:** NEVER ask Claude to write >50 lines of code from scratch or refactor huge files personally.
+    *   **Command:** Instruct Claude to use the `minimax_worker` MCP tool.
+    *   **Phrasing:** "Delegate the implementation of [feature] to MiniMax Backend Worker. Review their output."
+
+2.  **Self-Correction (The Ralph Loop):**
+    *   **Goal:** Autonomous task completion.
+    *   **Rule:** Tasks like "Fix bugs" or "Make tests pass" imply iteration.
+    *   **Command:** Explicitly tell Claude: "Do not report back on the first error. Read the error, fix the code, and retry. Only report back when tests pass or after 3 failed attempts."
+
+3.  **Project Memory (.eck context):**
+    *   **Goal:** Instant onboarding.
+    *   **Command:** "Read `.eck/CONTEXT.md` and `.eck/TECH_DEBT.md` before starting to understand the architectural constraints."
+
+### AVAILABLE EXECUTION AGENTS
+
+You can command multiple specialized agents. **YOU must choose the most appropriate agent** based on the task requirements and target environment:
+
+{{agentDefinitions}}
+
 ## Final Mandate
 
 Your existence is defined by this loop. Think, act by issuing a command using Eck-Protocol v2, and then wait for the observation. This is the only way you can make progress.

package/src/utils/aiHeader.js

@@ -22,19 +22,57 @@ function render(template, data) {
   return output;
 }
 
-function buildAgentDefinitions(executionAgents) {
+/**
+ * Filters execution agents based on the current mode.
+ * Senior Architect should only see relevant agents, not internal workers.
+ */
+function getVisibleAgents(executionAgents, options) {
+  const visible = {};
+
+  // 1. Define Standard Coders (Always available as fallback)
+  // These keys must match IDs in setup.json
+  const standardCoders = ['local_dev', 'production_server', 'android_wsl_dev'];
+
+  // 2. Determine Priority Agent (The Junior Architect)
+  let priorityAgentKey = null;
+  if (options.jas) priorityAgentKey = 'jas';
+  if (options.jao) priorityAgentKey = 'jao';
+  if (options.jag) priorityAgentKey = 'jag';
+
+  // 3. Build the list
+  // If a JA is selected, add them FIRST with a note
+  if (priorityAgentKey && executionAgents[priorityAgentKey]) {
+    const ja = executionAgents[priorityAgentKey];
+    visible[priorityAgentKey] = {
+      ...ja,
+      description: `⭐ **PRIMARY AGENT** ⭐ ${ja.description} (Delegates to MiniMax)`
+    };
+  }
+
+  // Add standard coders
+  for (const key of standardCoders) {
+    if (executionAgents[key] && executionAgents[key].active) {
+      visible[key] = executionAgents[key];
+    }
+  }
+
+  // NOTE: We deliberately EXCLUDE 'minimax_worker' here.
+  // The Senior Architect does not call MiniMax directly; the JA does.
+
+  return visible;
+}
+
+function buildAgentDefinitions(filteredAgents) {
   let definitions = '';
-  for (const key in executionAgents) {
-    const agent = executionAgents[key];
-    if (agent.active) {
-      definitions += `
+  for (const key in filteredAgents) {
+    const agent = filteredAgents[key];
+    definitions += `
 ### ${agent.name} (ID: "${key}")
 - **Description:** ${agent.description}
 - **GUI Support:** ${agent.guiSupport ? 'Yes' : 'No (Headless)'}
 - **Capabilities:** ${agent.capabilities.join(', ')}
 - **Restrictions:** ${agent.restrictions.join(', ')}
 `;
-    }
   }
   return definitions;
 }
@@ -290,35 +328,67 @@ export async function generateEnhancedAIHeader(context, isGitRepo = false) {
     // --- End context building ---
 
 
-    // Check if agent mode is enabled
-    if (context.options && context.options.agent) {
-      const agentPromptTemplate = await loadTemplate(promptTemplates.agent);
+    // --- LOGIC CHANGE: Snapshot is ALWAYS for Senior Architect ---
+    // The `agent` prompt template is used ONLY in CLAUDE.md (via claudeMdGenerator.js)
+    // NOT in the snapshot itself.
 
-      const agentHeader = `${agentPromptTemplate}
+    const isJag = context.options && context.options.jag;
+    const isJas = context.options && context.options.jas;
+    const isJao = context.options && context.options.jao;
+    const isJaMode = isJag || isJas || isJao;
 
-${projectOverview}
-${eckManifestSection}
----
-
-## Project Snapshot Information
+    // --- Determine Workflow Content based on JA Flag ---
+    let hierarchicalWorkflow = '';
+    let commandFormats = '';
 
-- **Project**: ${context.repoName || 'Unknown'}
-- **Timestamp**: ${new Date().toISOString()}
-- **Files Included**: ${context.stats ? context.stats.includedFiles : 'Unknown'}
-- **Total Files in Repo**: ${context.stats ? context.stats.totalFiles : 'Unknown'}
+    if (isJaMode) {
+      // Instructions strictly for the Senior Architect on how to use the JA
+      hierarchicalWorkflow = `### 👑 ROYAL COURT ARCHITECTURE (Active)
 
----
+You are the **Senior Architect**. You have a **Junior Architect** available to handle implementation.
 
+**PROTOCOL:**
+1.  **Prefer Delegation:** Unless the task is trivial (1-2 file edits), assign it to the **Junior Architect** (ID: \`jas\`, \`jao\`, or \`jag\` - see agents list above).
+2.  **Direct Execution:** Only use \`local_dev\` or \`production_server\` directly if the Junior Architect fails or for simple "hotfixes".
+3.  **No Micro-Management:** Do not tell the Junior Architect *how* to use MiniMax or internal tools. Just give them the strategic objective.
 `;
-      return agentHeader;
-    }
 
-    // --- Determine Workflow Content based on JA Flag ---
-    const withJa = context.options && context.options.withJa;
-    let hierarchicalWorkflow = '';
-    let commandFormats = '';
+      commandFormats = `### COMMAND FORMATS (Eck-Protocol v2)
+
+You MUST use the **Eck-Protocol v2** format for all code execution tasks. This format combines Markdown for analysis, XML tags for file operations, and JSON for routing metadata.
+
+**CRITICAL DISPLAY RULE (THE 4-BACKTICK WRAPPER):**
+To ensure your command is copy-pasteable without breaking UI rendering, you **MUST** wrap the ENTIRE protocol output in a \`text\` block using **QUADRUPLE BACKTICKS** (\` \`\`\`\` \`).
+
+**Why?** Your command contains internal code blocks with 3 backticks. To escape them, the outer container needs 4.
+
+**Required Output Format:**
+
+\`\`\`\`text
+# Analysis
+[Your reasoning...]
+
+## Changes
+<file path="example.js" action="replace">
+\\\`\\\`\\\`javascript
+// Internal code block uses 3 backticks
+const x = 1;
+\\\`\\\`\\\`
+</file>
 
-    if (withJa) {
+## Metadata
+\\\`\\\`\\\`json
+{ "target_agent": "jas", "task_id": "unique-id" }
+\\\`\\\`\\\`
+\`\`\`\`
+
+**File Actions:**
+- \`create\`: Create a new file (requires full content)
+- \`replace\`: Overwrite existing file (requires full content)
+- \`modify\`: Replace specific sections (provide context)
+- \`delete\`: Delete the file
+`;
+    } else if (context.options && context.options.withJa) {
       hierarchicalWorkflow = `### HIERARCHICAL AGENT WORKFLOW
 
 Your primary role is **Senior Architect**. You formulate high-level strategy. For complex code implementation, you will delegate to a **Junior Architect** agent (\`gemini_wsl\`), who has a detailed (\`_ja.md\`) snapshot and the ability to command a **Coder** agent (\`claude\`).
@@ -461,16 +531,8 @@ const x = 1;
     template = template.replace('{{eckManifestSection}}', eckManifestSection);
     // --- END INJECT ---
 
-    // Filter out gemini agents if not in JA mode
-    const filteredExecutionAgents = {};
-    for (const [key, agent] of Object.entries(executionAgents)) {
-      const isGeminiAgent = key.includes('gemini') || (agent.name && agent.name.toLowerCase().includes('gemini'));
-      if (isGeminiAgent) {
-        if (withJa && agent.active) filteredExecutionAgents[key] = agent;
-      } else {
-        if (agent.active) filteredExecutionAgents[key] = agent;
-      }
-    }
+    // Use the new filtering function to get visible agents
+    const filteredExecutionAgents = getVisibleAgents(executionAgents, context.options || {});
 
     const agentDefinitions = buildAgentDefinitions(filteredExecutionAgents);
 

package/src/utils/claudeMdGenerator.js

@@ -0,0 +1,148 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Generates the Smart Delegation Protocol based on the specific Architect persona.
+ */
+function getArchitectInstructions(modelName, tree) {
+  const isOpus = modelName.includes('Opus');
+
+  return `# 🧠 ROLE: Junior Architect (${modelName})
+
+## 1. PROJECT CONTEXT & MEMORY
+You are working inside the repository.
+- **Source of Truth:** The file system is your source of truth.
+- **Documentation:** The \`.eck/\` directory contains project context. READ filenames to understand what is available.
+- **Directory Structure:**
+\`\`\`
+${tree}
+\`\`\`
+
+## 2. SMART DELEGATION PROTOCOL (TOKEN ECONOMY)
+
+### A. Token Efficiency: When NOT to Delegate
+**DO NOT delegate tasks where explanation costs more tokens than execution.**
+* *Examples:*
+  - Reading a config file → Just use \`Read\` tool (1 tool call vs explaining to MiniMax)
+  - Checking if file exists → Use \`Bash test -f\` or \`Read\`
+  - Fixing a typo → Use \`Edit\` tool directly
+  - Writing < 50 lines of glue code
+* **Rule:** If you can solve it in 1-2 tool calls, DO IT YOURSELF.
+
+### B. Heavy Lifting (DELEGATE TO MINIMAX)
+For bulk work where delegation saves YOUR expensive context:
+* *Examples:*
+  - Implementing complex business logic (> 100 lines)
+  - Refactoring entire modules
+  - Writing comprehensive test suites
+  - Generating boilerplate code
+* **Action:** Use \`minimax_backend\`, \`minimax_frontend\`, \`minimax_qa\`, or \`minimax_refactor\`.
+
+## 3. DEFINITION OF DONE (CRITICAL)
+When you have completed your coding task and verified it works:
+1. **DO NOT** run \`git commit\` manually.
+2. **DO NOT** just say "I'm done".
+3. **YOU MUST use the tool \`eck_finish_task\`**.
+   - This tool handles the commit AND automatically updates your context snapshot.
+   - Using this tool is the ONLY way to successfully close a task.
+
+## 4. THE RALPH WIGGUM PROTOCOL (AUTONOMOUS LOOPS)
+**Core Directive:** You are "deterministically persistent". Failures are expected, giving up is not.
+
+1.  **Iterative Correction:**
+    *   If a build fails or tests turn red: **DO NOT STOP**.
+    *   **Read** the error message.
+    *   **Think** about the cause.
+    *   **Fix** the code.
+    *   **Retry** the verification command.
+    *   *Repeat this loop up to 3-4 times.*
+
+2.  **Intelligent Retry (MiniMax Supervision):**
+    *   If a MiniMax worker produces bad code:
+    *   **DON'T** repeat the same prompt.
+    *   **Analyze WHY** it failed (missing context? wrong import?).
+    *   **Guide** the worker: "Previous attempt failed because X. Try again using pattern Y."
+    *   **Takeover:** If MiniMax fails twice, **DO IT YOURSELF**.
+
+3.  **Definition of Done:**
+    *   A task is ONLY done when the verification command (e.g., \`npm test\`) exits with code 0.
+    *   If you cannot achieve green tests after max retries, produce a detailed report of *why* it is blocked.
+
+## 5. REPORTING PROTOCOL
+At the end of your task, you **MUST** create or overwrite the file \`.eck/AnswerToSA.md\` BEFORE calling \`eck_finish_task\`.
+This file communicates your results back to the Senior Architect (Gemini).
+
+**Format for .eck/AnswerToSA.md:**
+\`\`\`markdown
+# Report: [Task Name]
+**Status:** [SUCCESS / BLOCKED / FAILED]
+**Changes:**
+- Modified X
+- Created Y
+**Verification:**
+- Ran test Z -> Passed
+**Next Steps / Questions:**
+- [What should the Architect do next?]
+\`\`\`
+
+## 6. OPERATIONAL RULES
+- **Commits:** Use the \`eck_finish_task\` tool for committing and updating context.
+- **Manifests:** If you see [STUB] in .eck/ files, update them.
+- **Reporting:** NEVER finish a session without writing \`.eck/AnswerToSA.md\` and calling \`eck_finish_task\`.
+`;
+}
+
+const CODER_INSTRUCTIONS = `# 🛠️ ROLE: Expert Developer (The Fixer)
+
+## CORE DIRECTIVE
+You are an Expert Developer. The architecture is already decided. Your job is to **execute**, **fix**, and **polish**.
+
+## DEFINITION OF DONE (CRITICAL)
+When the task is complete:
+1. **UPDATE** the \`.eck/AnswerToSA.md\` file with your status.
+2. **CALL** the tool \`eck_finish_task\` to commit and sync context.
+3. **DO NOT** use raw git commands for the final commit.
+
+## CONTEXT
+- The MiniMax swarm might have struggled or produced code that needs refinement.
+- You are here to solve the hard problems manually.
+- You have full permission to edit files directly.
+
+## WORKFLOW
+1.  Read the code.
+2.  Fix the bugs / Implement the feature.
+3.  Verify functionality (Run tests!).
+4.  **Loop:** If verification fails, fix it immediately. Do not ask for permission.
+`;
+
+/**
+ * Generates and writes the CLAUDE.md file based on the selected mode.
+ */
+export async function updateClaudeMd(repoPath, mode, tree, confidentialFiles = []) {
+  let content = '';
+
+  if (mode === 'jas') {
+    content = getArchitectInstructions('Sonnet 4.5', tree);
+  } else if (mode === 'jao') {
+    content = getArchitectInstructions('Opus 4.5', tree);
+  } else if (mode === 'jag') {
+    content = getArchitectInstructions('Gemini 3 Pro', tree);
+  } else {
+    // Default coder mode (or if flags are missing)
+    content = CODER_INSTRUCTIONS;
+  }
+
+  // Append Confidential Files Reference
+  if (confidentialFiles.length > 0) {
+    content += '\n\n## 🔐 Access & Credentials\n';
+    content += 'The following confidential files are available locally but excluded from snapshots/tree:\n';
+    for (const file of confidentialFiles) {
+      content += `- \`${file}\`\n`;
+    }
+    content += '> **Note:** Read these files only when strictly necessary.\n';
+  }
+
+  const claudeMdPath = path.join(repoPath, 'CLAUDE.md');
+  await fs.writeFile(claudeMdPath, content, 'utf-8');
+  console.log(`📝 Updated CLAUDE.md for role: **${mode.toUpperCase()}** (Ralph Loop + MiniMax Protocol Active)`);
+}

package/src/utils/fileUtils.js

@@ -262,8 +262,8 @@ export async function generateDirectoryTree(dir, prefix = '', allFiles, depth =
     
     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('.')) {
+      // 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;
@@ -283,19 +283,20 @@ export async function generateDirectoryTree(dir, prefix = '', allFiles, depth =
 
       if (entry.isDirectory()) {
         tree += `${prefix}${connector}${entry.name}/\n`;
-        tree += await generateDirectoryTree(fullPath, nextPrefix, allFiles, depth + 1, maxDepth, config);
+
+        // RECURSION CONTROL:
+        // If we are currently inside .eck, do NOT recurse deeper into subdirectories (like snapshots, logs).
+        // We want to see that 'snapshots/' exists, but not list its contents.
+        const isInsideEckRoot = path.basename(dir) === '.eck';
+
+        if (!isInsideEckRoot) {
+          tree += await generateDirectoryTree(fullPath, nextPrefix, allFiles, depth + 1, maxDepth, config);
+        }
       } else {
         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}`);
@@ -406,13 +407,13 @@ export async function loadConfig(configPath) {
 
 export function generateTimestamp() {
   const now = new Date();
-  const YYYY = now.getFullYear();
+  const YY = String(now.getFullYear()).slice(-2);
   const MM = String(now.getMonth() + 1).padStart(2, '0');
   const DD = String(now.getDate()).padStart(2, '0');
   const hh = String(now.getHours()).padStart(2, '0');
   const mm = String(now.getMinutes()).padStart(2, '0');
-  const ss = String(now.getSeconds()).padStart(2, '0');
-  return `${YYYY}-${MM}-${DD}_${hh}-${mm}-${ss}`;
+  // Compact format: YY-MM-DD_HH-mm (no seconds)
+  return `${YY}-${MM}-${DD}_${hh}-${mm}`;
 }
 
 /**