aether-colony 3.1.4 → 3.1.15

package/bin/lib/state-sync.js

@@ -10,6 +10,96 @@
 
 const fs = require('fs');
 const path = require('path');
+const { FileLock } = require('./file-lock');
+
+/**
+ * Default maximum number of events to keep (PLAN-007 Fix 2)
+ */
+const DEFAULT_MAX_EVENTS = 100;
+
+/**
+ * Prune events array to prevent unbounded growth (PLAN-007 Fix 2)
+ * @param {Array} events - Events array to prune
+ * @param {number} maxEvents - Maximum number of events to keep
+ * @returns {Array} Pruned events array (most recent by timestamp)
+ */
+function pruneEvents(events, maxEvents = DEFAULT_MAX_EVENTS) {
+  if (!Array.isArray(events)) return events;
+  if (events.length <= maxEvents) return events;
+
+  // Keep most recent events by timestamp
+  const sorted = [...events].sort((a, b) => {
+    const timeA = a.timestamp ? new Date(a.timestamp).getTime() : 0;
+    const timeB = b.timestamp ? new Date(b.timestamp).getTime() : 0;
+    return timeB - timeA; // Descending (most recent first)
+  });
+
+  return sorted.slice(0, maxEvents);
+}
+
+/**
+ * State schema definition for validation (PLAN-007 Fix 3)
+ */
+const STATE_SCHEMA = {
+  version: { required: true, type: 'string' },
+  current_phase: { required: true, type: 'number' },
+  events: { required: true, type: 'array' },
+  goal: { required: false, type: 'string' },
+  state: { required: false, type: 'string' },
+};
+
+/**
+ * Validate state object against schema (PLAN-007 Fix 3)
+ * @param {object} state - State object to validate
+ * @returns {object} Validation result: { valid: boolean, errors: string[] }
+ */
+function validateStateSchema(state) {
+  const errors = [];
+
+  // Check state is a non-null object
+  if (!state || typeof state !== 'object' || Array.isArray(state)) {
+    return { valid: false, errors: ['State must be a non-null object'] };
+  }
+
+  // Validate each field against schema
+  for (const [field, config] of Object.entries(STATE_SCHEMA)) {
+    // Check required fields
+    if (config.required && !(field in state)) {
+      errors.push(`Missing required field: ${field}`);
+      continue;
+    }
+
+    // Check types for present non-null fields
+    if ((field in state) && state[field] !== null && state[field] !== undefined) {
+      const actualType = Array.isArray(state[field]) ? 'array' : typeof state[field];
+      if (actualType !== config.type) {
+        errors.push(`Field "${field}" must be ${config.type}, got ${actualType}`);
+      }
+    }
+  }
+
+  // Validate events array elements
+  if (Array.isArray(state.events)) {
+    for (let i = 0; i < state.events.length; i++) {
+      const event = state.events[i];
+      if (!event || typeof event !== 'object') {
+        errors.push(`events[${i}] must be an object`);
+        continue;
+      }
+      if (!event.timestamp) {
+        errors.push(`events[${i}] missing required field: timestamp`);
+      }
+      if (!event.type) {
+        errors.push(`events[${i}] missing required field: type`);
+      }
+      if (!event.worker) {
+        errors.push(`events[${i}] missing required field: worker`);
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
 
 /**
  * Parse STATE.md markdown content to extract current state
@@ -75,6 +165,11 @@ function parseRoadmapMd(content) {
     const phaseNum = parseInt(match[1], 10);
     const phaseName = match[2].trim();
 
+    // Warn on unreasonable phase numbers (PLAN-006 fix #8)
+    if (phaseNum > 100 || phaseNum < 0) {
+      console.warn(`Warning: Unusual phase number ${phaseNum} in ROADMAP.md`);
+    }
+
     // Look for status indicators near this phase
     const sectionStart = match.index;
     const nextPhaseMatch = phaseRegex.exec(content);
@@ -110,8 +205,13 @@ function parseRoadmapMd(content) {
  * @returns {string} Colony state: INITIALIZING|PLANNING|BUILDING|COMPLETED
  */
 function determineColonyState(status, phase) {
+  // No status - determine by phase (PLAN-006 fix #7)
   if (!status) {
-    return 'INITIALIZING';
+    if (phase === null || phase === undefined) {
+      return 'INITIALIZING';
+    }
+    // Phase 0 can be valid - don't force INITIALIZING
+    return phase === 0 ? 'PLANNING' : 'BUILDING';
   }
 
   const statusLower = status.toLowerCase();
@@ -128,47 +228,109 @@ function determineColonyState(status, phase) {
     return 'BUILDING';
   }
 
-  // Default based on phase
-  if (phase === 0) {
-    return 'INITIALIZING';
-  }
-
-  return 'BUILDING';
+  // Default based on phase - Phase 0 is PLANNING, not INITIALIZING
+  return phase === 0 ? 'PLANNING' : 'BUILDING';
 }
 
 /**
  * Synchronize COLONY_STATE.json with .planning/STATE.md
  * @param {string} repoPath - Path to repository root
- * @returns {object} Sync result: { synced: boolean, updates: string[], error?: string }
+ * @returns {object} Sync result: { synced: boolean, updates: string[], error?: string, recovery?: string }
  */
 function syncStateFromPlanning(repoPath) {
   const updates = [];
+  const lockDir = path.join(repoPath, '.aether', 'locks');
+  const colonyStatePath = path.join(repoPath, '.aether', 'data', 'COLONY_STATE.json');
+
+  // Create lock instance
+  const lock = new FileLock({
+    lockDir,
+    timeout: 5000,
+    maxRetries: 50
+  });
+
+  // Attempt to acquire lock
+  if (!lock.acquire(colonyStatePath)) {
+    return {
+      synced: false,
+      updates: [],
+      error: 'Could not acquire state lock - another sync in progress'
+    };
+  }
 
   try {
-    // Read STATE.md
+    // Read STATE.md with improved error handling (PLAN-006 fix #9)
     const stateMdPath = path.join(repoPath, '.planning', 'STATE.md');
-    if (!fs.existsSync(stateMdPath)) {
-      return { synced: false, updates: [], error: 'STATE.md not found' };
+    try {
+      if (!fs.existsSync(stateMdPath)) {
+        return { synced: false, updates: [], error: '.planning/STATE.md not found' };
+      }
+    } catch (accessError) {
+      if (accessError.code === 'EACCES') {
+        return { synced: false, updates: [], error: '.planning/STATE.md not accessible (permission denied)' };
+      }
+      return { synced: false, updates: [], error: `Failed to check STATE.md: ${accessError.message}` };
     }
 
-    const stateMdContent = fs.readFileSync(stateMdPath, 'utf8');
+    let stateMdContent;
+    try {
+      stateMdContent = fs.readFileSync(stateMdPath, 'utf8');
+    } catch (readError) {
+      if (readError.code === 'EACCES') {
+        return { synced: false, updates: [], error: '.planning/STATE.md not readable (permission denied)' };
+      }
+      return { synced: false, updates: [], error: `Failed to read STATE.md: ${readError.message}` };
+    }
     const planningState = parseStateMd(stateMdContent);
 
     // Read ROADMAP.md for phases
     const roadmapPath = path.join(repoPath, '.planning', 'ROADMAP.md');
     let phases = [];
     if (fs.existsSync(roadmapPath)) {
-      const roadmapContent = fs.readFileSync(roadmapPath, 'utf8');
-      phases = parseRoadmapMd(roadmapContent);
+      try {
+        const roadmapContent = fs.readFileSync(roadmapPath, 'utf8');
+        phases = parseRoadmapMd(roadmapContent);
+      } catch (roadmapError) {
+        // Non-fatal - phases are optional
+        console.warn(`Warning: Could not read ROADMAP.md: ${roadmapError.message}`);
+      }
     }
 
-    // Read current COLONY_STATE.json
-    const colonyStatePath = path.join(repoPath, '.aether', 'data', 'COLONY_STATE.json');
-    if (!fs.existsSync(colonyStatePath)) {
-      return { synced: false, updates: [], error: 'COLONY_STATE.json not found' };
+    // Read current COLONY_STATE.json with improved error handling
+    try {
+      if (!fs.existsSync(colonyStatePath)) {
+        return { synced: false, updates: [], error: '.aether/data/COLONY_STATE.json not found' };
+      }
+    } catch (accessError) {
+      if (accessError.code === 'EACCES') {
+        return { synced: false, updates: [], error: 'COLONY_STATE.json not accessible (permission denied)' };
+      }
+      return { synced: false, updates: [], error: `Failed to check COLONY_STATE.json: ${accessError.message}` };
+    }
+
+    // Parse JSON with error handling (PLAN-002)
+    let colonyState;
+    try {
+      colonyState = JSON.parse(fs.readFileSync(colonyStatePath, 'utf8'));
+    } catch (parseError) {
+      return {
+        synced: false,
+        updates: [],
+        error: `COLONY_STATE.json contains invalid JSON: ${parseError.message}`,
+        recovery: 'Manually fix or delete .aether/data/COLONY_STATE.json and reinitialize'
+      };
     }
 
-    const colonyState = JSON.parse(fs.readFileSync(colonyStatePath, 'utf8'));
+    // Validate state schema before any modifications (PLAN-007 Fix 3)
+    const validation = validateStateSchema(colonyState);
+    if (!validation.valid) {
+      return {
+        synced: false,
+        updates: [],
+        error: `State schema validation failed: ${validation.errors.join('; ')}`,
+        recovery: 'Fix state schema errors or restore from backup'
+      };
+    }
 
     // Track if any changes were made
     let changed = false;
@@ -224,11 +386,16 @@ function syncStateFromPlanning(repoPath) {
         }
       });
 
+      // Prune events to prevent unbounded growth (PLAN-007 Fix 2)
+      colonyState.events = pruneEvents(colonyState.events);
+
       // Update last_updated
       colonyState.last_updated = new Date().toISOString();
 
-      // Write updated state
-      fs.writeFileSync(colonyStatePath, JSON.stringify(colonyState, null, 2) + '\n');
+      // Atomic write: write to temp file, then rename (PLAN-002)
+      const tempPath = `${colonyStatePath}.tmp`;
+      fs.writeFileSync(tempPath, JSON.stringify(colonyState, null, 2) + '\n');
+      fs.renameSync(tempPath, colonyStatePath);
     }
 
     return {
@@ -243,6 +410,9 @@ function syncStateFromPlanning(repoPath) {
       updates: [],
       error: error.message
     };
+  } finally {
+    // Always release lock
+    lock.release();
   }
 }
 
@@ -278,7 +448,17 @@ function reconcileStates(repoPath) {
       };
     }
 
-    const colonyState = JSON.parse(fs.readFileSync(colonyStatePath, 'utf8'));
+    // Parse JSON with error handling
+    let colonyState;
+    try {
+      colonyState = JSON.parse(fs.readFileSync(colonyStatePath, 'utf8'));
+    } catch (parseError) {
+      return {
+        consistent: false,
+        mismatches: [`COLONY_STATE.json contains invalid JSON: ${parseError.message}`],
+        resolution: 'Manually fix or delete .aether/data/COLONY_STATE.json and reinitialize'
+      };
+    }
 
     // Check phase mismatch
     if (planningState.phase !== null && planningState.phase !== colonyState.current_phase) {
@@ -329,5 +509,8 @@ module.exports = {
   determineColonyState,
   syncStateFromPlanning,
   reconcileStates,
-  updateColonyStateFromPlanning
+  updateColonyStateFromPlanning,
+  validateStateSchema,
+  pruneEvents,
+  DEFAULT_MAX_EVENTS,
 };

package/bin/lib/update-transaction.js

@@ -144,11 +144,13 @@ class UpdateTransaction {
    * @param {object} options - Transaction options
    * @param {string} options.sourceVersion - Version to update to
    * @param {boolean} options.quiet - Suppress output
+   * @param {boolean} options.force - Force update even with dirty files
    */
   constructor(repoPath, options = {}) {
     this.repoPath = repoPath;
     this.sourceVersion = options.sourceVersion || null;
     this.quiet = options.quiet || false;
+    this.force = options.force || false;
 
     // Transaction state
     this.state = TransactionStates.PENDING;
@@ -159,14 +161,15 @@ class UpdateTransaction {
     // Hub paths (from cli.js)
     this.HOME = process.env.HOME || process.env.USERPROFILE;
     this.HUB_DIR = path.join(this.HOME, '.aether');
-    this.HUB_SYSTEM = path.join(this.HUB_DIR, 'system');
     this.HUB_COMMANDS_CLAUDE = path.join(this.HUB_DIR, 'commands', 'claude');
     this.HUB_COMMANDS_OPENCODE = path.join(this.HUB_DIR, 'commands', 'opencode');
     this.HUB_AGENTS = path.join(this.HUB_DIR, 'agents');
-    this.HUB_VISUALIZATIONS = path.join(this.HUB_DIR, 'visualizations');
     this.HUB_VERSION = path.join(this.HUB_DIR, 'version.json');
     this.HUB_REGISTRY = path.join(this.HUB_DIR, 'registry.json');
 
+    // Directories to exclude from sync (user data, local state)
+    this.EXCLUDE_DIRS = ['data', 'dreams', 'checkpoints', 'locks', 'temp'];
+
     // Target directories for git safety checks
     this.targetDirs = ['.aether', '.claude/commands/ant', '.opencode/commands/ant', '.opencode/agents'];
 
@@ -183,15 +186,36 @@ class UpdateTransaction {
       'verification-loop.md',
       'verification.md',
       'workers.md',
+      'workers-new-castes.md',
+      'docs/biological-reference.md',
+      'docs/command-sync.md',
       'docs/constraints.md',
+      'docs/namespace.md',
       'docs/pathogen-schema-example.json',
       'docs/pathogen-schema.md',
+      'docs/PHEROMONE-INJECTION.md',
+      'docs/PHEROMONE-INTEGRATION.md',
+      'docs/PHEROMONE-SYSTEM-DESIGN.md',
       'docs/pheromones.md',
       'docs/progressive-disclosure.md',
+      'docs/README.md',
+      'docs/VISUAL-OUTPUT-SPEC.md',
+      'docs/known-issues.md',
+      'docs/implementation-learnings.md',
+      'docs/codebase-review.md',
+      'docs/planning-discipline.md',
       'utils/atomic-write.sh',
+      'utils/chamber-compare.sh',
+      'utils/chamber-utils.sh',
       'utils/colorize-log.sh',
+      'utils/error-handler.sh',
       'utils/file-lock.sh',
+      'utils/spawn-tree.sh',
+      'utils/spawn-with-model.sh',
+      'utils/state-loader.sh',
+      'utils/swarm-display.sh',
       'utils/watch-spawn-tree.sh',
+      'templates/QUEEN.md.template',
     ];
   }
 
@@ -330,6 +354,12 @@ class UpdateTransaction {
       return { clean: true };
     }
 
+    // If force flag is set, allow dirty repo (will be stashed in checkpoint)
+    if (this.force) {
+      this.log('  Force flag set: proceeding with dirty repository (will stash changes)');
+      return { clean: true, dirty: dirtyState, force: true };
+    }
+
     // Build detailed error message
     const lines = [
       'Cannot update: repository has uncommitted changes',
@@ -405,16 +435,48 @@ class UpdateTransaction {
    */
   gitStashFiles(files) {
     try {
-      const fileArgs = files.map(f => `"${f}"`).join(' ');
-      execSync(`git stash push -m "aether-update-backup" -- ${fileArgs}`, {
-        cwd: this.repoPath,
-        stdio: 'pipe',
-      });
+      // Separate tracked and untracked files
+      const trackedFiles = [];
+      const untrackedFiles = [];
+
+      for (const file of files) {
+        const fullPath = path.join(this.repoPath, file);
+        try {
+          // Check if file is tracked by git
+          execSync(`git ls-files --error-unmatch "${file}"`, {
+            cwd: this.repoPath,
+            stdio: 'pipe'
+          });
+          trackedFiles.push(file);
+        } catch {
+          // File is not tracked (untracked or in .gitignore)
+          untrackedFiles.push(file);
+        }
+      }
 
-      // Get the stash reference
-      const stashList = execSync('git stash list', { cwd: this.repoPath, encoding: 'utf8' });
-      const match = stashList.match(/^(stash@\{[^}]+\})/m);
-      return match ? match[1] : null;
+      let stashRef = null;
+
+      // Stash tracked files
+      if (trackedFiles.length > 0) {
+        const fileArgs = trackedFiles.map(f => `"${f}"`).join(' ');
+        execSync(`git stash push -m "aether-update-backup" -- ${fileArgs}`, {
+          cwd: this.repoPath,
+          stdio: 'pipe',
+        });
+
+        // Get the stash reference
+        const stashList = execSync('git stash list', { cwd: this.repoPath, encoding: 'utf8' });
+        const match = stashList.match(/^(stash@\{[^}]+\})/m);
+        stashRef = match ? match[1] : null;
+      }
+
+      // For untracked files, we can't stash them easily
+      // Just log a warning - they'll be left as-is during the update
+      if (untrackedFiles.length > 0) {
+        this.log(`  Note: ${untrackedFiles.length} untracked files won't be stashed (left in place)`);
+      }
+
+      return stashRef;
     } catch (err) {
       this.log(`  Warning: git stash failed (${err.message}). Proceeding without stash.`);
       return null;
@@ -684,6 +746,127 @@ class UpdateTransaction {
     return { copied, removed, skipped };
   }
 
+  /**
+   * Check if a path should be excluded from sync
+   * @param {string} relPath - Relative path
+   * @returns {boolean} True if should be excluded
+   * @private
+   */
+  shouldExclude(relPath) {
+    const parts = relPath.split(path.sep);
+    return parts.some(part => this.EXCLUDE_DIRS.includes(part));
+  }
+
+  /**
+   * Sync .aether/ directory from hub to repo, excluding user data directories
+   * @param {string} srcDir - Source hub directory
+   * @param {string} destDir - Destination repo .aether/ directory
+   * @param {object} opts - Options
+   * @returns {object} Sync result: { copied, removed, skipped }
+   * @private
+   */
+  syncAetherToRepo(srcDir, destDir, opts) {
+    opts = opts || {};
+    const dryRun = opts.dryRun || false;
+
+    if (!fs.existsSync(srcDir)) {
+      return { copied: 0, removed: [], skipped: 0 };
+    }
+
+    // Collect all files in source, filtering out excluded directories
+    const srcFiles = [];
+    const collectFiles = (dir, base) => {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith('.')) continue;
+        const fullPath = path.join(dir, entry.name);
+        const relPath = path.relative(base, fullPath);
+
+        if (this.shouldExclude(relPath)) continue;
+
+        if (entry.isDirectory()) {
+          collectFiles(fullPath, base);
+        } else {
+          srcFiles.push(relPath);
+        }
+      }
+    };
+    collectFiles(srcDir, srcDir);
+
+    // Copy files with hash comparison
+    let copied = 0;
+    let skipped = 0;
+    for (const relPath of srcFiles) {
+      const srcPath = path.join(srcDir, relPath);
+      const destPath = path.join(destDir, relPath);
+
+      if (!dryRun) {
+        fs.mkdirSync(path.dirname(destPath), { recursive: true });
+
+        // Hash comparison
+        let shouldCopy = true;
+        if (fs.existsSync(destPath)) {
+          const srcHash = this.hashFileSync(srcPath);
+          const destHash = this.hashFileSync(destPath);
+          if (srcHash === destHash) {
+            shouldCopy = false;
+            skipped++;
+          }
+        }
+
+        if (shouldCopy) {
+          fs.copyFileSync(srcPath, destPath);
+          if (relPath.endsWith('.sh')) {
+            fs.chmodSync(destPath, 0o755);
+          }
+        }
+      }
+      copied++;
+    }
+
+    // Cleanup: remove files in dest that aren't in source
+    const destFiles = [];
+    const collectDestFiles = (dir, base) => {
+      if (!fs.existsSync(dir)) return;
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith('.')) continue;
+        const fullPath = path.join(dir, entry.name);
+        const relPath = path.relative(base, fullPath);
+
+        if (this.shouldExclude(relPath)) continue;
+
+        if (entry.isDirectory()) {
+          collectDestFiles(fullPath, base);
+        } else {
+          destFiles.push(relPath);
+        }
+      }
+    };
+    collectDestFiles(destDir, destDir);
+
+    const srcSet = new Set(srcFiles);
+    const removed = [];
+    for (const relPath of destFiles) {
+      if (!srcSet.has(relPath)) {
+        removed.push(relPath);
+        if (!dryRun) {
+          try {
+            fs.unlinkSync(path.join(destDir, relPath));
+          } catch (err) {
+            // Ignore cleanup errors
+          }
+        }
+      }
+    }
+
+    if (!dryRun && removed.length > 0) {
+      this.cleanEmptyDirs(destDir);
+    }
+
+    return { copied, removed, skipped };
+  }
+
   /**
    * Sync files from hub to repo
    * @param {string} sourceVersion - Version to sync from
@@ -697,15 +880,14 @@ class UpdateTransaction {
       system: { copied: 0, removed: 0, skipped: 0 },
       commands: { copied: 0, removed: 0, skipped: 0 },
       agents: { copied: 0, removed: 0, skipped: 0 },
-      visualizations: { copied: 0, removed: 0, skipped: 0 },
       errors: [],
     };
 
     const repoAether = path.join(this.repoPath, '.aether');
 
-    // Sync system files from hub
-    if (fs.existsSync(this.HUB_SYSTEM)) {
-      results.system = this.syncSystemFilesWithCleanup(this.HUB_SYSTEM, repoAether, { dryRun });
+    // Sync .aether/ from hub to repo (excluding user data directories)
+    if (fs.existsSync(this.HUB_DIR)) {
+      results.system = this.syncAetherToRepo(this.HUB_DIR, repoAether, { dryRun });
     }
 
     // Sync commands from hub
@@ -729,12 +911,6 @@ class UpdateTransaction {
       results.agents = this.syncDirWithCleanup(this.HUB_AGENTS, repoAgents, { dryRun });
     }
 
-    // Sync visualizations from hub
-    const repoVisualizations = path.join(this.repoPath, '.aether', 'visualizations');
-    if (fs.existsSync(this.HUB_VISUALIZATIONS)) {
-      results.visualizations = this.syncDirWithCleanup(this.HUB_VISUALIZATIONS, repoVisualizations, { dryRun });
-    }
-
     this.syncResult = results;
     return results;
   }
@@ -754,6 +930,9 @@ class UpdateTransaction {
 
       const files = this.listFilesRecursive(hubDir);
       for (const relPath of files) {
+        // Skip excluded directories
+        if (this.shouldExclude(relPath)) continue;
+
         const hubPath = path.join(hubDir, relPath);
         const repoPath = path.join(repoDir, relPath);
 
@@ -774,7 +953,7 @@ class UpdateTransaction {
     };
 
     const repoAether = path.join(this.repoPath, '.aether');
-    verifyDir(this.HUB_SYSTEM, repoAether);
+    verifyDir(this.HUB_DIR, repoAether);
     verifyDir(this.HUB_COMMANDS_CLAUDE, path.join(this.repoPath, '.claude', 'commands', 'ant'));
     verifyDir(this.HUB_COMMANDS_OPENCODE, path.join(this.repoPath, '.opencode', 'commands', 'ant'));
     verifyDir(this.HUB_AGENTS, path.join(this.repoPath, '.opencode', 'agents'));
@@ -819,7 +998,7 @@ class UpdateTransaction {
       }
     };
 
-    checkDir(this.HUB_SYSTEM, 'system');
+    checkDir(this.HUB_DIR, '.aether');
     checkDir(this.HUB_COMMANDS_CLAUDE, 'commands/claude');
     checkDir(this.HUB_COMMANDS_OPENCODE, 'commands/opencode');
     checkDir(this.HUB_AGENTS, 'agents');
@@ -865,6 +1044,9 @@ class UpdateTransaction {
 
       const files = this.listFilesRecursive(hubDir);
       for (const relPath of files) {
+        // Skip excluded directories
+        if (this.shouldExclude(relPath)) continue;
+
         const hubPath = path.join(hubDir, relPath);
         const repoPath = path.join(repoDir, relPath);
 
@@ -916,7 +1098,7 @@ class UpdateTransaction {
     };
 
     const repoAether = path.join(this.repoPath, '.aether');
-    checkDir(this.HUB_SYSTEM, repoAether);
+    checkDir(this.HUB_DIR, repoAether);
     checkDir(this.HUB_COMMANDS_CLAUDE, path.join(this.repoPath, '.claude', 'commands', 'ant'));
     checkDir(this.HUB_COMMANDS_OPENCODE, path.join(this.repoPath, '.opencode', 'commands', 'ant'));
     checkDir(this.HUB_AGENTS, path.join(this.repoPath, '.opencode', 'agents'));